?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed warning "SetWindowText(0, ...)" when opening new windows.
[wine.git] / programs / winefile / winefile.c
blob6bec3932b88c9cb52c52542dba338384fa71abda
1 /*
2 * Winefile
3 *
4 * Copyright 2000 Martin Fuchs
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #ifndef _WIN32
22 #include "config.h"
23 #include "wine/port.h"
24 #endif
25
26 #include "winefile.h"
27 #include "resource.h"
28
29
30 /* for read_directory_unix() */
31 #if !defined(_NO_EXTENSIONS) && !defined(_WIN32)
32 #include <dirent.h>
33 #include <sys/stat.h>
34 #include <unistd.h>
35 #include <time.h>
36 #endif
37
38 #ifdef _NO_EXTENSIONS
39 #undef _LEFT_FILES
40 #endif
41
42 #ifndef _MAX_PATH
43 #define _MAX_DRIVE 3
44 #define _MAX_FNAME 256
45 #define _MAX_DIR _MAX_FNAME
46 #define _MAX_EXT _MAX_FNAME
47 #define _MAX_PATH 260
48 #endif
49
50 WINEFILE_GLOBALS Globals;
51
52 extern void WineLicense(HWND hWnd);
53 extern void WineWarranty(HWND hWnd);
54
55 typedef struct _Entry {
56 struct _Entry* next;
57 struct _Entry* down;
58 struct _Entry* up;
59
60 BOOL expanded;
61 BOOL scanned;
62 int level;
63
64 WIN32_FIND_DATA data;
65
66 #ifndef _NO_EXTENSIONS
67 BY_HANDLE_FILE_INFORMATION bhfi;
68 BOOL bhfi_valid;
69 BOOL unix_dir;
70 #endif
71 } Entry;
72
73 typedef struct {
74 Entry entry;
75 TCHAR path[MAX_PATH];
76 TCHAR volname[_MAX_FNAME];
77 TCHAR fs[_MAX_DIR];
78 DWORD drive_type;
79 DWORD fs_flags;
80 } Root;
81
82 enum COLUMN_FLAGS {
83 COL_SIZE = 0x01,
84 COL_DATE = 0x02,
85 COL_TIME = 0x04,
86 COL_ATTRIBUTES = 0x08,
87 COL_DOSNAMES = 0x10,
88 #ifdef _NO_EXTENSIONS
89 COL_ALL = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES
90 #else
91 COL_INDEX = 0x20,
92 COL_LINKS = 0x40,
93 COL_ALL = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES|COL_INDEX|COL_LINKS
94 #endif
95 };
96
97 typedef enum {
98 SORT_NAME,
99 SORT_EXT,
100 SORT_SIZE,
101 SORT_DATE
102 } SORT_ORDER;
103
104 typedef struct {
105 HWND hwnd;
106 #ifndef _NO_EXTENSIONS
107 HWND hwndHeader;
108 #endif
109
110 #ifndef _NO_EXTENSIONS
111 #define COLUMNS 10
112 #else
113 #define COLUMNS 5
114 #endif
115 int widths[COLUMNS];
116 int positions[COLUMNS+1];
117
118 BOOL treePane;
119 int visible_cols;
120 Entry* root;
121 Entry* cur;
122 } Pane;
123
124 typedef struct {
125 HWND hwnd;
126 Pane left;
127 Pane right;
128 int focus_pane; /* 0: left 1: right */
129 WINDOWPLACEMENT pos;
130 int split_pos;
131 BOOL header_wdths_ok;
132
133 TCHAR path[MAX_PATH];
134 Root root;
135
136 SORT_ORDER sortOrder;
137 } ChildWnd;
138
139
140 static void read_directory(Entry* parent, LPCTSTR path, int sortOrder);
141 static void set_curdir(ChildWnd* child, Entry* entry);
142
143 LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
144 LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
145 LRESULT CALLBACK TreeWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
146
147
148 static void display_error(HWND hwnd, DWORD error)
149 {
150 PTSTR msg;
151
152 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
153 0, error, MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), (PTSTR)&msg, 0, NULL))
154 MessageBox(hwnd, msg, _T("Winefile"), MB_OK);
155 else
156 MessageBox(hwnd, _T("Error"), _T("Winefile"), MB_OK);
157
158 LocalFree(msg);
159 }
160
161
162 static void read_directory_win(Entry* parent, LPCTSTR path)
163 {
164 Entry* entry = (Entry*) malloc(sizeof(Entry));
165 int level = parent->level + 1;
166 Entry* last = 0;
167 HANDLE hFind;
168 #ifndef _NO_EXTENSIONS
169 HANDLE hFile;
170 #endif
171
172 TCHAR buffer[MAX_PATH], *p;
173 for(p=buffer; *path; )
174 *p++ = *path++;
175
176 lstrcpy(p, _T("\\*"));
177
178 hFind = FindFirstFile(buffer, &entry->data);
179
180 if (hFind != INVALID_HANDLE_VALUE) {
181 parent->down = entry;
182
183 do {
184 entry->down = 0;
185 entry->up = parent;
186 entry->expanded = FALSE;
187 entry->scanned = FALSE;
188 entry->level = level;
189
190 #ifdef _NO_EXTENSIONS
191 /* hide directory entry "." */
192 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
193 LPCTSTR name = entry->data.cFileName;
194
195 if (name[0]=='.' && name[1]=='\0')
196 continue;
197 }
198 #else
199 entry->unix_dir = FALSE;
200 entry->bhfi_valid = FALSE;
201
202 lstrcpy(p+1, entry->data.cFileName);
203
204 hFile = CreateFile(buffer, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
205 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
206
207 if (hFile != INVALID_HANDLE_VALUE) {
208 if (GetFileInformationByHandle(hFile, &entry->bhfi))
209 entry->bhfi_valid = TRUE;
210
211 CloseHandle(hFile);
212 }
213 #endif
214
215 last = entry;
216
217 entry = (Entry*) malloc(sizeof(Entry));
218
219 if (last)
220 last->next = entry;
221 } while(FindNextFile(hFind, &entry->data));
222
223 last->next = 0;
224
225 FindClose(hFind);
226 } else
227 parent->down = 0;
228
229 free(entry);
230
231 parent->scanned = TRUE;
232 }
233
234
235 static Entry* find_entry_win(Entry* parent, LPCTSTR name)
236 {
237 Entry* entry;
238
239 for(entry=parent->down; entry; entry=entry->next) {
240 LPCTSTR p = name;
241 LPCTSTR q = entry->data.cFileName;
242
243 do {
244 if (!*p || *p==_T('\\') || *p==_T('/'))
245 return entry;
246 } while(tolower(*p++) == tolower(*q++));
247
248 p = name;
249 q = entry->data.cAlternateFileName;
250
251 do {
252 if (!*p || *p==_T('\\') || *p==_T('/'))
253 return entry;
254 } while(tolower(*p++) == tolower(*q++));
255 }
256
257 return 0;
258 }
259
260
261 static Entry* read_tree_win(Root* root, LPCTSTR path, int sortOrder)
262 {
263 TCHAR buffer[MAX_PATH];
264 Entry* entry = &root->entry;
265 LPCTSTR s = path;
266 PTSTR d = buffer;
267
268 #ifndef _NO_EXTENSIONS
269 entry->unix_dir = FALSE;
270 #endif
271
272 while(entry) {
273 while(*s && *s!=_T('\\') && *s!=_T('/'))
274 *d++ = *s++;
275
276 while(*s==_T('\\') || *s==_T('/'))
277 s++;
278
279 *d++ = _T('\\');
280 *d = _T('\0');
281
282 read_directory(entry, buffer, sortOrder);
283
284 if (entry->down)
285 entry->expanded = TRUE;
286
287 if (!*s)
288 break;
289
290 entry = find_entry_win(entry, s);
291 }
292
293 return entry;
294 }
295
296
297 #if !defined(_NO_EXTENSIONS) && defined(__linux__)
298
299 BOOL to_filetime(const time_t* t, FILETIME* ftime)
300 {
301 struct tm* tm = gmtime(t);
302 SYSTEMTIME stime;
303
304 if (!tm)
305 return FALSE;
306
307 stime.wYear = tm->tm_year+1900;
308 stime.wMonth = tm->tm_mon+1;
309 /* stime.wDayOfWeek */
310 stime.wDay = tm->tm_mday;
311 stime.wHour = tm->tm_hour;
312 stime.wMinute = tm->tm_min;
313 stime.wSecond = tm->tm_sec;
314
315 return SystemTimeToFileTime(&stime, ftime);
316 }
317
318 static void read_directory_unix(Entry* parent, LPCTSTR path)
319 {
320 Entry* entry = (Entry*) malloc(sizeof(Entry));
321 int level = parent->level + 1;
322 Entry* last = 0;
323
324 DIR* dir = opendir(path);
325
326 if (dir) {
327 struct stat st;
328 struct dirent* ent;
329 TCHAR buffer[MAX_PATH], *p;
330
331 for(p=buffer; *path; )
332 *p++ = *path++;
333
334 if (p==buffer || p[-1]!='/')
335 *p++ = '/';
336
337 parent->down = entry;
338
339 while((ent=readdir(dir))) {
340 entry->unix_dir = TRUE;
341 lstrcpy(entry->data.cFileName, ent->d_name);
342 entry->data.dwFileAttributes = ent->d_name[0]=='.'? FILE_ATTRIBUTE_HIDDEN: 0;
343
344 strcpy(p, ent->d_name);
345
346 if (!stat(buffer, &st)) {
347 if (S_ISDIR(st.st_mode))
348 entry->data.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
349
350 entry->data.nFileSizeLow = st.st_size & 0xFFFFFFFF;
351 entry->data.nFileSizeHigh = st.st_size >> 32;
352
353 memset(&entry->data.ftCreationTime, 0, sizeof(FILETIME));
354 to_filetime(&st.st_atime, &entry->data.ftLastAccessTime);
355 to_filetime(&st.st_mtime, &entry->data.ftLastWriteTime);
356
357 entry->bhfi.nFileIndexLow = ent->d_ino;
358 entry->bhfi.nFileIndexHigh = 0;
359
360 entry->bhfi.nNumberOfLinks = st.st_nlink;
361
362 entry->bhfi_valid = TRUE;
363 } else {
364 entry->data.nFileSizeLow = 0;
365 entry->data.nFileSizeHigh = 0;
366 entry->bhfi_valid = FALSE;
367 }
368
369 entry->down = 0;
370 entry->up = parent;
371 entry->expanded = FALSE;
372 entry->scanned = FALSE;
373 entry->level = level;
374
375 last = entry;
376
377 entry = (Entry*) malloc(sizeof(Entry));
378
379 if (last)
380 last->next = entry;
381 }
382
383 last->next = 0;
384
385 closedir(dir);
386 } else
387 parent->down = 0;
388
389 free(entry);
390
391 parent->scanned = TRUE;
392 }
393
394 static Entry* find_entry_unix(Entry* parent, LPCTSTR name)
395 {
396 Entry* entry;
397
398 for(entry=parent->down; entry; entry=entry->next) {
399 LPCTSTR p = name;
400 LPCTSTR q = entry->data.cFileName;
401
402 do {
403 if (!*p || *p==_T('/'))
404 return entry;
405 } while(*p++ == *q++);
406 }
407
408 return 0;
409 }
410
411 static Entry* read_tree_unix(Root* root, LPCTSTR path, int sortOrder)
412 {
413 TCHAR buffer[MAX_PATH];
414 Entry* entry = &root->entry;
415 LPCTSTR s = path;
416 PTSTR d = buffer;
417
418 entry->unix_dir = TRUE;
419
420 while(entry) {
421 while(*s && *s!=_T('/'))
422 *d++ = *s++;
423
424 while(*s == _T('/'))
425 s++;
426
427 *d++ = _T('/');
428 *d = _T('\0');
429
430 read_directory(entry, buffer, sortOrder);
431
432 if (entry->down)
433 entry->expanded = TRUE;
434
435 if (!*s)
436 break;
437
438 entry = find_entry_unix(entry, s);
439 }
440
441 return entry;
442 }
443
444 #endif
445
446
447 /* directories first... */
448 static int compareType(const WIN32_FIND_DATA* fd1, const WIN32_FIND_DATA* fd2)
449 {
450 int dir1 = fd1->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
451 int dir2 = fd2->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
452
453 return dir2==dir1? 0: dir2<dir1? -1: 1;
454 }
455
456
457 static int compareName(const void* arg1, const void* arg2)
458 {
459 const WIN32_FIND_DATA* fd1 = &(*(Entry**)arg1)->data;
460 const WIN32_FIND_DATA* fd2 = &(*(Entry**)arg2)->data;
461
462 int cmp = compareType(fd1, fd2);
463 if (cmp)
464 return cmp;
465
466 return lstrcmpi(fd1->cFileName, fd2->cFileName);
467 }
468
469 static int compareExt(const void* arg1, const void* arg2)
470 {
471 const WIN32_FIND_DATA* fd1 = &(*(Entry**)arg1)->data;
472 const WIN32_FIND_DATA* fd2 = &(*(Entry**)arg2)->data;
473 const TCHAR *name1, *name2, *ext1, *ext2;
474
475 int cmp = compareType(fd1, fd2);
476 if (cmp)
477 return cmp;
478
479 name1 = fd1->cFileName;
480 name2 = fd2->cFileName;
481
482 ext1 = _tcsrchr(name1, _T('.'));
483 ext2 = _tcsrchr(name2, _T('.'));
484
485 if (ext1)
486 ext1++;
487 else
488 ext1 = _T("");
489
490 if (ext2)
491 ext2++;
492 else
493 ext2 = _T("");
494
495 cmp = lstrcmpi(ext1, ext2);
496 if (cmp)
497 return cmp;
498
499 return lstrcmpi(name1, name2);
500 }
501
502 static int compareSize(const void* arg1, const void* arg2)
503 {
504 WIN32_FIND_DATA* fd1 = &(*(Entry**)arg1)->data;
505 WIN32_FIND_DATA* fd2 = &(*(Entry**)arg2)->data;
506
507 int cmp = compareType(fd1, fd2);
508 if (cmp)
509 return cmp;
510
511 cmp = fd2->nFileSizeHigh - fd1->nFileSizeHigh;
512
513 if (cmp < 0)
514 return -1;
515 else if (cmp > 0)
516 return 1;
517
518 cmp = fd2->nFileSizeLow - fd1->nFileSizeLow;
519
520 return cmp<0? -1: cmp>0? 1: 0;
521 }
522
523 static int compareDate(const void* arg1, const void* arg2)
524 {
525 WIN32_FIND_DATA* fd1 = &(*(Entry**)arg1)->data;
526 WIN32_FIND_DATA* fd2 = &(*(Entry**)arg2)->data;
527
528 int cmp = compareType(fd1, fd2);
529 if (cmp)
530 return cmp;
531
532 return CompareFileTime(&fd2->ftLastWriteTime, &fd1->ftLastWriteTime);
533 }
534
535
536 static int (*sortFunctions[])(const void* arg1, const void* arg2) = {
537 compareName, /* SORT_NAME */
538 compareExt, /* SORT_EXT */
539 compareSize, /* SORT_SIZE */
540 compareDate /* SORT_DATE */
541 };
542
543
544 static void SortDirectory(Entry* parent, SORT_ORDER sortOrder)
545 {
546 Entry* entry = parent->down;
547 Entry** array, **p;
548 int len;
549
550 len = 0;
551 for(entry=parent->down; entry; entry=entry->next)
552 len++;
553
554 if (len) {
555 array = (Entry**) alloca(len*sizeof(Entry*));
556
557 p = array;
558 for(entry=parent->down; entry; entry=entry->next)
559 *p++ = entry;
560
561 /* call qsort with the appropriate compare function */
562 qsort(array, len, sizeof(array[0]), sortFunctions[sortOrder]);
563
564 parent->down = array[0];
565
566 for(p=array; --len; p++)
567 p[0]->next = p[1];
568
569 (*p)->next = 0;
570 }
571 }
572
573
574 static void read_directory(Entry* parent, LPCTSTR path, int sortOrder)
575 {
576 TCHAR buffer[MAX_PATH];
577 Entry* entry;
578 LPCTSTR s;
579 PTSTR d;
580
581 #if !defined(_NO_EXTENSIONS) && defined(__linux__)
582 if (parent->unix_dir)
583 {
584 read_directory_unix(parent, path);
585
586 if (Globals.prescan_node) {
587 s = path;
588 d = buffer;
589
590 while(*s)
591 *d++ = *s++;
592
593 *d++ = _T('/');
594
595 for(entry=parent->down; entry; entry=entry->next)
596 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
597 lstrcpy(d, entry->data.cFileName);
598 read_directory_unix(entry, buffer);
599 SortDirectory(entry, sortOrder);
600 }
601 }
602 }
603 else
604 #endif
605 {
606 read_directory_win(parent, path);
607
608 if (Globals.prescan_node) {
609 s = path;
610 d = buffer;
611
612 while(*s)
613 *d++ = *s++;
614
615 *d++ = _T('\\');
616
617 for(entry=parent->down; entry; entry=entry->next)
618 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
619 lstrcpy(d, entry->data.cFileName);
620 read_directory_win(entry, buffer);
621 SortDirectory(entry, sortOrder);
622 }
623 }
624 }
625
626 SortDirectory(parent, sortOrder);
627 }
628
629
630 static ChildWnd* alloc_child_window(LPCTSTR path)
631 {
632 TCHAR drv[_MAX_DRIVE+1], dir[_MAX_DIR], name[_MAX_FNAME], ext[_MAX_EXT];
633 ChildWnd* child = (ChildWnd*) malloc(sizeof(ChildWnd));
634 Root* root = &child->root;
635 Entry* entry;
636
637 memset(child, 0, sizeof(ChildWnd));
638
639 child->left.treePane = TRUE;
640 child->left.visible_cols = 0;
641
642 child->right.treePane = FALSE;
643 #ifndef _NO_EXTENSIONS
644 child->right.visible_cols = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_INDEX|COL_LINKS;
645 #else
646 child->right.visible_cols = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES;
647 #endif
648
649 child->pos.length = sizeof(WINDOWPLACEMENT);
650 child->pos.flags = 0;
651 child->pos.showCmd = SW_SHOWNORMAL;
652 child->pos.rcNormalPosition.left = CW_USEDEFAULT;
653 child->pos.rcNormalPosition.top = CW_USEDEFAULT;
654 child->pos.rcNormalPosition.right = CW_USEDEFAULT;
655 child->pos.rcNormalPosition.bottom = CW_USEDEFAULT;
656
657 child->focus_pane = 0;
658 child->split_pos = 200;
659 child->sortOrder = SORT_NAME;
660 child->header_wdths_ok = FALSE;
661
662 lstrcpy(child->path, path);
663
664 _tsplitpath(path, drv, dir, name, ext);
665
666 #if !defined(_NO_EXTENSIONS) && defined(__linux__)
667 if (*path == '/')
668 {
669 root->drive_type = GetDriveType(path);
670
671 lstrcat(drv, _T("/"));
672 lstrcpy(root->volname, _T("root fs"));
673 root->fs_flags = 0;
674 lstrcpy(root->fs, _T("unixfs"));
675
676 lstrcpy(root->path, _T("/"));
677 entry = read_tree_unix(root, path, child->sortOrder);
678 }
679 else
680 #endif
681 {
682 root->drive_type = GetDriveType(path);
683
684 lstrcat(drv, _T("\\"));
685 GetVolumeInformation(drv, root->volname, _MAX_FNAME, 0, 0, &root->fs_flags, root->fs, _MAX_DIR);
686
687 lstrcpy(root->path, drv);
688 entry = read_tree_win(root, path, child->sortOrder);
689 }
690
691 /*@@lstrcpy(root->entry.data.cFileName, drv); */
692 wsprintf(root->entry.data.cFileName, _T("%s - %s"), drv, root->fs);
693
694 root->entry.data.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
695
696 child->left.root = &root->entry;
697
698 set_curdir(child, entry);
699
700 return child;
701 }
702
703
704 /* recursively free all child entries */
705 static void free_entries(Entry* parent)
706 {
707 Entry *entry, *next=parent->down;
708
709 if (next) {
710 parent->down = 0;
711
712 do {
713 entry = next;
714 next = entry->next;
715
716 free_entries(entry);
717 free(entry);
718 } while(next);
719 }
720 }
721
722 /* free all memory associated with a child window */
723 static void free_child_window(ChildWnd* child)
724 {
725 free_entries(&child->root.entry);
726 free(child);
727 }
728
729
730 /* get full path of specified directory entry */
731 static void get_path(Entry* dir, PTSTR path)
732 {
733 Entry* entry;
734 int len = 0;
735 int level = 0;
736
737 for(entry=dir; entry; level++) {
738 LPCTSTR name = entry->data.cFileName;
739 LPCTSTR s = name;
740 int l;
741
742 for(l=0; *s && *s!=_T('/') && *s!=_T('\\'); s++)
743 l++;
744
745 if (entry->up) {
746 memmove(path+l+1, path, len*sizeof(TCHAR));
747 memcpy(path+1, name, l*sizeof(TCHAR));
748 len += l+1;
749
750 #ifndef _NO_EXTENSIONS
751 if (entry->unix_dir)
752 path[0] = _T('/');
753 else
754 #endif
755 path[0] = _T('\\');
756
757 entry = entry->up;
758 } else {
759 memmove(path+l, path, len*sizeof(TCHAR));
760 memcpy(path, name, l*sizeof(TCHAR));
761 len += l;
762 break;
763 }
764 }
765
766 if (!level) {
767 #ifndef _NO_EXTENSIONS
768 if (entry->unix_dir)
769 path[len++] = _T('/');
770 else
771 #endif
772 path[len++] = _T('\\');
773 }
774
775 path[len] = _T('\0');
776 }
777
778
779 static void resize_frame_rect(HWND hwnd, PRECT prect)
780 {
781 int new_top;
782 RECT rt;
783
784 if (IsWindowVisible(Globals.htoolbar)) {
785 SendMessage(Globals.htoolbar, WM_SIZE, 0, 0);
786 GetClientRect(Globals.htoolbar, &rt);
787 prect->top = rt.bottom+3;
788 prect->bottom -= rt.bottom+3;
789 }
790
791 if (IsWindowVisible(Globals.hdrivebar)) {
792 SendMessage(Globals.hdrivebar, WM_SIZE, 0, 0);
793 GetClientRect(Globals.hdrivebar, &rt);
794 new_top = --prect->top + rt.bottom+3;
795 MoveWindow(Globals.hdrivebar, 0, prect->top, rt.right, new_top, TRUE);
796 prect->top = new_top;
797 prect->bottom -= rt.bottom+2;
798 }
799
800 if (IsWindowVisible(Globals.hstatusbar)) {
801 int parts[] = {300, 500};
802
803 SendMessage(Globals.hstatusbar, WM_SIZE, 0, 0);
804 SendMessage(Globals.hstatusbar, SB_SETPARTS, 2, (LPARAM)&parts);
805 GetClientRect(Globals.hstatusbar, &rt);
806 prect->bottom -= rt.bottom;
807 }
808
809 MoveWindow(Globals.hmdiclient, prect->left-1,prect->top-1,prect->right+2,prect->bottom+1, TRUE);
810 }
811
812 static void resize_frame(HWND hwnd, int cx, int cy)
813 {
814 RECT rect;
815
816 rect.left = 0;
817 rect.top = 0;
818 rect.right = cx;
819 rect.bottom = cy;
820
821 resize_frame_rect(hwnd, &rect);
822 }
823
824 static void resize_frame_client(HWND hwnd)
825 {
826 RECT rect;
827
828 GetClientRect(hwnd, &rect);
829
830 resize_frame_rect(hwnd, &rect);
831 }
832
833
834 static HHOOK hcbthook;
835 static ChildWnd* newchild = NULL;
836
837 LRESULT CALLBACK CBTProc(int code, WPARAM wparam, LPARAM lparam)
838 {
839 if (code==HCBT_CREATEWND && newchild) {
840 ChildWnd* child = newchild;
841 newchild = NULL;
842
843 child->hwnd = (HWND) wparam;
844 SetWindowLong(child->hwnd, GWL_USERDATA, (LPARAM)child);
845 }
846
847 return CallNextHookEx(hcbthook, code, wparam, lparam);
848 }
849
850 static HWND create_child_window(ChildWnd* child)
851 {
852 MDICREATESTRUCT mcs;
853 int idx;
854
855 mcs.szClass = WINEFILETREE;
856 mcs.szTitle = (LPTSTR)child->path;
857 mcs.hOwner = Globals.hInstance;
858 mcs.x = child->pos.rcNormalPosition.left;
859 mcs.y = child->pos.rcNormalPosition.top;
860 mcs.cx = child->pos.rcNormalPosition.right-child->pos.rcNormalPosition.left;
861 mcs.cy = child->pos.rcNormalPosition.bottom-child->pos.rcNormalPosition.top;
862 mcs.style = 0;
863 mcs.lParam = 0;
864
865 hcbthook = SetWindowsHookEx(WH_CBT, CBTProc, 0, GetCurrentThreadId());
866
867 newchild = child;
868 child->hwnd = (HWND) SendMessage(Globals.hmdiclient, WM_MDICREATE, 0, (LPARAM)&mcs);
869 if (!child->hwnd)
870 return 0;
871
872 UnhookWindowsHookEx(hcbthook);
873
874 idx = ListBox_FindItemData(child->left.hwnd, ListBox_GetCurSel(child->left.hwnd), child->left.cur);
875 ListBox_SetCurSel(child->left.hwnd, idx);
876
877 return child->hwnd;
878 }
879
880
881 struct ExecuteDialog {
882 TCHAR cmd[MAX_PATH];
883 int cmdshow;
884 };
885
886
887 static BOOL CALLBACK ExecuteDialogWndProg(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
888 {
889 static struct ExecuteDialog* dlg;
890
891 switch(nmsg) {
892 case WM_INITDIALOG:
893 dlg = (struct ExecuteDialog*) lparam;
894 return 1;
895
896 case WM_COMMAND: {
897 int id = (int)wparam;
898
899 if (id == IDOK) {
900 GetWindowText(GetDlgItem(hwnd, 201), dlg->cmd, MAX_PATH);
901 dlg->cmdshow = Button_GetState(GetDlgItem(hwnd,214))&BST_CHECKED?
902 SW_SHOWMINIMIZED: SW_SHOWNORMAL;
903 EndDialog(hwnd, id);
904 } else if (id == IDCANCEL)
905 EndDialog(hwnd, id);
906
907 return 1;}
908 }
909
910 return 0;
911 }
912
913
914 #ifndef _NO_EXTENSIONS
915
916 static struct FullScreenParameters {
917 BOOL mode;
918 RECT orgPos;
919 BOOL wasZoomed;
920 } g_fullscreen = {
921 FALSE /* mode */
922 };
923
924 void frame_get_clientspace(HWND hwnd, PRECT prect)
925 {
926 RECT rt;
927
928 if (!IsIconic(hwnd))
929 GetClientRect(hwnd, prect);
930 else {
931 WINDOWPLACEMENT wp;
932
933 GetWindowPlacement(hwnd, &wp);
934
935 prect->left = prect->top = 0;
936 prect->right = wp.rcNormalPosition.right-wp.rcNormalPosition.left-
937 2*(GetSystemMetrics(SM_CXSIZEFRAME)+GetSystemMetrics(SM_CXEDGE));
938 prect->bottom = wp.rcNormalPosition.bottom-wp.rcNormalPosition.top-
939 2*(GetSystemMetrics(SM_CYSIZEFRAME)+GetSystemMetrics(SM_CYEDGE))-
940 GetSystemMetrics(SM_CYCAPTION)-GetSystemMetrics(SM_CYMENUSIZE);
941 }
942
943 if (IsWindowVisible(Globals.htoolbar)) {
944 GetClientRect(Globals.htoolbar, &rt);
945 prect->top += rt.bottom+2;
946 }
947
948 if (IsWindowVisible(Globals.hdrivebar)) {
949 GetClientRect(Globals.hdrivebar, &rt);
950 prect->top += rt.bottom+2;
951 }
952
953 if (IsWindowVisible(Globals.hstatusbar)) {
954 GetClientRect(Globals.hstatusbar, &rt);
955 prect->bottom -= rt.bottom;
956 }
957 }
958
959 static BOOL toggle_fullscreen(HWND hwnd)
960 {
961 RECT rt;
962
963 if ((g_fullscreen.mode=!g_fullscreen.mode)) {
964 GetWindowRect(hwnd, &g_fullscreen.orgPos);
965 g_fullscreen.wasZoomed = IsZoomed(hwnd);
966
967 Frame_CalcFrameClient(hwnd, &rt);
968 ClientToScreen(hwnd, (LPPOINT)&rt.left);
969 ClientToScreen(hwnd, (LPPOINT)&rt.right);
970
971 rt.left = g_fullscreen.orgPos.left-rt.left;
972 rt.top = g_fullscreen.orgPos.top-rt.top;
973 rt.right = GetSystemMetrics(SM_CXSCREEN)+g_fullscreen.orgPos.right-rt.right;
974 rt.bottom = GetSystemMetrics(SM_CYSCREEN)+g_fullscreen.orgPos.bottom-rt.bottom;
975
976 MoveWindow(hwnd, rt.left, rt.top, rt.right-rt.left, rt.bottom-rt.top, TRUE);
977 } else {
978 MoveWindow(hwnd, g_fullscreen.orgPos.left, g_fullscreen.orgPos.top,
979 g_fullscreen.orgPos.right-g_fullscreen.orgPos.left,
980 g_fullscreen.orgPos.bottom-g_fullscreen.orgPos.top, TRUE);
981
982 if (g_fullscreen.wasZoomed)
983 ShowWindow(hwnd, WS_MAXIMIZE);
984 }
985
986 return g_fullscreen.mode;
987 }
988
989 static void fullscreen_move(HWND hwnd)
990 {
991 RECT rt, pos;
992 GetWindowRect(hwnd, &pos);
993
994 Frame_CalcFrameClient(hwnd, &rt);
995 ClientToScreen(hwnd, (LPPOINT)&rt.left);
996 ClientToScreen(hwnd, (LPPOINT)&rt.right);
997
998 rt.left = pos.left-rt.left;
999 rt.top = pos.top-rt.top;
1000 rt.right = GetSystemMetrics(SM_CXSCREEN)+pos.right-rt.right;
1001 rt.bottom = GetSystemMetrics(SM_CYSCREEN)+pos.bottom-rt.bottom;
1002
1003 MoveWindow(hwnd, rt.left, rt.top, rt.right-rt.left, rt.bottom-rt.top, TRUE);
1004 }
1005
1006 #endif
1007
1008
1009 static void toggle_child(HWND hwnd, UINT cmd, HWND hchild)
1010 {
1011 BOOL vis = IsWindowVisible(hchild);
1012
1013 CheckMenuItem(Globals.hMenuOptions, cmd, vis?MF_BYCOMMAND:MF_BYCOMMAND|MF_CHECKED);
1014
1015 ShowWindow(hchild, vis?SW_HIDE:SW_SHOW);
1016
1017 #ifndef _NO_EXTENSIONS
1018 if (g_fullscreen.mode)
1019 fullscreen_move(hwnd);
1020 #endif
1021
1022 resize_frame_client(hwnd);
1023 }
1024
1025 BOOL activate_drive_window(LPCTSTR path)
1026 {
1027 TCHAR drv1[_MAX_DRIVE], drv2[_MAX_DRIVE];
1028 HWND child_wnd;
1029
1030 _tsplitpath(path, drv1, 0, 0, 0);
1031
1032 /* search for a already open window for the same drive */
1033 for(child_wnd=GetNextWindow(Globals.hmdiclient,GW_CHILD); child_wnd; child_wnd=GetNextWindow(child_wnd, GW_HWNDNEXT)) {
1034 ChildWnd* child = (ChildWnd*) GetWindowLong(child_wnd, GWL_USERDATA);
1035
1036 if (child) {
1037 _tsplitpath(child->root.path, drv2, 0, 0, 0);
1038
1039 if (!lstrcmpi(drv2, drv1)) {
1040 SendMessage(Globals.hmdiclient, WM_MDIACTIVATE, (WPARAM)child_wnd, 0);
1041
1042 if (IsMinimized(child_wnd))
1043 ShowWindow(child_wnd, SW_SHOWNORMAL);
1044
1045 return TRUE;
1046 }
1047 }
1048 }
1049
1050 return FALSE;
1051 }
1052
1053 LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
1054 {
1055 switch(nmsg) {
1056 case WM_CLOSE:
1057 DestroyWindow(hwnd);
1058 break;
1059
1060 case WM_DESTROY:
1061 PostQuitMessage(0);
1062 break;
1063
1064 case WM_COMMAND: {
1065 UINT cmd = LOWORD(wparam);
1066 HWND hwndClient = (HWND) SendMessage(Globals.hmdiclient, WM_MDIGETACTIVE, 0, 0);
1067
1068 if (SendMessage(hwndClient, WM_DISPATCH_COMMAND, wparam, lparam))
1069 break;
1070
1071 if (cmd>=ID_DRIVE_FIRST && cmd<=ID_DRIVE_FIRST+0xFF) {
1072 TCHAR drv[_MAX_DRIVE], path[MAX_PATH];
1073 ChildWnd* child;
1074 LPCTSTR root = Globals.drives;
1075 int i;
1076
1077 for(i=cmd-ID_DRIVE_FIRST; i--; root++)
1078 while(*root)
1079 root++;
1080
1081 if (activate_drive_window(root))
1082 return 0;
1083
1084 _tsplitpath(root, drv, 0, 0, 0);
1085
1086 if (!SetCurrentDirectory(drv)) {
1087 display_error(hwnd, GetLastError());
1088 return 0;
1089 }
1090
1091 GetCurrentDirectory(MAX_PATH, path); /*@@ letztes Verzeichnis pro Laufwerk speichern */
1092 child = alloc_child_window(path);
1093
1094 if (!create_child_window(child))
1095 free(child);
1096 } else switch(cmd) {
1097 case ID_FILE_EXIT:
1098 PostQuitMessage(0);
1099 break;
1100
1101 case ID_WINDOW_NEW: {
1102 TCHAR path[MAX_PATH];
1103 ChildWnd* child;
1104
1105 GetCurrentDirectory(MAX_PATH, path);
1106 child = alloc_child_window(path);
1107
1108 if (!create_child_window(child))
1109 free(child);
1110 break;}
1111
1112 case ID_WINDOW_CASCADE:
1113 SendMessage(Globals.hmdiclient, WM_MDICASCADE, 0, 0);
1114 break;
1115
1116 case ID_WINDOW_TILE_HORZ:
1117 SendMessage(Globals.hmdiclient, WM_MDITILE, MDITILE_HORIZONTAL, 0);
1118 break;
1119
1120 case ID_WINDOW_TILE_VERT:
1121 SendMessage(Globals.hmdiclient, WM_MDITILE, MDITILE_VERTICAL, 0);
1122 break;
1123
1124 case ID_WINDOW_ARRANGE:
1125 SendMessage(Globals.hmdiclient, WM_MDIICONARRANGE, 0, 0);
1126 break;
1127
1128 case ID_VIEW_TOOL_BAR:
1129 toggle_child(hwnd, cmd, Globals.htoolbar);
1130 break;
1131
1132 case ID_VIEW_DRIVE_BAR:
1133 toggle_child(hwnd, cmd, Globals.hdrivebar);
1134 break;
1135
1136 case ID_VIEW_STATUSBAR:
1137 toggle_child(hwnd, cmd, Globals.hstatusbar);
1138 break;
1139
1140 case ID_EXECUTE: {
1141 struct ExecuteDialog dlg = {{0}};
1142 if (DialogBoxParam(Globals.hInstance, MAKEINTRESOURCE(IDD_EXECUTE), hwnd, ExecuteDialogWndProg, (LPARAM)&dlg) == IDOK) {
1143 HINSTANCE hinst = ShellExecute(hwnd, NULL/*operation*/, dlg.cmd/*file*/, NULL/*parameters*/, NULL/*dir*/, dlg.cmdshow);
1144
1145 if ((int)hinst <= 32)
1146 display_error(hwnd, GetLastError());
1147 }
1148 break;}
1149
1150 case ID_HELP:
1151 WinHelp(hwnd, _T("winfile"), HELP_INDEX, 0);
1152 break;
1153
1154 #ifndef _NO_EXTENSIONS
1155 case ID_VIEW_FULLSCREEN:
1156 CheckMenuItem(Globals.hMenuOptions, cmd, toggle_fullscreen(hwnd)?MF_CHECKED:0);
1157 break;
1158
1159 #ifdef __linux__
1160 case ID_DRIVE_UNIX_FS: {
1161 TCHAR path[MAX_PATH];
1162 ChildWnd* child;
1163
1164 if (activate_drive_window(_T("/")))
1165 break;
1166
1167 getcwd(path, MAX_PATH);
1168 child = alloc_child_window(path);
1169
1170 if (!create_child_window(child))
1171 free(child);
1172 break;}
1173 #endif
1174 #endif
1175
1176 /*TODO: There are even more menu items! */
1177
1178 #ifndef _NO_EXTENSIONS
1179 case ID_LICENSE:
1180 WineLicense(Globals.hMainWnd);
1181 break;
1182
1183 case ID_NO_WARRANTY:
1184 WineWarranty(Globals.hMainWnd);
1185 break;
1186
1187 case ID_ABOUT_WINE:
1188 ShellAbout(hwnd, _T("WINE"), _T("Winefile"), 0);
1189 break;
1190 #endif
1191
1192 default:
1193 /*@@if (wParam >= PM_FIRST_LANGUAGE && wParam <= PM_LAST_LANGUAGE)
1194 STRING_SelectLanguageByNumber(wParam - PM_FIRST_LANGUAGE);
1195 else */if ((cmd<IDW_FIRST_CHILD || cmd>=IDW_FIRST_CHILD+0x100) &&
1196 (cmd<SC_SIZE || cmd>SC_RESTORE))
1197 MessageBox(hwnd, _T("Not yet implemented"), _T("Winefile"), MB_OK);
1198
1199 return DefFrameProc(hwnd, Globals.hmdiclient, nmsg, wparam, lparam);
1200 }
1201 break;}
1202
1203 case WM_SIZE:
1204 resize_frame(hwnd, LOWORD(lparam), HIWORD(lparam));
1205 break; /* do not pass message to DefFrameProc */
1206
1207 #ifndef _NO_EXTENSIONS
1208 case WM_GETMINMAXINFO: {
1209 LPMINMAXINFO lpmmi = (LPMINMAXINFO)lparam;
1210
1211 lpmmi->ptMaxTrackSize.x <<= 1;/*2*GetSystemMetrics(SM_CXSCREEN) / SM_CXVIRTUALSCREEN */
1212 lpmmi->ptMaxTrackSize.y <<= 1;/*2*GetSystemMetrics(SM_CYSCREEN) / SM_CYVIRTUALSCREEN */
1213 break;}
1214
1215 case FRM_CALC_CLIENT:
1216 frame_get_clientspace(hwnd, (PRECT)lparam);
1217 return TRUE;
1218 #endif
1219
1220 default:
1221 return DefFrameProc(hwnd, Globals.hmdiclient, nmsg, wparam, lparam);
1222 }
1223
1224 return 0;
1225 }
1226
1227
1228 const static LPTSTR g_pos_names[COLUMNS] = {
1229 _T(""), /* symbol */
1230 _T("Name"),
1231 _T("Size"),
1232 _T("CDate"),
1233 #ifndef _NO_EXTENSIONS
1234 _T("ADate"),
1235 _T("MDate"),
1236 _T("Index/Inode"),
1237 _T("Links"),
1238 #endif
1239 _T("Attributes"),
1240 #ifndef _NO_EXTENSIONS
1241 _T("Security")
1242 #endif
1243 };
1244
1245 const static int g_pos_align[] = {
1246 0,
1247 HDF_LEFT, /* Name */
1248 HDF_RIGHT, /* Size */
1249 HDF_LEFT, /* CDate */
1250 #ifndef _NO_EXTENSIONS
1251 HDF_LEFT, /* ADate */
1252 HDF_LEFT, /* MDate */
1253 HDF_LEFT, /* Index */
1254 HDF_CENTER, /* Links */
1255 #endif
1256 HDF_CENTER, /* Attributes */
1257 #ifndef _NO_EXTENSIONS
1258 HDF_LEFT /* Security */
1259 #endif
1260 };
1261
1262 static void resize_tree(ChildWnd* child, int cx, int cy)
1263 {
1264 HDWP hdwp = BeginDeferWindowPos(4);
1265 RECT rt;
1266
1267 rt.left = 0;
1268 rt.top = 0;
1269 rt.right = cx;
1270 rt.bottom = cy;
1271
1272 cx = child->split_pos + SPLIT_WIDTH/2;
1273
1274 #ifndef _NO_EXTENSIONS
1275 {
1276 WINDOWPOS wp;
1277 HD_LAYOUT hdl;
1278
1279 hdl.prc = &rt;
1280 hdl.pwpos = &wp;
1281
1282 Header_Layout(child->left.hwndHeader, &hdl);
1283
1284 DeferWindowPos(hdwp, child->left.hwndHeader, wp.hwndInsertAfter,
1285 wp.x-1, wp.y, child->split_pos-SPLIT_WIDTH/2+1, wp.cy, wp.flags);
1286 DeferWindowPos(hdwp, child->right.hwndHeader, wp.hwndInsertAfter,
1287 rt.left+cx+1, wp.y, wp.cx-cx+2, wp.cy, wp.flags);
1288 }
1289 #endif
1290
1291 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);
1292 DeferWindowPos(hdwp, child->right.hwnd, 0, rt.left+cx+1, rt.top, rt.right-cx, rt.bottom-rt.top, SWP_NOZORDER|SWP_NOACTIVATE);
1293
1294 EndDeferWindowPos(hdwp);
1295 }
1296
1297
1298 #ifndef _NO_EXTENSIONS
1299
1300 static HWND create_header(HWND parent, Pane* pane, int id)
1301 {
1302 HD_ITEM hdi = {HDI_TEXT|HDI_WIDTH|HDI_FORMAT};
1303 int idx;
1304
1305 HWND hwnd = CreateWindow(WC_HEADER, 0, WS_CHILD|WS_VISIBLE|HDS_HORZ/*TODO: |HDS_BUTTONS + sort orders*/,
1306 0, 0, 0, 0, parent, (HMENU)id, Globals.hInstance, 0);
1307 if (!hwnd)
1308 return 0;
1309
1310 SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), FALSE);
1311
1312 for(idx=0; idx<COLUMNS; idx++) {
1313 hdi.pszText = g_pos_names[idx];
1314 hdi.fmt = HDF_STRING | g_pos_align[idx];
1315 hdi.cxy = pane->widths[idx];
1316 Header_InsertItem(hwnd, idx, &hdi);
1317 }
1318
1319 return hwnd;
1320 }
1321
1322 #endif
1323
1324
1325 static void init_output(HWND hwnd)
1326 {
1327 TCHAR b[16];
1328 HFONT old_font;
1329 HDC hdc = GetDC(hwnd);
1330
1331 if (GetNumberFormat(LOCALE_USER_DEFAULT, 0, _T("1000"), 0, b, 16) > 4)
1332 Globals.num_sep = b[1];
1333 else
1334 Globals.num_sep = _T('.');
1335
1336 old_font = SelectFont(hdc, Globals.hfont);
1337 GetTextExtentPoint32(hdc, _T(" "), 1, &Globals.spaceSize);
1338 SelectFont(hdc, old_font);
1339 ReleaseDC(hwnd, hdc);
1340 }
1341
1342 static void draw_item(Pane* pane, LPDRAWITEMSTRUCT dis, Entry* entry, int calcWidthCol);
1343
1344
1345 /* calculate prefered width for all visible columns */
1346
1347 static BOOL calc_widths(Pane* pane, BOOL anyway)
1348 {
1349 int col, x, cx, spc=3*Globals.spaceSize.cx;
1350 int entries = ListBox_GetCount(pane->hwnd);
1351 int orgWidths[COLUMNS];
1352 int orgPositions[COLUMNS+1];
1353 HFONT hfontOld;
1354 HDC hdc;
1355 int cnt;
1356
1357 if (!anyway) {
1358 memcpy(orgWidths, pane->widths, sizeof(orgWidths));
1359 memcpy(orgPositions, pane->positions, sizeof(orgPositions));
1360 }
1361
1362 for(col=0; col<COLUMNS; col++)
1363 pane->widths[col] = 0;
1364
1365 hdc = GetDC(pane->hwnd);
1366 hfontOld = SelectFont(hdc, Globals.hfont);
1367
1368 for(cnt=0; cnt<entries; cnt++) {
1369 Entry* entry = (Entry*) ListBox_GetItemData(pane->hwnd, cnt);
1370
1371 DRAWITEMSTRUCT dis;
1372
1373 dis.CtlType = 0;
1374 dis.CtlID = 0;
1375 dis.itemID = 0;
1376 dis.itemAction = 0;
1377 dis.itemState = 0;
1378 dis.hwndItem = pane->hwnd;
1379 dis.hDC = hdc;
1380 dis.rcItem.left = 0;
1381 dis.rcItem.top = 0;
1382 dis.rcItem.right = 0;
1383 dis.rcItem.bottom = 0;
1384 /*dis.itemData = 0; */
1385
1386 draw_item(pane, &dis, entry, COLUMNS);
1387 }
1388
1389 SelectObject(hdc, hfontOld);
1390 ReleaseDC(pane->hwnd, hdc);
1391
1392 x = 0;
1393 for(col=0; col<COLUMNS; col++) {
1394 pane->positions[col] = x;
1395 cx = pane->widths[col];
1396
1397 if (cx) {
1398 cx += spc;
1399
1400 if (cx < IMAGE_WIDTH)
1401 cx = IMAGE_WIDTH;
1402
1403 pane->widths[col] = cx;
1404 }
1405
1406 x += cx;
1407 }
1408
1409 pane->positions[COLUMNS] = x;
1410
1411 ListBox_SetHorizontalExtent(pane->hwnd, x);
1412
1413 /* no change? */
1414 if (!memcmp(orgWidths, pane->widths, sizeof(orgWidths)))
1415 return FALSE;
1416
1417 /* don't move, if only collapsing an entry */
1418 if (!anyway && pane->widths[0]<orgWidths[0] &&
1419 !memcmp(orgWidths+1, pane->widths+1, sizeof(orgWidths)-sizeof(int))) {
1420 pane->widths[0] = orgWidths[0];
1421 memcpy(pane->positions, orgPositions, sizeof(orgPositions));
1422
1423 return FALSE;
1424 }
1425
1426 InvalidateRect(pane->hwnd, 0, TRUE);
1427
1428 return TRUE;
1429 }
1430
1431
1432 /* calculate one prefered column width */
1433
1434 static void calc_single_width(Pane* pane, int col)
1435 {
1436 HFONT hfontOld;
1437 int x, cx;
1438 int entries = ListBox_GetCount(pane->hwnd);
1439 int cnt;
1440 HDC hdc;
1441
1442 pane->widths[col] = 0;
1443
1444 hdc = GetDC(pane->hwnd);
1445 hfontOld = SelectFont(hdc, Globals.hfont);
1446
1447 for(cnt=0; cnt<entries; cnt++) {
1448 Entry* entry = (Entry*) ListBox_GetItemData(pane->hwnd, cnt);
1449 DRAWITEMSTRUCT dis;
1450
1451 dis.CtlType = 0;
1452 dis.CtlID = 0;
1453 dis.itemID = 0;
1454 dis.itemAction = 0;
1455 dis.itemState = 0;
1456 dis.hwndItem = pane->hwnd;
1457 dis.hDC = hdc;
1458 dis.rcItem.left = 0;
1459 dis.rcItem.top = 0;
1460 dis.rcItem.right = 0;
1461 dis.rcItem.bottom = 0;
1462 /*dis.itemData = 0; */
1463
1464 draw_item(pane, &dis, entry, col);
1465 }
1466
1467 SelectObject(hdc, hfontOld);
1468 ReleaseDC(pane->hwnd, hdc);
1469
1470 cx = pane->widths[col];
1471
1472 if (cx) {
1473 cx += 3*Globals.spaceSize.cx;
1474
1475 if (cx < IMAGE_WIDTH)
1476 cx = IMAGE_WIDTH;
1477 }
1478
1479 pane->widths[col] = cx;
1480
1481 x = pane->positions[col] + cx;
1482
1483 for(; col<COLUMNS; ) {
1484 pane->positions[++col] = x;
1485 x += pane->widths[col];
1486 }
1487
1488 ListBox_SetHorizontalExtent(pane->hwnd, x);
1489 }
1490
1491
1492 /* insert listbox entries after index idx */
1493
1494 static void insert_entries(Pane* pane, Entry* parent, int idx)
1495 {
1496 Entry* entry = parent;
1497
1498 if (!entry)
1499 return;
1500
1501 ShowWindow(pane->hwnd, SW_HIDE);
1502
1503 for(; entry; entry=entry->next) {
1504 #ifndef _LEFT_FILES
1505 if (pane->treePane && !(entry->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
1506 continue;
1507 #endif
1508
1509 /* don't display entries "." and ".." in the left pane */
1510 if (pane->treePane && (entry->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
1511 && entry->data.cFileName[0]==_T('.'))
1512 if (
1513 #ifndef _NO_EXTENSIONS
1514 entry->data.cFileName[1]==_T('\0') ||
1515 #endif
1516 (entry->data.cFileName[1]==_T('.') && entry->data.cFileName[2]==_T('\0')))
1517 continue;
1518
1519 if (idx != -1)
1520 idx++;
1521
1522 ListBox_InsertItemData(pane->hwnd, idx, entry);
1523
1524 if (pane->treePane && entry->expanded)
1525 insert_entries(pane, entry->down, idx);
1526 }
1527
1528 ShowWindow(pane->hwnd, SW_SHOW);
1529 }
1530
1531
1532 static WNDPROC g_orgTreeWndProc;
1533
1534 static void create_tree_window(HWND parent, Pane* pane, int id, int id_header)
1535 {
1536 static int s_init = 0;
1537 Entry* entry = pane->root;
1538
1539 pane->hwnd = CreateWindow(_T("ListBox"), _T(""), WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|
1540 LBS_DISABLENOSCROLL|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED|LBS_NOTIFY,
1541 0, 0, 0, 0, parent, (HMENU)id, Globals.hInstance, 0);
1542
1543 SetWindowLong(pane->hwnd, GWL_USERDATA, (LPARAM)pane);
1544 g_orgTreeWndProc = SubclassWindow(pane->hwnd, TreeWndProc);
1545
1546 SendMessage(pane->hwnd, WM_SETFONT, (WPARAM)Globals.hfont, FALSE);
1547
1548 /* insert entries into listbox */
1549 if (entry)
1550 insert_entries(pane, entry, -1);
1551
1552 /* calculate column widths */
1553 if (!s_init) {
1554 s_init = 1;
1555 init_output(pane->hwnd);
1556 }
1557
1558 calc_widths(pane, TRUE);
1559
1560 #ifndef _NO_EXTENSIONS
1561 pane->hwndHeader = create_header(parent, pane, id_header);
1562 #endif
1563 }
1564
1565
1566 static void InitChildWindow(ChildWnd* child)
1567 {
1568 create_tree_window(child->hwnd, &child->left, IDW_TREE_LEFT, IDW_HEADER_LEFT);
1569 create_tree_window(child->hwnd, &child->right, IDW_TREE_RIGHT, IDW_HEADER_RIGHT);
1570 }
1571
1572
1573 static void format_date(const FILETIME* ft, TCHAR* buffer, int visible_cols)
1574 {
1575 SYSTEMTIME systime;
1576 FILETIME lft;
1577 int len = 0;
1578
1579 *buffer = _T('\0');
1580
1581 if (!ft->dwLowDateTime && !ft->dwHighDateTime)
1582 return;
1583
1584 if (!FileTimeToLocalFileTime(ft, &lft))
1585 {err: _tcscpy(buffer,_T("???")); return;}
1586
1587 if (!FileTimeToSystemTime(&lft, &systime))
1588 goto err;
1589
1590 if (visible_cols & COL_DATE) {
1591 len = GetDateFormat(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer, BUFFER_LEN);
1592 if (!len)
1593 goto err;
1594 }
1595
1596 if (visible_cols & COL_TIME) {
1597 if (len)
1598 buffer[len-1] = ' ';
1599
1600 buffer[len++] = ' ';
1601
1602 if (!GetTimeFormat(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer+len, BUFFER_LEN-len))
1603 buffer[len] = _T('\0');
1604 }
1605 }
1606
1607
1608 static void calc_width(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCTSTR str)
1609 {
1610 RECT rt = {0};
1611
1612 DrawText(dis->hDC, (LPTSTR)str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);
1613
1614 if (rt.right > pane->widths[col])
1615 pane->widths[col] = rt.right;
1616 }
1617
1618 static void calc_tabbed_width(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCTSTR str)
1619 {
1620 RECT rt = {0};
1621
1622 /* DRAWTEXTPARAMS dtp = {sizeof(DRAWTEXTPARAMS), 2};
1623 DrawTextEx(dis->hDC, (LPTSTR)str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX|DT_EXPANDTABS|DT_TABSTOP, &dtp);*/
1624
1625 DrawText(dis->hDC, (LPTSTR)str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_EXPANDTABS|DT_TABSTOP|(2<<8));
1626 /*@@ rt (0,0) ??? */
1627
1628 if (rt.right > pane->widths[col])
1629 pane->widths[col] = rt.right;
1630 }
1631
1632
1633 static void output_text(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCTSTR str, DWORD flags)
1634 {
1635 int x = dis->rcItem.left;
1636 RECT rt;
1637
1638 rt.left = x+pane->positions[col]+Globals.spaceSize.cx;
1639 rt.top = dis->rcItem.top;
1640 rt.right = x+pane->positions[col+1]-Globals.spaceSize.cx;
1641 rt.bottom = dis->rcItem.bottom;
1642
1643 DrawText(dis->hDC, (LPTSTR)str, -1, &rt, DT_SINGLELINE|DT_NOPREFIX|flags);
1644 }
1645
1646 static void output_tabbed_text(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCTSTR str)
1647 {
1648 int x = dis->rcItem.left;
1649 RECT rt;
1650
1651 rt.left = x+pane->positions[col]+Globals.spaceSize.cx;
1652 rt.top = dis->rcItem.top;
1653 rt.right = x+pane->positions[col+1]-Globals.spaceSize.cx;
1654 rt.bottom = dis->rcItem.bottom;
1655
1656 /* DRAWTEXTPARAMS dtp = {sizeof(DRAWTEXTPARAMS), 2};
1657 DrawTextEx(dis->hDC, (LPTSTR)str, -1, &rt, DT_SINGLELINE|DT_NOPREFIX|DT_EXPANDTABS|DT_TABSTOP, &dtp);*/
1658
1659 DrawText(dis->hDC, (LPTSTR)str, -1, &rt, DT_SINGLELINE|DT_EXPANDTABS|DT_TABSTOP|(2<<8));
1660 }
1661
1662 static void output_number(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCTSTR str)
1663 {
1664 int x = dis->rcItem.left;
1665 RECT rt;
1666 LPCTSTR s = str;
1667 TCHAR b[128];
1668 LPTSTR d = b;
1669 int pos;
1670
1671 rt.left = x+pane->positions[col]+Globals.spaceSize.cx;
1672 rt.top = dis->rcItem.top;
1673 rt.right = x+pane->positions[col+1]-Globals.spaceSize.cx;
1674 rt.bottom = dis->rcItem.bottom;
1675
1676 if (*s)
1677 *d++ = *s++;
1678
1679 /* insert number separator characters */
1680 pos = lstrlen(s) % 3;
1681
1682 while(*s)
1683 if (pos--)
1684 *d++ = *s++;
1685 else {
1686 *d++ = Globals.num_sep;
1687 pos = 3;
1688 }
1689
1690 DrawText(dis->hDC, b, d-b, &rt, DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX|DT_END_ELLIPSIS);
1691 }
1692
1693
1694 static int is_exe_file(LPCTSTR ext)
1695 {
1696 const static LPCTSTR executable_extensions[] = {
1697 _T("COM"),
1698 _T("EXE"),
1699 _T("BAT"),
1700 _T("CMD"),
1701 #ifndef _NO_EXTENSIONS
1702 _T("CMM"),
1703 _T("BTM"),
1704 _T("AWK"),
1705 #endif
1706 0
1707 };
1708
1709 TCHAR ext_buffer[_MAX_EXT];
1710 const LPCTSTR* p;
1711 LPCTSTR s;
1712 LPTSTR d;
1713
1714 for(s=ext+1,d=ext_buffer; (*d=tolower(*s)); s++)
1715 d++;
1716
1717 for(p=executable_extensions; *p; p++)
1718 if (!_tcscmp(ext_buffer, *p))
1719 return 1;
1720
1721 return 0;
1722 }
1723
1724 static int is_registered_type(LPCTSTR ext)
1725 {
1726 /* TODO */
1727
1728 return 1;
1729 }
1730
1731
1732 static void draw_item(Pane* pane, LPDRAWITEMSTRUCT dis, Entry* entry, int calcWidthCol)
1733 {
1734 TCHAR buffer[BUFFER_LEN];
1735 DWORD attrs;
1736 int visible_cols = pane->visible_cols;
1737 COLORREF bkcolor, textcolor;
1738 RECT focusRect = dis->rcItem;
1739 HBRUSH hbrush;
1740 enum IMAGE img;
1741 int img_pos, cx;
1742 int col = 0;
1743
1744 if (entry) {
1745 attrs = entry->data.dwFileAttributes;
1746
1747 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
1748 if (entry->data.cFileName[0]==_T('.') && entry->data.cFileName[1]==_T('.')
1749 && entry->data.cFileName[2]==_T('\0'))
1750 img = IMG_FOLDER_UP;
1751 #ifndef _NO_EXTENSIONS
1752 else if (entry->data.cFileName[0]==_T('.') && entry->data.cFileName[1]==_T('\0'))
1753 img = IMG_FOLDER_CUR;
1754 #endif
1755 else if (
1756 #ifdef _NO_EXTENSIONS
1757 entry->expanded ||
1758 #endif
1759 (pane->treePane && (dis->itemState&ODS_FOCUS)))
1760 img = IMG_OPEN_FOLDER;
1761 else
1762 img = IMG_FOLDER;
1763 } else {
1764 LPCTSTR ext = _tcsrchr(entry->data.cFileName, '.');
1765 if (!ext)
1766 ext = _T("");
1767
1768 if (is_exe_file(ext))
1769 img = IMG_EXECUTABLE;
1770 else if (is_registered_type(ext))
1771 img = IMG_DOCUMENT;
1772 else
1773 img = IMG_FILE;
1774 }
1775 } else {
1776 attrs = 0;
1777 img = IMG_NONE;
1778 }
1779
1780 if (pane->treePane) {
1781 if (entry) {
1782 img_pos = dis->rcItem.left + entry->level*(IMAGE_WIDTH+Globals.spaceSize.cx);
1783
1784 if (calcWidthCol == -1) {
1785 int x;
1786 int y = dis->rcItem.top + IMAGE_HEIGHT/2;
1787 Entry* up;
1788 RECT rt_clip;
1789 HRGN hrgn_org = CreateRectRgn(0, 0, 0, 0);
1790 HRGN hrgn;
1791
1792 rt_clip.left = dis->rcItem.left;
1793 rt_clip.top = dis->rcItem.top;
1794 rt_clip.right = dis->rcItem.left+pane->widths[col];
1795 rt_clip.bottom = dis->rcItem.bottom;
1796
1797 hrgn = CreateRectRgnIndirect(&rt_clip);
1798
1799 if (!GetClipRgn(dis->hDC, hrgn_org)) {
1800 DeleteObject(hrgn_org);
1801 hrgn_org = 0;
1802 }
1803
1804 /* HGDIOBJ holdPen = SelectObject(dis->hDC, GetStockObject(BLACK_PEN)); */
1805 ExtSelectClipRgn(dis->hDC, hrgn, RGN_AND);
1806 DeleteObject(hrgn);
1807
1808 if ((up=entry->up) != NULL) {
1809 MoveToEx(dis->hDC, img_pos-IMAGE_WIDTH/2, y, 0);
1810 LineTo(dis->hDC, img_pos-2, y);
1811
1812 x = img_pos - IMAGE_WIDTH/2;
1813
1814 do {
1815 x -= IMAGE_WIDTH+Globals.spaceSize.cx;
1816
1817 if (up->next
1818 #ifndef _LEFT_FILES
1819 && (up->next->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
1820 #endif
1821 ) {
1822 MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
1823 LineTo(dis->hDC, x, dis->rcItem.bottom);
1824 }
1825 } while((up=up->up) != NULL);
1826 }
1827
1828 x = img_pos - IMAGE_WIDTH/2;
1829
1830 MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
1831 LineTo(dis->hDC, x, y);
1832
1833 if (entry->next
1834 #ifndef _LEFT_FILES
1835 && (entry->next->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
1836 #endif
1837 )
1838 LineTo(dis->hDC, x, dis->rcItem.bottom);
1839
1840 if (entry->down && entry->expanded) {
1841 x += IMAGE_WIDTH+Globals.spaceSize.cx;
1842 MoveToEx(dis->hDC, x, dis->rcItem.top+IMAGE_HEIGHT, 0);
1843 LineTo(dis->hDC, x, dis->rcItem.bottom);
1844 }
1845
1846 SelectClipRgn(dis->hDC, hrgn_org);
1847 if (hrgn_org) DeleteObject(hrgn_org);
1848 /* SelectObject(dis->hDC, holdPen); */
1849 } else if (calcWidthCol==col || calcWidthCol==COLUMNS) {
1850 int right = img_pos + IMAGE_WIDTH - Globals.spaceSize.cx;
1851
1852 if (right > pane->widths[col])
1853 pane->widths[col] = right;
1854 }
1855 } else {
1856 img_pos = dis->rcItem.left;
1857 }
1858 } else {
1859 img_pos = dis->rcItem.left;
1860
1861 if (calcWidthCol==col || calcWidthCol==COLUMNS)
1862 pane->widths[col] = IMAGE_WIDTH;
1863 }
1864
1865 if (calcWidthCol == -1) {
1866 focusRect.left = img_pos -2;
1867
1868 #ifdef _NO_EXTENSIONS
1869 if (pane->treePane && entry) {
1870 RECT rt = {0};
1871
1872 DrawText(dis->hDC, entry->data.cFileName, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);
1873
1874 focusRect.right = dis->rcItem.left+pane->positions[col+1]+Globals.spaceSize.cx + rt.right +2;
1875 }
1876 #else
1877
1878 if (attrs & FILE_ATTRIBUTE_COMPRESSED)
1879 textcolor = COLOR_COMPRESSED;
1880 else
1881 #endif
1882 textcolor = RGB(0,0,0);
1883
1884 if (dis->itemState & ODS_FOCUS) {
1885 textcolor = RGB(255,255,255);
1886 bkcolor = COLOR_SELECTION;
1887 } else {
1888 bkcolor = RGB(255,255,255);
1889 }
1890
1891 hbrush = CreateSolidBrush(bkcolor);
1892 FillRect(dis->hDC, &focusRect, hbrush);
1893 DeleteObject(hbrush);
1894
1895 SetBkMode(dis->hDC, TRANSPARENT);
1896 SetTextColor(dis->hDC, textcolor);
1897
1898 cx = pane->widths[col];
1899
1900 if (cx && img!=IMG_NONE) {
1901 if (cx > IMAGE_WIDTH)
1902 cx = IMAGE_WIDTH;
1903
1904 ImageList_DrawEx(Globals.himl, img, dis->hDC,
1905 img_pos, dis->rcItem.top, cx,
1906 IMAGE_HEIGHT, bkcolor, CLR_DEFAULT, ILD_NORMAL);
1907 }
1908 }
1909
1910 if (!entry)
1911 return;
1912
1913 #ifdef _NO_EXTENSIONS
1914 if (img >= IMG_FOLDER_UP)
1915 return;
1916 #endif
1917
1918 col++;
1919
1920 /* ouput file name */
1921 if (calcWidthCol == -1)
1922 output_text(pane, dis, col, entry->data.cFileName, 0);
1923 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1924 calc_width(pane, dis, col, entry->data.cFileName);
1925
1926 col++;
1927
1928 #ifdef _NO_EXTENSIONS
1929 if (!pane->treePane) {
1930 #endif
1931
1932 /* display file size */
1933 if (visible_cols & COL_SIZE) {
1934 #ifdef _NO_EXTENSIONS
1935 if (!(attrs&FILE_ATTRIBUTE_DIRECTORY))
1936 #endif
1937 {
1938 ULONGLONG size;
1939
1940 size = ((ULONGLONG)entry->data.nFileSizeHigh << 32) | entry->data.nFileSizeLow;
1941
1942 _stprintf(buffer, _T("%") LONGLONGARG _T("d"), size);
1943
1944 if (calcWidthCol == -1)
1945 output_number(pane, dis, col, buffer);
1946 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1947 calc_width(pane, dis, col, buffer);/*TODO: not ever time enough */
1948 }
1949
1950 col++;
1951 }
1952
1953 /* display file date */
1954 if (visible_cols & (COL_DATE|COL_TIME)) {
1955 #ifndef _NO_EXTENSIONS
1956 format_date(&entry->data.ftCreationTime, buffer, visible_cols);
1957 if (calcWidthCol == -1)
1958 output_text(pane, dis, col, buffer, 0);
1959 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1960 calc_width(pane, dis, col, buffer);
1961 col++;
1962
1963 format_date(&entry->data.ftLastAccessTime, buffer, visible_cols);
1964 if (calcWidthCol == -1)
1965 output_text(pane, dis, col, buffer, 0);
1966 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1967 calc_width(pane, dis, col, buffer);
1968 col++;
1969 #endif
1970
1971 format_date(&entry->data.ftLastWriteTime, buffer, visible_cols);
1972 if (calcWidthCol == -1)
1973 output_text(pane, dis, col, buffer, 0);
1974 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1975 calc_width(pane, dis, col, buffer);
1976 col++;
1977 }
1978
1979 #ifndef _NO_EXTENSIONS
1980 if (entry->bhfi_valid) {
1981 ULONGLONG index = ((ULONGLONG)entry->bhfi.nFileIndexHigh << 32) | entry->bhfi.nFileIndexLow;
1982
1983 if (visible_cols & COL_INDEX) {
1984 _stprintf(buffer, _T("%") LONGLONGARG _T("X"), index);
1985 if (calcWidthCol == -1)
1986 output_text(pane, dis, col, buffer, DT_RIGHT);
1987 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1988 calc_width(pane, dis, col, buffer);
1989 col++;
1990 }
1991
1992 if (visible_cols & COL_LINKS) {
1993 wsprintf(buffer, _T("%d"), entry->bhfi.nNumberOfLinks);
1994 if (calcWidthCol == -1)
1995 output_text(pane, dis, col, buffer, DT_CENTER);
1996 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
1997 calc_width(pane, dis, col, buffer);
1998 col++;
1999 }
2000 } else
2001 col += 2;
2002 #endif
2003
2004 /* show file attributes */
2005 if (visible_cols & COL_ATTRIBUTES) {
2006 #ifdef _NO_EXTENSIONS
2007 _tcscpy(buffer, _T(" \t \t \t \t "));
2008 #else
2009 _tcscpy(buffer, _T(" \t \t \t \t \t \t \t \t \t \t \t "));
2010 #endif
2011
2012 if (attrs & FILE_ATTRIBUTE_NORMAL) buffer[ 0] = 'N';
2013 else {
2014 if (attrs & FILE_ATTRIBUTE_READONLY) buffer[ 2] = 'R';
2015 if (attrs & FILE_ATTRIBUTE_HIDDEN) buffer[ 4] = 'H';
2016 if (attrs & FILE_ATTRIBUTE_SYSTEM) buffer[ 6] = 'S';
2017 if (attrs & FILE_ATTRIBUTE_ARCHIVE) buffer[ 8] = 'A';
2018 if (attrs & FILE_ATTRIBUTE_COMPRESSED) buffer[10] = 'C';
2019 #ifndef _NO_EXTENSIONS
2020 if (attrs & FILE_ATTRIBUTE_DIRECTORY) buffer[12] = 'D';
2021 if (attrs & FILE_ATTRIBUTE_ENCRYPTED) buffer[14] = 'E';
2022 if (attrs & FILE_ATTRIBUTE_TEMPORARY) buffer[16] = 'T';
2023 if (attrs & FILE_ATTRIBUTE_SPARSE_FILE) buffer[18] = 'P';
2024 if (attrs & FILE_ATTRIBUTE_REPARSE_POINT) buffer[20] = 'Q';
2025 if (attrs & FILE_ATTRIBUTE_OFFLINE) buffer[22] = 'O';
2026 if (attrs & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) buffer[24] = 'X';
2027 #endif
2028 }
2029
2030 if (calcWidthCol == -1)
2031 output_tabbed_text(pane, dis, col, buffer);
2032 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
2033 calc_tabbed_width(pane, dis, col, buffer);
2034
2035 col++;
2036 }
2037
2038 /*TODO
2039 if (flags.security) {
2040 DWORD rights = get_access_mask();
2041
2042 tcscpy(buffer, _T(" \t \t \t \t \t \t \t \t \t \t \t "));
2043
2044 if (rights & FILE_READ_DATA) buffer[ 0] = 'R';
2045 if (rights & FILE_WRITE_DATA) buffer[ 2] = 'W';
2046 if (rights & FILE_APPEND_DATA) buffer[ 4] = 'A';
2047 if (rights & FILE_READ_EA) {buffer[6] = 'entry'; buffer[ 7] = 'R';}
2048 if (rights & FILE_WRITE_EA) {buffer[9] = 'entry'; buffer[10] = 'W';}
2049 if (rights & FILE_EXECUTE) buffer[12] = 'X';
2050 if (rights & FILE_DELETE_CHILD) buffer[14] = 'D';
2051 if (rights & FILE_READ_ATTRIBUTES) {buffer[16] = 'a'; buffer[17] = 'R';}
2052 if (rights & FILE_WRITE_ATTRIBUTES) {buffer[19] = 'a'; buffer[20] = 'W';}
2053 if (rights & WRITE_DAC) buffer[22] = 'C';
2054 if (rights & WRITE_OWNER) buffer[24] = 'O';
2055 if (rights & SYNCHRONIZE) buffer[26] = 'S';
2056
2057 output_text(dis, col++, buffer, DT_LEFT, 3, psize);
2058 }
2059
2060 if (flags.description) {
2061 get_description(buffer);
2062 output_text(dis, col++, buffer, 0, psize);
2063 }
2064 */
2065
2066 #ifdef _NO_EXTENSIONS
2067 }
2068
2069 /* draw focus frame */
2070 if ((dis->itemState&ODS_FOCUS) && calcWidthCol==-1) {
2071 /* Currently [04/2000] Wine neither behaves exactly the same */
2072 /* way as WIN 95 nor like Windows NT... */
2073 HGDIOBJ lastBrush;
2074 HPEN lastPen;
2075 HPEN hpen;
2076
2077 if (!(GetVersion() & 0x80000000)) { /* Windows NT? */
2078 LOGBRUSH lb = {PS_SOLID, RGB(255,255,255)};
2079 hpen = ExtCreatePen(PS_COSMETIC|PS_ALTERNATE, 1, &lb, 0, 0);
2080 } else
2081 hpen = CreatePen(PS_DOT, 0, RGB(255,255,255));
2082
2083 lastPen = SelectPen(dis->hDC, hpen);
2084 lastBrush = SelectObject(dis->hDC, GetStockObject(HOLLOW_BRUSH));
2085 SetROP2(dis->hDC, R2_XORPEN);
2086 Rectangle(dis->hDC, focusRect.left, focusRect.top, focusRect.right, focusRect.bottom);
2087 SelectObject(dis->hDC, lastBrush);
2088 SelectObject(dis->hDC, lastPen);
2089 DeleteObject(hpen);
2090 }
2091 #endif
2092 }
2093
2094
2095 #ifdef _NO_EXTENSIONS
2096
2097 static void draw_splitbar(HWND hwnd, int x)
2098 {
2099 RECT rt;
2100 HDC hdc = GetDC(hwnd);
2101
2102 GetClientRect(hwnd, &rt);
2103
2104 rt.left = x - SPLIT_WIDTH/2;
2105 rt.right = x + SPLIT_WIDTH/2+1;
2106
2107 InvertRect(hdc, &rt);
2108
2109 ReleaseDC(hwnd, hdc);
2110 }
2111
2112 #endif
2113
2114
2115 #ifndef _NO_EXTENSIONS
2116
2117 static void set_header(Pane* pane)
2118 {
2119 HD_ITEM item;
2120 int scroll_pos = GetScrollPos(pane->hwnd, SB_HORZ);
2121 int i=0, x=0;
2122
2123 item.mask = HDI_WIDTH;
2124 item.cxy = 0;
2125
2126 for(; x+pane->widths[i]<scroll_pos && i<COLUMNS; i++) {
2127 x += pane->widths[i];
2128 Header_SetItem(pane->hwndHeader, i, &item);
2129 }
2130
2131 if (i < COLUMNS) {
2132 x += pane->widths[i];
2133 item.cxy = x - scroll_pos;
2134 Header_SetItem(pane->hwndHeader, i++, &item);
2135
2136 for(; i<COLUMNS; i++) {
2137 item.cxy = pane->widths[i];
2138 x += pane->widths[i];
2139 Header_SetItem(pane->hwndHeader, i, &item);
2140 }
2141 }
2142 }
2143
2144 static LRESULT pane_notify(Pane* pane, NMHDR* pnmh)
2145 {
2146 switch(pnmh->code) {
2147 case HDN_TRACK:
2148 case HDN_ENDTRACK: {
2149 HD_NOTIFY* phdn = (HD_NOTIFY*) pnmh;
2150 int idx = phdn->iItem;
2151 int dx = phdn->pitem->cxy - pane->widths[idx];
2152 int i;
2153
2154 RECT clnt;
2155 GetClientRect(pane->hwnd, &clnt);
2156
2157 /* move immediate to simulate HDS_FULLDRAG (for now [04/2000] not realy needed with WINELIB) */
2158 Header_SetItem(pane->hwndHeader, idx, phdn->pitem);
2159
2160 pane->widths[idx] += dx;
2161
2162 for(i=idx; ++i<=COLUMNS; )
2163 pane->positions[i] += dx;
2164
2165 {
2166 int scroll_pos = GetScrollPos(pane->hwnd, SB_HORZ);
2167 RECT rt_scr;
2168 RECT rt_clip;
2169
2170 rt_scr.left = pane->positions[idx+1]-scroll_pos;
2171 rt_scr.top = 0;
2172 rt_scr.right = clnt.right;
2173 rt_scr.bottom = clnt.bottom;
2174
2175 rt_clip.left = pane->positions[idx]-scroll_pos;
2176 rt_clip.top = 0;
2177 rt_clip.right = clnt.right;
2178 rt_clip.bottom = clnt.bottom;
2179
2180 if (rt_scr.left < 0) rt_scr.left = 0;
2181 if (rt_clip.left < 0) rt_clip.left = 0;
2182
2183 ScrollWindowEx(pane->hwnd, dx, 0, &rt_scr, &rt_clip, 0, 0, SW_INVALIDATE);
2184
2185 rt_clip.right = pane->positions[idx+1];
2186 RedrawWindow(pane->hwnd, &rt_clip, 0, RDW_INVALIDATE|RDW_UPDATENOW);
2187
2188 if (pnmh->code == HDN_ENDTRACK) {
2189 ListBox_SetHorizontalExtent(pane->hwnd, pane->positions[COLUMNS]);
2190
2191 if (GetScrollPos(pane->hwnd, SB_HORZ) != scroll_pos)
2192 set_header(pane);
2193 }
2194 }
2195
2196 return FALSE;
2197 }
2198
2199 case HDN_DIVIDERDBLCLICK: {
2200 HD_NOTIFY* phdn = (HD_NOTIFY*) pnmh;
2201 HD_ITEM item;
2202
2203 calc_single_width(pane, phdn->iItem);
2204 item.mask = HDI_WIDTH;
2205 item.cxy = pane->widths[phdn->iItem];
2206
2207 Header_SetItem(pane->hwndHeader, phdn->iItem, &item);
2208 InvalidateRect(pane->hwnd, 0, TRUE);
2209 break;}
2210 }
2211
2212 return 0;
2213 }
2214
2215 #endif
2216
2217
2218 static void scan_entry(ChildWnd* child, Entry* entry)
2219 {
2220 TCHAR path[MAX_PATH];
2221 int idx = ListBox_GetCurSel(child->left.hwnd);
2222 HCURSOR crsrOld = SetCursor(LoadCursor(0, IDC_WAIT));
2223
2224 /* delete sub entries in left pane */
2225 for(;;) {
2226 LRESULT res = ListBox_GetItemData(child->left.hwnd, idx+1);
2227 Entry* sub = (Entry*) res;
2228
2229 if (res==LB_ERR || !sub || sub->level<=entry->level)
2230 break;
2231
2232 ListBox_DeleteString(child->left.hwnd, idx+1);
2233 }
2234
2235 /* empty right pane */
2236 ListBox_ResetContent(child->right.hwnd);
2237
2238 /* release memory */
2239 free_entries(entry);
2240
2241 /* read contents from disk */
2242 get_path(entry, path);
2243 read_directory(entry, path, child->sortOrder);
2244
2245 /* insert found entries in right pane */
2246 insert_entries(&child->right, entry->down, -1);
2247 calc_widths(&child->right, FALSE);
2248 #ifndef _NO_EXTENSIONS
2249 set_header(&child->right);
2250 #endif
2251
2252 child->header_wdths_ok = FALSE;
2253
2254 SetCursor(crsrOld);
2255 }
2256
2257
2258 /* expand a directory entry */
2259
2260 static BOOL expand_entry(ChildWnd* child, Entry* dir)
2261 {
2262 int idx;
2263 Entry* p;
2264
2265 if (!dir || dir->expanded || !dir->down)
2266 return FALSE;
2267
2268 p = dir->down;
2269
2270 if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='\0' && p->next) {
2271 p = p->next;
2272
2273 if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='.' &&
2274 p->data.cFileName[2]=='\0' && p->next)
2275 p = p->next;
2276 }
2277
2278 /* no subdirectories ? */
2279 if (!(p->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
2280 return FALSE;
2281
2282 idx = ListBox_FindItemData(child->left.hwnd, 0, dir);
2283
2284 dir->expanded = TRUE;
2285
2286 /* insert entries in left pane */
2287 insert_entries(&child->left, p, idx);
2288
2289 if (!child->header_wdths_ok) {
2290 if (calc_widths(&child->left, FALSE)) {
2291 #ifndef _NO_EXTENSIONS
2292 set_header(&child->left);
2293 #endif
2294
2295 child->header_wdths_ok = TRUE;
2296 }
2297 }
2298
2299 return TRUE;
2300 }
2301
2302
2303 static void collapse_entry(Pane* pane, Entry* dir)
2304 {
2305 int idx = ListBox_FindItemData(pane->hwnd, 0, dir);
2306
2307 ShowWindow(pane->hwnd, SW_HIDE);
2308
2309 /* hide sub entries */
2310 for(;;) {
2311 LRESULT res = ListBox_GetItemData(pane->hwnd, idx+1);
2312 Entry* sub = (Entry*) res;
2313
2314 if (res==LB_ERR || !sub || sub->level<=dir->level)
2315 break;
2316
2317 ListBox_DeleteString(pane->hwnd, idx+1);
2318 }
2319
2320 dir->expanded = FALSE;
2321
2322 ShowWindow(pane->hwnd, SW_SHOW);
2323 }
2324
2325
2326 static void set_curdir(ChildWnd* child, Entry* entry)
2327 {
2328 TCHAR path[MAX_PATH];
2329
2330 child->left.cur = entry;
2331 child->right.root = entry->down;
2332 child->right.cur = entry;
2333
2334 if (!entry->scanned)
2335 scan_entry(child, entry);
2336 else {
2337 ListBox_ResetContent(child->right.hwnd);
2338 insert_entries(&child->right, entry->down, -1);
2339 calc_widths(&child->right, FALSE);
2340 #ifndef _NO_EXTENSIONS
2341 set_header(&child->right);
2342 #endif
2343 }
2344
2345 get_path(entry, path);
2346 lstrcpy(child->path, path);
2347
2348 if (child->hwnd) /* only change window title, if the window already exists */
2349 SetWindowText(child->hwnd, path);
2350
2351 SetCurrentDirectory(path);
2352 }
2353
2354
2355 static void activate_entry(ChildWnd* child, Pane* pane)
2356 {
2357 Entry* entry = pane->cur;
2358
2359 if (!entry)
2360 return;
2361
2362 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
2363 int scanned_old = entry->scanned;
2364
2365 if (!scanned_old)
2366 scan_entry(child, entry);
2367
2368 #ifndef _NO_EXTENSIONS
2369 if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='\0')
2370 return;
2371 #endif
2372
2373 if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='.' && entry->data.cFileName[2]=='\0') {
2374 entry = child->left.cur->up;
2375 collapse_entry(&child->left, entry);
2376 goto focus_entry;
2377 } else if (entry->expanded)
2378 collapse_entry(pane, child->left.cur);
2379 else {
2380 expand_entry(child, child->left.cur);
2381
2382 if (!pane->treePane) focus_entry: {
2383 int idx = ListBox_FindItemData(child->left.hwnd, ListBox_GetCurSel(child->left.hwnd), entry);
2384 ListBox_SetCurSel(child->left.hwnd, idx);
2385 set_curdir(child, entry);
2386 }
2387 }
2388
2389 if (!scanned_old) {
2390 calc_widths(pane, FALSE);
2391
2392 #ifndef _NO_EXTENSIONS
2393 set_header(pane);
2394 #endif
2395 }
2396 } else {
2397 TCHAR cmd[MAX_PATH];
2398 HINSTANCE hinst;
2399
2400 get_path(entry, cmd);
2401
2402 /* start program, open document... */
2403 hinst = ShellExecute(child->hwnd, NULL/*operation*/, cmd, NULL/*parameters*/, NULL/*dir*/, SW_SHOWNORMAL);
2404
2405 if ((int)hinst <= 32)
2406 display_error(child->hwnd, GetLastError());
2407 }
2408 }
2409
2410
2411 static BOOL pane_command(Pane* pane, UINT cmd)
2412 {
2413 switch(cmd) {
2414 case ID_VIEW_NAME:
2415 if (pane->visible_cols) {
2416 pane->visible_cols = 0;
2417 calc_widths(pane, TRUE);
2418 #ifndef _NO_EXTENSIONS
2419 set_header(pane);
2420 #endif
2421 InvalidateRect(pane->hwnd, 0, TRUE);
2422 CheckMenuItem(Globals.hMenuView, ID_VIEW_NAME, MF_BYCOMMAND|MF_CHECKED);
2423 CheckMenuItem(Globals.hMenuView, ID_VIEW_ALL_ATTRIBUTES, MF_BYCOMMAND);
2424 CheckMenuItem(Globals.hMenuView, ID_VIEW_SELECTED_ATTRIBUTES, MF_BYCOMMAND);
2425 }
2426 break;
2427
2428 case ID_VIEW_ALL_ATTRIBUTES:
2429 if (pane->visible_cols != COL_ALL) {
2430 pane->visible_cols = COL_ALL;
2431 calc_widths(pane, TRUE);
2432 #ifndef _NO_EXTENSIONS
2433 set_header(pane);
2434 #endif
2435 InvalidateRect(pane->hwnd, 0, TRUE);
2436 CheckMenuItem(Globals.hMenuView, ID_VIEW_NAME, MF_BYCOMMAND);
2437 CheckMenuItem(Globals.hMenuView, ID_VIEW_ALL_ATTRIBUTES, MF_BYCOMMAND|MF_CHECKED);
2438 CheckMenuItem(Globals.hMenuView, ID_VIEW_SELECTED_ATTRIBUTES, MF_BYCOMMAND);
2439 }
2440 break;
2441
2442 #ifndef _NO_EXTENSIONS
2443 case ID_PREFERED_SIZES: {
2444 calc_widths(pane, TRUE);
2445 set_header(pane);
2446 InvalidateRect(pane->hwnd, 0, TRUE);
2447 break;}
2448 #endif
2449
2450 /* TODO: more command ids... */
2451
2452 default:
2453 return FALSE;
2454 }
2455
2456 return TRUE;
2457 }
2458
2459
2460 LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
2461 {
2462 static int last_split;
2463
2464 ChildWnd* child = (ChildWnd*) GetWindowLong(hwnd, GWL_USERDATA);
2465 ASSERT(child);
2466
2467 switch(nmsg) {
2468 case WM_DRAWITEM: {
2469 LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lparam;
2470 Entry* entry = (Entry*) dis->itemData;
2471
2472 if (dis->CtlID == IDW_TREE_LEFT)
2473 draw_item(&child->left, dis, entry, -1);
2474 else
2475 draw_item(&child->right, dis, entry, -1);
2476
2477 return TRUE;}
2478
2479 case WM_CREATE:
2480 InitChildWindow(child);
2481 break;
2482
2483 case WM_NCDESTROY:
2484 free_child_window(child);
2485 SetWindowLong(hwnd, GWL_USERDATA, 0);
2486 break;
2487
2488 case WM_PAINT: {
2489 PAINTSTRUCT ps;
2490 HBRUSH lastBrush;
2491 RECT rt;
2492 GetClientRect(hwnd, &rt);
2493 BeginPaint(hwnd, &ps);
2494 rt.left = child->split_pos-SPLIT_WIDTH/2;
2495 rt.right = child->split_pos+SPLIT_WIDTH/2+1;
2496 lastBrush = SelectBrush(ps.hdc, (HBRUSH)GetStockObject(COLOR_SPLITBAR));
2497 Rectangle(ps.hdc, rt.left, rt.top-1, rt.right, rt.bottom+1);
2498 SelectObject(ps.hdc, lastBrush);
2499 #ifdef _NO_EXTENSIONS
2500 rt.top = rt.bottom - GetSystemMetrics(SM_CYHSCROLL);
2501 FillRect(ps.hdc, &rt, GetStockObject(BLACK_BRUSH));
2502 #endif
2503 EndPaint(hwnd, &ps);
2504 break;}
2505
2506 case WM_SETCURSOR:
2507 if (LOWORD(lparam) == HTCLIENT) {
2508 POINT pt;
2509 GetCursorPos(&pt);
2510 ScreenToClient(hwnd, &pt);
2511
2512 if (pt.x>=child->split_pos-SPLIT_WIDTH/2 && pt.x<child->split_pos+SPLIT_WIDTH/2+1) {
2513 SetCursor(LoadCursor(0, IDC_SIZEWE));
2514 return TRUE;
2515 }
2516 }
2517 goto def;
2518
2519 case WM_LBUTTONDOWN: {
2520 RECT rt;
2521 int x = LOWORD(lparam);
2522
2523 GetClientRect(hwnd, &rt);
2524
2525 if (x>=child->split_pos-SPLIT_WIDTH/2 && x<child->split_pos+SPLIT_WIDTH/2+1) {
2526 last_split = child->split_pos;
2527 #ifdef _NO_EXTENSIONS
2528 draw_splitbar(hwnd, last_split);
2529 #endif
2530 SetCapture(hwnd);
2531 }
2532
2533 break;}
2534
2535 case WM_LBUTTONUP:
2536 if (GetCapture() == hwnd) {
2537 #ifdef _NO_EXTENSIONS
2538 RECT rt;
2539 int x = LOWORD(lparam);
2540 draw_splitbar(hwnd, last_split);
2541 last_split = -1;
2542 GetClientRect(hwnd, &rt);
2543 child->split_pos = x;
2544 resize_tree(child, rt.right, rt.bottom);
2545 #endif
2546 ReleaseCapture();
2547 }
2548 break;
2549
2550 #ifdef _NO_EXTENSIONS
2551 case WM_CAPTURECHANGED:
2552 if (GetCapture()==hwnd && last_split>=0)
2553 draw_splitbar(hwnd, last_split);
2554 break;
2555 #endif
2556
2557 case WM_KEYDOWN:
2558 if (wparam == VK_ESCAPE)
2559 if (GetCapture() == hwnd) {
2560 RECT rt;
2561 #ifdef _NO_EXTENSIONS
2562 draw_splitbar(hwnd, last_split);
2563 #else
2564 child->split_pos = last_split;
2565 #endif
2566 GetClientRect(hwnd, &rt);
2567 resize_tree(child, rt.right, rt.bottom);
2568 last_split = -1;
2569 ReleaseCapture();
2570 SetCursor(LoadCursor(0, IDC_ARROW));
2571 }
2572 break;
2573
2574 case WM_MOUSEMOVE:
2575 if (GetCapture() == hwnd) {
2576 RECT rt;
2577 int x = LOWORD(lparam);
2578
2579 #ifdef _NO_EXTENSIONS
2580 HDC hdc = GetDC(hwnd);
2581 GetClientRect(hwnd, &rt);
2582
2583 rt.left = last_split-SPLIT_WIDTH/2;
2584 rt.right = last_split+SPLIT_WIDTH/2+1;
2585 InvertRect(hdc, &rt);
2586
2587 last_split = x;
2588 rt.left = x-SPLIT_WIDTH/2;
2589 rt.right = x+SPLIT_WIDTH/2+1;
2590 InvertRect(hdc, &rt);
2591
2592 ReleaseDC(hwnd, hdc);
2593 #else
2594 GetClientRect(hwnd, &rt);
2595
2596 if (x>=0 && x<rt.right) {
2597 child->split_pos = x;
2598 resize_tree(child, rt.right, rt.bottom);
2599 rt.left = x-SPLIT_WIDTH/2;
2600 rt.right = x+SPLIT_WIDTH/2+1;
2601 InvalidateRect(hwnd, &rt, FALSE);
2602 UpdateWindow(child->left.hwnd);
2603 UpdateWindow(hwnd);
2604 UpdateWindow(child->right.hwnd);
2605 }
2606 #endif
2607 }
2608 break;
2609
2610 #ifndef _NO_EXTENSIONS
2611 case WM_GETMINMAXINFO:
2612 DefMDIChildProc(hwnd, nmsg, wparam, lparam);
2613
2614 {LPMINMAXINFO lpmmi = (LPMINMAXINFO)lparam;
2615
2616 lpmmi->ptMaxTrackSize.x <<= 1;/*2*GetSystemMetrics(SM_CXSCREEN) / SM_CXVIRTUALSCREEN */
2617 lpmmi->ptMaxTrackSize.y <<= 1;/*2*GetSystemMetrics(SM_CYSCREEN) / SM_CYVIRTUALSCREEN */
2618 break;}
2619 #endif
2620
2621 case WM_SETFOCUS:
2622 SetCurrentDirectory(child->path);
2623 SetFocus(child->focus_pane? child->right.hwnd: child->left.hwnd);
2624 break;
2625
2626 case WM_DISPATCH_COMMAND: {
2627 Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
2628
2629 switch(LOWORD(wparam)) {
2630 case ID_WINDOW_NEW: {
2631 ChildWnd* new_child = alloc_child_window(child->path);
2632
2633 if (!create_child_window(new_child))
2634 free(new_child);
2635
2636 break;}
2637
2638 case ID_REFRESH:
2639 scan_entry(child, pane->cur);
2640 break;
2641
2642 case ID_ACTIVATE:
2643 activate_entry(child, pane);
2644 break;
2645
2646 default:
2647 return pane_command(pane, LOWORD(wparam));
2648 }
2649
2650 return TRUE;}
2651
2652 case WM_COMMAND: {
2653 Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
2654
2655 switch(HIWORD(wparam)) {
2656 case LBN_SELCHANGE: {
2657 int idx = ListBox_GetCurSel(pane->hwnd);
2658 Entry* entry = (Entry*) ListBox_GetItemData(pane->hwnd, idx);
2659
2660 if (pane == &child->left)
2661 set_curdir(child, entry);
2662 else
2663 pane->cur = entry;
2664 break;}
2665
2666 case LBN_DBLCLK:
2667 activate_entry(child, pane);
2668 break;
2669 }
2670 break;}
2671
2672 #ifndef _NO_EXTENSIONS
2673 case WM_NOTIFY: {
2674 NMHDR* pnmh = (NMHDR*) lparam;
2675 return pane_notify(pnmh->idFrom==IDW_HEADER_LEFT? &child->left: &child->right, pnmh);}
2676 #endif
2677
2678 case WM_SIZE:
2679 if (wparam != SIZE_MINIMIZED)
2680 resize_tree(child, LOWORD(lparam), HIWORD(lparam));
2681 /* fall through */
2682
2683 default: def:
2684 return DefMDIChildProc(hwnd, nmsg, wparam, lparam);
2685 }
2686
2687 return 0;
2688 }
2689
2690
2691 LRESULT CALLBACK TreeWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
2692 {
2693 ChildWnd* child = (ChildWnd*) GetWindowLong(GetParent(hwnd), GWL_USERDATA);
2694 Pane* pane = (Pane*) GetWindowLong(hwnd, GWL_USERDATA);
2695 ASSERT(child);
2696
2697 switch(nmsg) {
2698 #ifndef _NO_EXTENSIONS
2699 case WM_HSCROLL:
2700 set_header(pane);
2701 break;
2702 #endif
2703
2704 case WM_SETFOCUS:
2705 child->focus_pane = pane==&child->right? 1: 0;
2706 ListBox_SetSel(hwnd, TRUE, 1);
2707 /*TODO: check menu items */
2708 break;
2709
2710 case WM_KEYDOWN:
2711 if (wparam == VK_TAB) {
2712 /*TODO: SetFocus(Globals.hdrivebar) */
2713 SetFocus(child->focus_pane? child->left.hwnd: child->right.hwnd);
2714 }
2715 }
2716
2717 return CallWindowProc(g_orgTreeWndProc, hwnd, nmsg, wparam, lparam);
2718 }
2719
2720
2721 static void InitInstance(HINSTANCE hinstance)
2722 {
2723 WNDCLASSEX wcFrame;
2724 ATOM hframeClass;
2725 WNDCLASS wcChild;
2726 WINE_UNUSED ATOM hChildClass;
2727 HMENU hMenuFrame = LoadMenu(hinstance, MAKEINTRESOURCE(IDM_WINEFILE));
2728 HMENU hMenuWindow = GetSubMenu(hMenuFrame, GetMenuItemCount(hMenuFrame)-2);
2729
2730 CLIENTCREATESTRUCT ccs;
2731
2732 INITCOMMONCONTROLSEX icc = {
2733 sizeof(INITCOMMONCONTROLSEX),
2734 ICC_BAR_CLASSES
2735 };
2736
2737 ChildWnd* child;
2738 TCHAR path[MAX_PATH];
2739
2740 HDC hdc = GetDC(0);
2741
2742
2743 wcFrame.cbSize = sizeof(WNDCLASSEX);
2744 wcFrame.style = 0;
2745 wcFrame.lpfnWndProc = FrameWndProc;
2746 wcFrame.cbClsExtra = 0;
2747 wcFrame.cbWndExtra = 0;
2748 wcFrame.hInstance = hinstance;
2749 wcFrame.hIcon = LoadIcon(hinstance,
2750 MAKEINTRESOURCE(IDI_WINEFILE));
2751 wcFrame.hCursor = LoadCursor(0, IDC_ARROW);
2752 wcFrame.hbrBackground = 0;
2753 wcFrame.lpszMenuName = 0;
2754 wcFrame.lpszClassName = WINEFILEFRAME;
2755 wcFrame.hIconSm = (HICON)LoadImage(hinstance,
2756 MAKEINTRESOURCE(IDI_WINEFILE),
2757 IMAGE_ICON,
2758 GetSystemMetrics(SM_CXSMICON),
2759 GetSystemMetrics(SM_CYSMICON),
2760 LR_SHARED);
2761
2762 /* register frame window class */
2763 hframeClass = RegisterClassEx(&wcFrame);
2764
2765 wcChild.style = CS_CLASSDC|CS_DBLCLKS|CS_VREDRAW;
2766 wcChild.lpfnWndProc = ChildWndProc;
2767 wcChild.cbClsExtra = 0;
2768 wcChild.cbWndExtra = 0;
2769 wcChild.hInstance = hinstance;
2770 wcChild.hIcon = 0;
2771 wcChild.hCursor = LoadCursor(0, IDC_ARROW);
2772 wcChild.hbrBackground = 0;
2773 wcChild.lpszMenuName = 0;
2774 wcChild.lpszClassName = WINEFILETREE;
2775
2776 /* register tree windows class */
2777 hChildClass = RegisterClass(&wcChild);
2778
2779 ccs.hWindowMenu = hMenuWindow;
2780 ccs.idFirstChild = IDW_FIRST_CHILD;
2781
2782 Globals.hMenuFrame = hMenuFrame;
2783 Globals.hMenuView = GetSubMenu(hMenuFrame, 3);
2784 Globals.hMenuOptions = GetSubMenu(hMenuFrame, 4);
2785
2786 Globals.haccel = LoadAccelerators(hinstance, MAKEINTRESOURCE(IDA_WINEFILE));
2787
2788 Globals.hfont = CreateFont(-MulDiv(8,GetDeviceCaps(hdc,LOGPIXELSY),72), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _T("MS Sans Serif"));
2789
2790 ReleaseDC(0, hdc);
2791
2792 Globals.hInstance = hinstance;
2793
2794 /* create main window */
2795 Globals.hMainWnd = CreateWindowEx(0, (LPCTSTR)(int)hframeClass, _T("Wine File"), WS_OVERLAPPEDWINDOW,
2796 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
2797 0/*hWndParent*/, Globals.hMenuFrame, hinstance, 0/*lpParam*/);
2798
2799
2800 Globals.hmdiclient = CreateWindowEx(0, _T("MDICLIENT"), NULL,
2801 WS_CHILD|WS_CLIPCHILDREN|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE|WS_BORDER,
2802 0, 0, 0, 0,
2803 Globals.hMainWnd, 0, hinstance, &ccs);
2804
2805
2806 InitCommonControlsEx(&icc);
2807
2808 {
2809 TBBUTTON drivebarBtn = {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP};
2810 int btn = 1;
2811 PTSTR p;
2812
2813 Globals.hdrivebar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE|CCS_NOMOVEY|TBSTYLE_LIST,
2814 IDW_DRIVEBAR, 2, Globals.hInstance, IDB_DRIVEBAR, &drivebarBtn,
2815 1, 16, 13, 16, 13, sizeof(TBBUTTON));
2816 CheckMenuItem(Globals.hMenuOptions, ID_VIEW_DRIVE_BAR, MF_BYCOMMAND|MF_CHECKED);
2817
2818 GetLogicalDriveStrings(BUFFER_LEN, Globals.drives);
2819
2820 drivebarBtn.fsStyle = TBSTYLE_BUTTON;
2821
2822 #ifndef _NO_EXTENSIONS
2823 #ifdef __linux__
2824 /* insert unix file system button */
2825 SendMessage(Globals.hdrivebar, TB_ADDSTRING, 0, (LPARAM)_T("/\0"));
2826
2827 drivebarBtn.idCommand = ID_DRIVE_UNIX_FS;
2828 SendMessage(Globals.hdrivebar, TB_INSERTBUTTON, btn++, (LPARAM)&drivebarBtn);
2829 drivebarBtn.iString++;
2830 #endif
2831
2832 /* register windows drive root strings */
2833 SendMessage(Globals.hdrivebar, TB_ADDSTRING, 0, (LPARAM)Globals.drives);
2834 #endif
2835
2836 drivebarBtn.idCommand = ID_DRIVE_FIRST;
2837
2838 for(p=Globals.drives; *p; ) {
2839 #ifdef _NO_EXTENSIONS
2840 /* insert drive letter */
2841 TCHAR b[3] = {tolower(*p)};
2842 SendMessage(Globals.hdrivebar, TB_ADDSTRING, 0, (LPARAM)b);
2843 #endif
2844 switch(GetDriveType(p)) {
2845 case DRIVE_REMOVABLE: drivebarBtn.iBitmap = 1; break;
2846 case DRIVE_CDROM: drivebarBtn.iBitmap = 3; break;
2847 case DRIVE_REMOTE: drivebarBtn.iBitmap = 4; break;
2848 case DRIVE_RAMDISK: drivebarBtn.iBitmap = 5; break;
2849 default:/*DRIVE_FIXED*/ drivebarBtn.iBitmap = 2;
2850 }
2851
2852 SendMessage(Globals.hdrivebar, TB_INSERTBUTTON, btn++, (LPARAM)&drivebarBtn);
2853 drivebarBtn.idCommand++;
2854 drivebarBtn.iString++;
2855
2856 while(*p++);
2857 }
2858 }
2859
2860 {
2861 TBBUTTON toolbarBtns[] = {
2862 {0, 0, 0, TBSTYLE_SEP},
2863 {0, ID_WINDOW_NEW, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2864 {1, ID_WINDOW_CASCADE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2865 {2, ID_WINDOW_TILE_HORZ, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2866 {3, ID_WINDOW_TILE_VERT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2867 {4, 2/*TODO: ID_...*/, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2868 {5, 2/*TODO: ID_...*/, TBSTATE_ENABLED, TBSTYLE_BUTTON},
2869 };
2870
2871 Globals.htoolbar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE,
2872 IDW_TOOLBAR, 2, Globals.hInstance, IDB_TOOLBAR, toolbarBtns,
2873 sizeof(toolbarBtns)/sizeof(TBBUTTON), 16, 15, 16, 15, sizeof(TBBUTTON));
2874 CheckMenuItem(Globals.hMenuOptions, ID_VIEW_TOOL_BAR, MF_BYCOMMAND|MF_CHECKED);
2875 }
2876
2877 Globals.hstatusbar = CreateStatusWindow(WS_CHILD|WS_VISIBLE, 0, Globals.hMainWnd, IDW_STATUSBAR);
2878 CheckMenuItem(Globals.hMenuOptions, ID_VIEW_STATUSBAR, MF_BYCOMMAND|MF_CHECKED);
2879
2880 /* CreateStatusWindow does not accept WS_BORDER
2881 Globals.hstatusbar = CreateWindowEx(WS_EX_NOPARENTNOTIFY, STATUSCLASSNAME, 0,
2882 WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_BORDER|CCS_NODIVIDER, 0,0,0,0,
2883 Globals.hMainWnd, (HMENU)IDW_STATUSBAR, hinstance, 0);*/
2884
2885 /*TODO: read paths and window placements from registry */
2886 GetCurrentDirectory(MAX_PATH, path);
2887 child = alloc_child_window(path);
2888
2889 child->pos.showCmd = SW_SHOWMAXIMIZED;
2890 child->pos.rcNormalPosition.left = 0;
2891 child->pos.rcNormalPosition.top = 0;
2892 child->pos.rcNormalPosition.right = 320;
2893 child->pos.rcNormalPosition.bottom = 280;
2894
2895 if (!create_child_window(child))
2896 free(child);
2897
2898 SetWindowPlacement(child->hwnd, &child->pos);
2899
2900 Globals.himl = ImageList_LoadBitmap(Globals.hInstance, MAKEINTRESOURCE(IDB_IMAGES), 16, 0, RGB(0,255,0));
2901
2902 Globals.prescan_node = FALSE;
2903 }
2904
2905 void ExitInstance()
2906 {
2907 ImageList_Destroy(Globals.himl);
2908 }
2909
2910
2911 #ifdef _NO_EXTENSIONS
2912
2913 /* search for already running win[e]files */
2914
2915 static int g_foundPrevInstance = 0;
2916
2917 static BOOL CALLBACK EnumWndProc(HWND hwnd, LPARAM lparam)
2918 {
2919 TCHAR cls[128];
2920
2921 GetClassName(hwnd, cls, 128);
2922
2923 if (!lstrcmp(cls, (LPCTSTR)lparam)) {
2924 g_foundPrevInstance++;
2925 return FALSE;
2926 }
2927
2928 return TRUE;
2929 }
2930
2931 #endif
2932
2933
2934 int APIENTRY WinMain(HINSTANCE hinstance,
2935 HINSTANCE previnstance,
2936 LPSTR cmdline,
2937 int cmdshow)
2938 {
2939 MSG msg;
2940
2941 #ifdef _NO_EXTENSIONS
2942 /* allow only one running instance */
2943 EnumWindows(EnumWndProc, (LPARAM)WINEFILEFRAME);
2944
2945 if (g_foundPrevInstance)
2946 return 1;
2947 #endif
2948
2949 InitInstance(hinstance);
2950
2951 if (cmdshow == SW_SHOWNORMAL) {
2952 /*TODO: read window placement from registry */
2953 cmdshow = SW_MAXIMIZE;
2954 }
2955
2956 ShowWindow(Globals.hMainWnd, cmdshow);
2957 UpdateWindow(Globals.hMainWnd);
2958
2959 while(GetMessage(&msg, 0, 0, 0)) {
2960 if (!TranslateMDISysAccel(Globals.hmdiclient, &msg) &&
2961 !TranslateAccelerator(Globals.hMainWnd, Globals.haccel, &msg))
2962 {
2963 TranslateMessage(&msg);
2964 DispatchMessage(&msg);
2965 }
2966 }
2967
2968 ExitInstance();
2969
2970 return 0;
2971 }
Windows API implementation