db931cb8f05b224715b245b82dac8c8867b8f1a5
[reactos.git] / reactos / base / shell / explorer / explorer.cpp
1 /*
2 * Copyright 2003, 2004, 2005, 2006 Martin Fuchs
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19
20 //
21 // Explorer clone
22 //
23 // explorer.cpp
24 //
25 // Martin Fuchs, 23.07.2003
26 //
27 // Credits: Thanks to Leon Finker for his explorer cabinet window example
28 //
29
30
31 #include <precomp.h> // <precomp.h> instead of "precomp.h" because the ROS build system needs this to find the precompiled header file (*.gch) in the output directory tree
32
33 #include <shlwapi.h>
34 #include <locale.h> // for setlocale()
35
36 #ifndef __WINE__
37 #include <io.h> // for dup2()
38 #include <fcntl.h> // for _O_RDONLY
39 #endif
40
41 //#include "dialogs/settings.h" // for MdiSdiDlg
42
43 #include "services/shellservices.h"
44
45
46 extern "C" int initialize_gdb_stub(); // start up GDB stub
47
48
49 DynamicLoadLibFct<void(__stdcall*)(BOOL)> g_SHDOCVW_ShellDDEInit(TEXT("SHDOCVW"), 118);
50
51
52 ExplorerGlobals g_Globals;
53 boolean SelectOpt=FALSE;
54
55
56 ExplorerGlobals::ExplorerGlobals()
57 {
58 _hInstance = 0;
59 _cfStrFName = 0;
60
61 #ifndef ROSSHELL
62 _hframeClass = 0;
63 _hMainWnd = 0;
64 _desktop_mode = false;
65 _prescan_nodes = false;
66 #endif
67
68 _log = NULL;
69 _SHRestricted = 0;
70 _hwndDesktopBar = 0;
71 _hwndShellView = 0;
72 _hwndDesktop = 0;
73 }
74
75
76 void ExplorerGlobals::init(HINSTANCE hInstance)
77 {
78 _hInstance = hInstance;
79 _SHRestricted = (DWORD(STDAPICALLTYPE*)(RESTRICTIONS)) GetProcAddress(GetModuleHandle(TEXT("SHELL32")), "SHRestricted");
80 _icon_cache.init();
81 }
82
83
84 void ExplorerGlobals::read_persistent()
85 {
86 // read configuration file
87 _cfg_dir.printf(TEXT("%s\\ReactOS"), (LPCTSTR)SpecialFolderFSPath(CSIDL_APPDATA,0));
88 _cfg_path.printf(TEXT("%s\\ros-explorer-cfg.xml"), _cfg_dir.c_str());
89
90 if (!_cfg.read_file(_cfg_path)) {
91 if (!_cfg._errors.empty()) {
92 MessageBox(_hwndDesktop,
93 _cfg._errors.str(),
94 TEXT("ROS Explorer - reading user settings"),
95 MB_OK);
96 }
97 _cfg.read_file(TEXT("explorer-cfg-template.xml"));
98 }
99
100 // read bookmarks
101 _favorites_path.printf(TEXT("%s\\ros-explorer-bookmarks.xml"), _cfg_dir.c_str());
102
103 if (!_favorites.read(_favorites_path)) {
104 _favorites.import_IE_favorites(0);
105 _favorites.write(_favorites_path);
106 }
107 }
108
109 void ExplorerGlobals::write_persistent()
110 {
111 // write configuration file
112 RecursiveCreateDirectory(_cfg_dir);
113
114 _cfg.write_file(_cfg_path);
115 _favorites.write(_favorites_path);
116 }
117
118
119 XMLPos ExplorerGlobals::get_cfg()
120 {
121 XMLPos cfg_pos(&_cfg);
122
123 cfg_pos.smart_create("explorer-cfg");
124
125 return cfg_pos;
126 }
127
128 XMLPos ExplorerGlobals::get_cfg(const char* path)
129 {
130 XMLPos cfg_pos(&_cfg);
131
132 cfg_pos.smart_create("explorer-cfg");
133 cfg_pos.create_relative(path);
134
135 return cfg_pos;
136 }
137
138
139 void _log_(LPCTSTR txt)
140 {
141 FmtString msg(TEXT("%s\n"), txt);
142
143 if (g_Globals._log)
144 _fputts(msg, g_Globals._log);
145
146 OutputDebugString(msg);
147 }
148
149
150 bool FileTypeManager::is_exe_file(LPCTSTR ext)
151 {
152 static const LPCTSTR s_executable_extensions[] = {
153 TEXT("COM"),
154 TEXT("EXE"),
155 TEXT("BAT"),
156 TEXT("CMD"),
157 TEXT("CMM"),
158 TEXT("BTM"),
159 TEXT("AWK"),
160 0
161 };
162
163 TCHAR ext_buffer[_MAX_EXT];
164 const LPCTSTR* p;
165 LPCTSTR s;
166 LPTSTR d;
167
168 for(s=ext+1,d=ext_buffer; (*d=toupper(*s)); s++)
169 ++d;
170
171 for(p=s_executable_extensions; *p; p++)
172 if (!lstrcmp(ext_buffer, *p))
173 return true;
174
175 return false;
176 }
177
178
179 const FileTypeInfo& FileTypeManager::operator[](String ext)
180 {
181 ext.toLower();
182
183 iterator found = find(ext);
184 if (found != end())
185 return found->second;
186
187 FileTypeInfo& ftype = super::operator[](ext);
188
189 ftype._neverShowExt = false;
190
191 HKEY hkey;
192 TCHAR value[MAX_PATH], display_name[MAX_PATH];
193 LONG valuelen = sizeof(value);
194
195 if (!RegQueryValue(HKEY_CLASSES_ROOT, ext, value, &valuelen)) {
196 ftype._classname = value;
197
198 valuelen = sizeof(display_name);
199 if (!RegQueryValue(HKEY_CLASSES_ROOT, ftype._classname, display_name, &valuelen))
200 ftype._displayname = display_name;
201
202 if (!RegOpenKey(HKEY_CLASSES_ROOT, ftype._classname, &hkey)) {
203 if (!RegQueryValueEx(hkey, TEXT("NeverShowExt"), 0, NULL, NULL, NULL))
204 ftype._neverShowExt = true;
205
206 RegCloseKey(hkey);
207 }
208 }
209
210 return ftype;
211 }
212
213 LPCTSTR FileTypeManager::set_type(Entry* entry, bool dont_hide_ext)
214 {
215 LPCTSTR ext = _tcsrchr(entry->_data.cFileName, TEXT('.'));
216
217 if (ext) {
218 const FileTypeInfo& type = (*this)[ext];
219
220 if (!type._displayname.empty())
221 entry->_type_name = _tcsdup(type._displayname);
222
223 // hide some file extensions
224 if (type._neverShowExt && !dont_hide_ext) {
225 int len = ext - entry->_data.cFileName;
226
227 if (entry->_display_name != entry->_data.cFileName)
228 free(entry->_display_name);
229
230 entry->_display_name = (LPTSTR) malloc((len+1)*sizeof(TCHAR));
231 lstrcpyn(entry->_display_name, entry->_data.cFileName, len + 1);
232 }
233
234 if (is_exe_file(ext))
235 entry->_data.dwFileAttributes |= ATTRIBUTE_EXECUTABLE;
236 }
237
238 return ext;
239 }
240
241
242 Icon::Icon()
243 : _id(ICID_UNKNOWN),
244 _itype(IT_STATIC),
245 _hicon(0)
246 {
247 }
248
249 Icon::Icon(ICON_ID id, UINT nid) //, int cx, int cy
250 : _id(id),
251 _itype(IT_STATIC),
252 _hicon(ResIcon(nid)) // ResIconEx(nid, cx, cy)
253 {
254 }
255
256 Icon::Icon(ICON_ID id, UINT nid, int icon_size)
257 : _id(id),
258 _itype(IT_STATIC),
259 _hicon(ResIconEx(nid, icon_size, icon_size))
260 {
261 }
262
263 Icon::Icon(ICON_TYPE itype, int id, HICON hIcon)
264 : _id((ICON_ID)id),
265 _itype(itype),
266 _hicon(hIcon)
267 {
268 }
269
270 Icon::Icon(ICON_TYPE itype, int id, int sys_idx)
271 : _id((ICON_ID)id),
272 _itype(itype),
273 _sys_idx(sys_idx)
274 {
275 }
276
277 void Icon::draw(HDC hdc, int x, int y, int cx, int cy, COLORREF bk_color, HBRUSH bk_brush) const
278 {
279 if (_itype == IT_SYSCACHE)
280 ImageList_DrawEx(g_Globals._icon_cache.get_sys_imagelist(), _sys_idx, hdc, x, y, cx, cy, bk_color, CLR_DEFAULT, ILD_NORMAL);
281 else
282 DrawIconEx(hdc, x, y, _hicon, cx, cy, 0, bk_brush, DI_NORMAL);
283 }
284
285 HBITMAP Icon::create_bitmap(COLORREF bk_color, HBRUSH hbrBkgnd, HDC hdc_wnd) const
286 {
287 if (_itype == IT_SYSCACHE) {
288 HIMAGELIST himl = g_Globals._icon_cache.get_sys_imagelist();
289
290 int cx, cy;
291 ImageList_GetIconSize(himl, &cx, &cy);
292
293 HBITMAP hbmp = CreateCompatibleBitmap(hdc_wnd, cx, cy);
294 HDC hdc = CreateCompatibleDC(hdc_wnd);
295 HBITMAP hbmp_old = SelectBitmap(hdc, hbmp);
296 ImageList_DrawEx(himl, _sys_idx, hdc, 0, 0, cx, cy, bk_color, CLR_DEFAULT, ILD_NORMAL);
297 SelectBitmap(hdc, hbmp_old);
298 DeleteDC(hdc);
299
300 return hbmp;
301 } else
302 return create_bitmap_from_icon(_hicon, hbrBkgnd, hdc_wnd);
303 }
304
305
306 int Icon::add_to_imagelist(HIMAGELIST himl, HDC hdc_wnd, COLORREF bk_color, HBRUSH bk_brush) const
307 {
308 int ret;
309
310 if (_itype == IT_SYSCACHE) {
311 HIMAGELIST himl = g_Globals._icon_cache.get_sys_imagelist();
312
313 int cx, cy;
314 ImageList_GetIconSize(himl, &cx, &cy);
315
316 HBITMAP hbmp = CreateCompatibleBitmap(hdc_wnd, cx, cy);
317 HDC hdc = CreateCompatibleDC(hdc_wnd);
318 HBITMAP hbmp_old = SelectBitmap(hdc, hbmp);
319 ImageList_DrawEx(himl, _sys_idx, hdc, 0, 0, cx, cy, bk_color, CLR_DEFAULT, ILD_NORMAL);
320 SelectBitmap(hdc, hbmp_old);
321 DeleteDC(hdc);
322
323 ret = ImageList_Add(himl, hbmp, 0);
324
325 DeleteObject(hbmp);
326 } else
327 ret = ImageList_AddAlphaIcon(himl, _hicon, bk_brush, hdc_wnd);
328
329 return ret;
330 }
331
332 HBITMAP create_bitmap_from_icon(HICON hIcon, HBRUSH hbrush_bkgnd, HDC hdc_wnd/*, int icon_size*/)
333 {
334 int cx = ICON_SIZE_SMALL;
335 int cy = ICON_SIZE_SMALL;
336 HBITMAP hbmp = CreateCompatibleBitmap(hdc_wnd, cx, cy);
337
338 MemCanvas canvas;
339 BitmapSelection sel(canvas, hbmp);
340
341 RECT rect = {0, 0, cx, cy};
342 FillRect(canvas, &rect, hbrush_bkgnd);
343
344 DrawIconEx(canvas, 0, 0, hIcon, cx, cy, 0, hbrush_bkgnd, DI_NORMAL);
345
346 return hbmp;
347 }
348
349 HBITMAP create_small_bitmap_from_icon(HICON hIcon, HBRUSH hbrush_bkgnd, HDC hdc_wnd)
350 {
351 int cx = GetSystemMetrics(SM_CXSMICON);
352 int cy = GetSystemMetrics(SM_CYSMICON);
353 HBITMAP hbmp = CreateCompatibleBitmap(hdc_wnd, cx, cy);
354
355 MemCanvas canvas;
356 BitmapSelection sel(canvas, hbmp);
357
358 RECT rect = {0, 0, cx, cy};
359 FillRect(canvas, &rect, hbrush_bkgnd);
360
361 DrawIconEx(canvas, 0, 0, hIcon, cx, cy, 0, hbrush_bkgnd, DI_NORMAL);
362
363 return hbmp;
364 }
365
366 int ImageList_AddAlphaIcon(HIMAGELIST himl, HICON hIcon, HBRUSH hbrush_bkgnd, HDC hdc_wnd)
367 {
368 HBITMAP hbmp = create_bitmap_from_icon(hIcon, hbrush_bkgnd, hdc_wnd);
369
370 int ret = ImageList_Add(himl, hbmp, 0);
371
372 DeleteObject(hbmp);
373
374 return ret;
375 }
376
377
378 int IconCache::s_next_id = ICID_DYNAMIC;
379
380
381 void IconCache::init()
382 {
383 int icon_size = STARTMENUROOT_ICON_SIZE;
384
385 _icons[ICID_NONE] = Icon(IT_STATIC, ICID_NONE, (HICON)0);
386
387 _icons[ICID_FOLDER] = Icon(ICID_FOLDER, IDI_FOLDER);
388 //_icons[ICID_DOCUMENT] = Icon(ICID_DOCUMENT, IDI_DOCUMENT);
389 _icons[ICID_EXPLORER] = Icon(ICID_EXPLORER, IDI_EXPLORER);
390 //_icons[ICID_APP] = Icon(ICID_APP, IDI_APPICON);
391
392 _icons[ICID_CONFIG] = Icon(ICID_CONFIG, IDI_CONFIG, icon_size);
393 _icons[ICID_DOCUMENTS] = Icon(ICID_DOCUMENTS, IDI_DOCUMENTS, icon_size);
394 _icons[ICID_FAVORITES] = Icon(ICID_FAVORITES, IDI_FAVORITES, icon_size);
395 _icons[ICID_INFO] = Icon(ICID_INFO, IDI_INFO, icon_size);
396 _icons[ICID_APPS] = Icon(ICID_APPS, IDI_APPS, icon_size);
397 _icons[ICID_SEARCH] = Icon(ICID_SEARCH, IDI_SEARCH, icon_size);
398 _icons[ICID_ACTION] = Icon(ICID_ACTION, IDI_ACTION, icon_size);
399 _icons[ICID_SEARCH_DOC] = Icon(ICID_SEARCH_DOC, IDI_SEARCH_DOC, icon_size);
400 _icons[ICID_PRINTER] = Icon(ICID_PRINTER, IDI_PRINTER, icon_size);
401 _icons[ICID_NETWORK] = Icon(ICID_NETWORK, IDI_NETWORK, icon_size);
402 _icons[ICID_COMPUTER] = Icon(ICID_COMPUTER, IDI_COMPUTER, icon_size);
403 _icons[ICID_LOGOFF] = Icon(ICID_LOGOFF, IDI_LOGOFF, icon_size);
404 _icons[ICID_SHUTDOWN] = Icon(ICID_SHUTDOWN, IDI_SHUTDOWN, icon_size);
405 _icons[ICID_RESTART] = Icon(ICID_RESTART, IDI_RESTART, icon_size);
406 _icons[ICID_BOOKMARK] = Icon(ICID_BOOKMARK, IDI_DOT_TRANS, icon_size);
407 _icons[ICID_MINIMIZE] = Icon(ICID_MINIMIZE, IDI_MINIMIZE, icon_size);
408 _icons[ICID_CONTROLPAN] = Icon(ICID_CONTROLPAN, IDI_CONTROLPAN, icon_size);
409 _icons[ICID_DESKSETTING]= Icon(ICID_DESKSETTING,IDI_DESKSETTING,icon_size);
410 _icons[ICID_NETCONNS] = Icon(ICID_NETCONNS, IDI_NETCONNS, icon_size);
411 _icons[ICID_ADMIN] = Icon(ICID_ADMIN, IDI_ADMIN, icon_size);
412 _icons[ICID_RECENT] = Icon(ICID_RECENT, IDI_RECENT, icon_size);
413 }
414
415
416 const Icon& IconCache::extract(LPCTSTR path, ICONCACHE_FLAGS flags)
417 {
418 // search for matching icon with unchanged flags in the cache
419 CacheKey mapkey(path, flags);
420 PathCacheMap::iterator found = _pathCache.find(mapkey);
421
422 if (found != _pathCache.end())
423 return _icons[found->second];
424
425 // search for matching icon with handle
426 CacheKey mapkey_hicon(path, flags|ICF_HICON);
427 if (flags != mapkey_hicon.second) {
428 found = _pathCache.find(mapkey_hicon);
429
430 if (found != _pathCache.end())
431 return _icons[found->second];
432 }
433
434 // search for matching icon in the system image list cache
435 CacheKey mapkey_syscache(path, flags|ICF_SYSCACHE);
436 if (flags != mapkey_syscache.second) {
437 found = _pathCache.find(mapkey_syscache);
438
439 if (found != _pathCache.end())
440 return _icons[found->second];
441 }
442
443 SHFILEINFO sfi;
444
445 int shgfi_flags = 0;
446
447 if (flags & ICF_OPEN)
448 shgfi_flags |= SHGFI_OPENICON;
449
450 if ((flags&(ICF_LARGE|ICF_MIDDLE|ICF_OVERLAYS|ICF_HICON)) && !(flags&ICF_SYSCACHE)) {
451 shgfi_flags |= SHGFI_ICON;
452
453 if (!(flags & (ICF_LARGE|ICF_MIDDLE)))
454 shgfi_flags |= SHGFI_SMALLICON;
455
456 if (flags & ICF_OVERLAYS)
457 shgfi_flags |= SHGFI_ADDOVERLAYS;
458
459 // get small/big icons with/without overlays
460 if (SHGetFileInfo(path, 0, &sfi, sizeof(sfi), shgfi_flags)) {
461 const Icon& icon = add(sfi.hIcon, IT_CACHED);
462
463 ///@todo limit cache size
464 _pathCache[mapkey_hicon] = icon;
465
466 return icon;
467 }
468 } else {
469 assert(!(flags&ICF_OVERLAYS));
470
471 shgfi_flags |= SHGFI_SYSICONINDEX|SHGFI_SMALLICON;
472
473 // use system image list - the "search program dialog" needs it
474 HIMAGELIST himlSys_small = (HIMAGELIST) SHGetFileInfo(path, 0, &sfi, sizeof(sfi), shgfi_flags);
475
476 if (himlSys_small) {
477 _himlSys_small = himlSys_small;
478
479 const Icon& icon = add(sfi.iIcon/*, IT_SYSCACHE*/);
480
481 ///@todo limit cache size
482 _pathCache[mapkey_syscache] = icon;
483
484 return icon;
485 }
486 }
487
488 return _icons[ICID_NONE];
489 }
490
491 const Icon& IconCache::extract(LPCTSTR path, int icon_idx, ICONCACHE_FLAGS flags)
492 {
493 IdxCacheKey key(path, make_pair(icon_idx, (flags|ICF_HICON)&~ICF_SYSCACHE));
494
495 key.first.toLower();
496
497 IdxCacheMap::iterator found = _idxCache.find(key);
498
499 if (found != _idxCache.end())
500 return _icons[found->second];
501
502 HICON hIcon;
503
504 if ((int)ExtractIconEx(path, icon_idx, NULL, &hIcon, 1) > 0) {
505 const Icon& icon = add(hIcon, IT_CACHED);
506
507 _idxCache[key] = icon;
508
509 return icon;
510 } else {
511
512 ///@todo retreive "http://.../favicon.ico" format icons
513
514 return _icons[ICID_NONE];
515 }
516 }
517
518 const Icon& IconCache::extract(IExtractIcon* pExtract, LPCTSTR path, int icon_idx, ICONCACHE_FLAGS flags)
519 {
520 HICON hIconLarge = 0;
521 HICON hIcon;
522
523 int icon_size = ICON_SIZE_FROM_ICF(flags);
524 HRESULT hr = pExtract->Extract(path, icon_idx, &hIconLarge, &hIcon, MAKELONG(GetSystemMetrics(SM_CXICON), icon_size));
525
526 if (hr == NOERROR) { //@@ oder SUCCEEDED(hr) ?
527 if (icon_size > ICON_SIZE_SMALL) { //@@ OK?
528 if (hIcon)
529 DestroyIcon(hIcon);
530
531 hIcon = hIconLarge;
532 } else {
533 if (hIconLarge)
534 DestroyIcon(hIconLarge);
535 }
536
537 if (hIcon)
538 return add(hIcon); //@@ When do we want not to free this icons?
539 }
540
541 return _icons[ICID_NONE];
542 }
543
544 const Icon& IconCache::extract(LPCITEMIDLIST pidl, ICONCACHE_FLAGS flags)
545 {
546 // search for matching icon with unchanged flags in the cache
547 PidlCacheKey mapkey(pidl, flags);
548 PidlCacheMap::iterator found = _pidlcache.find(mapkey);
549
550 if (found != _pidlcache.end())
551 return _icons[found->second];
552
553 // search for matching icon with handle
554 PidlCacheKey mapkey_hicon(pidl, flags|ICF_HICON);
555 if (flags != mapkey_hicon.second) {
556 found = _pidlcache.find(mapkey_hicon);
557
558 if (found != _pidlcache.end())
559 return _icons[found->second];
560 }
561
562 // search for matching icon in the system image list cache
563 PidlCacheKey mapkey_syscache(pidl, flags|ICF_SYSCACHE);
564 if (flags != mapkey_syscache.second) {
565 found = _pidlcache.find(mapkey_syscache);
566
567 if (found != _pidlcache.end())
568 return _icons[found->second];
569 }
570
571 SHFILEINFO sfi;
572
573 int shgfi_flags = SHGFI_PIDL;
574
575 if (!(flags & (ICF_LARGE|ICF_MIDDLE)))
576 shgfi_flags |= SHGFI_SMALLICON;
577
578 if (flags & ICF_OPEN)
579 shgfi_flags |= SHGFI_OPENICON;
580
581 if (flags & ICF_SYSCACHE) {
582 assert(!(flags&ICF_OVERLAYS));
583
584 HIMAGELIST himlSys = (HIMAGELIST) SHGetFileInfo((LPCTSTR)pidl, 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX|shgfi_flags);
585 if (himlSys) {
586 const Icon& icon = add(sfi.iIcon/*, IT_SYSCACHE*/);
587
588 ///@todo limit cache size
589 _pidlcache[mapkey_syscache] = icon;
590
591 return icon;
592 }
593 } else {
594 if (flags & ICF_OVERLAYS)
595 shgfi_flags |= SHGFI_ADDOVERLAYS;
596
597 if (SHGetFileInfo((LPCTSTR)pidl, 0, &sfi, sizeof(sfi), SHGFI_ICON|shgfi_flags)) {
598 const Icon& icon = add(sfi.hIcon, IT_CACHED);
599
600 ///@todo limit cache size
601 _pidlcache[mapkey_hicon] = icon;
602
603 return icon;
604 }
605 }
606
607 return _icons[ICID_NONE];
608 }
609
610
611 const Icon& IconCache::add(HICON hIcon, ICON_TYPE type)
612 {
613 int id = ++s_next_id;
614
615 return _icons[id] = Icon(type, id, hIcon);
616 }
617
618 const Icon& IconCache::add(int sys_idx/*, ICON_TYPE type=IT_SYSCACHE*/)
619 {
620 int id = ++s_next_id;
621
622 return _icons[id] = SysCacheIcon(id, sys_idx);
623 }
624
625 const Icon& IconCache::get_icon(int id)
626 {
627 return _icons[id];
628 }
629
630 IconCache::~IconCache()
631 {
632 /* We don't need to free cached resources - they are automatically freed at process termination
633 for (int index = s_next_id; index >= 0; index--) {
634 IconMap::iterator found = _icons.find(index);
635
636 if (found != _icons.end()) {
637 Icon& icon = found->second;
638
639 if ((icon.get_icontype() == IT_DYNAMIC) ||
640 (icon.get_icontype() == IT_CACHED))
641 {
642 DestroyIcon(icon.get_hicon());
643 _icons.erase(found);
644 }
645 }
646 }
647 */
648 }
649
650 void IconCache::free_icon(int icon_id)
651 {
652 IconMap::iterator found = _icons.find(icon_id);
653
654 if (found != _icons.end()) {
655 Icon& icon = found->second;
656
657 if (icon.destroy())
658 _icons.erase(found);
659 }
660 }
661
662
663 ResString::ResString(UINT nid)
664 {
665 TCHAR buffer[BUFFER_LEN];
666
667 int len = LoadString(g_Globals._hInstance, nid, buffer, sizeof(buffer)/sizeof(TCHAR));
668
669 super::assign(buffer, len);
670 }
671
672
673 ResIcon::ResIcon(UINT nid)
674 {
675 _hicon = LoadIcon(g_Globals._hInstance, MAKEINTRESOURCE(nid));
676 }
677
678 SmallIcon::SmallIcon(UINT nid)
679 {
680 _hicon = (HICON)LoadImage(g_Globals._hInstance, MAKEINTRESOURCE(nid), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
681 }
682
683 ResIconEx::ResIconEx(UINT nid, int w, int h)
684 {
685 _hicon = (HICON)LoadImage(g_Globals._hInstance, MAKEINTRESOURCE(nid), IMAGE_ICON, w, h, LR_SHARED);
686 }
687
688
689 void SetWindowIcon(HWND hwnd, UINT nid)
690 {
691 HICON hIcon = ResIcon(nid);
692 (void)Window_SetIcon(hwnd, ICON_BIG, hIcon);
693
694 HICON hIconSmall = SmallIcon(nid);
695 (void)Window_SetIcon(hwnd, ICON_SMALL, hIconSmall);
696 }
697
698
699 ResBitmap::ResBitmap(UINT nid)
700 {
701 _hBmp = LoadBitmap(g_Globals._hInstance, MAKEINTRESOURCE(nid));
702 }
703
704
705 #ifndef ROSSHELL
706
707 void explorer_show_frame(int cmdShow, LPTSTR lpCmdLine)
708 {
709 ExplorerCmd cmd;
710
711 if (g_Globals._hMainWnd) {
712 if (IsIconic(g_Globals._hMainWnd))
713 ShowWindow(g_Globals._hMainWnd, SW_RESTORE);
714 else
715 SetForegroundWindow(g_Globals._hMainWnd);
716
717 return;
718 }
719
720 g_Globals._prescan_nodes = false;
721
722 cmd._mdi = true;
723 cmd._cmdShow = cmdShow;
724
725 // parse command line options, which may overwrite the MDI flag
726 if (lpCmdLine)
727 cmd.ParseCmdLine(lpCmdLine);
728
729 // create main window
730 MainFrameBase::Create(cmd);
731 }
732
733 bool ExplorerCmd::ParseCmdLine(LPCTSTR lpCmdLine)
734 {
735 bool ok = true;
736
737 LPCTSTR b = lpCmdLine;
738 LPCTSTR p = b;
739
740 while(*b) {
741 // remove leading space
742 while(_istspace((unsigned)*b))
743 ++b;
744
745 p = b;
746
747 bool quote = false;
748
749 // options are separated by ','
750 for(; *p; ++p) {
751 if (*p == '"') // Quote characters may appear at any position in the command line.
752 quote = !quote;
753 else if (*p==',' && !quote)
754 break;
755 }
756
757 if (p > b) {
758 int l = p - b;
759
760 // remove trailing space
761 while(l>0 && _istspace((unsigned)b[l-1]))
762 --l;
763
764 if (!EvaluateOption(String(b, l)))
765 ok = false;
766
767 if (*p)
768 ++p;
769
770 b = p;
771 }
772 }
773
774 return ok;
775 }
776
777 bool ExplorerCmd::EvaluateOption(LPCTSTR option)
778 {
779 String opt_str;
780
781 // Remove quote characters, as they are evaluated at this point.
782 for(; *option; ++option)
783 if (*option != '"')
784 opt_str += *option;
785
786 option = opt_str;
787
788 if (option[0] == '/') {
789 ++option;
790
791 // option /e for windows in explorer mode
792 if (!_tcsicmp(option, TEXT("e")))
793 _flags |= OWM_EXPLORE;
794 // option /root for rooted explorer windows
795 else if (!_tcsicmp(option, TEXT("root")))
796 _flags |= OWM_ROOTED;
797 // non-standard options: /mdi, /sdi
798 else if (!_tcsicmp(option, TEXT("mdi")))
799 _mdi = true;
800 else if (!_tcsicmp(option, TEXT("sdi")))
801 _mdi = false;
802 else if (!_tcsicmp(option, TEXT("n")))
803 {
804 // Do nothing
805 }
806 else if (!_tcsicmp(option, TEXT("select")))
807 {
808 SelectOpt = TRUE;
809 }
810 else
811 return false;
812
813 } else {
814 if (!_path.empty())
815 return false;
816
817 if((SelectOpt == TRUE) && (PathFileExists(option)))
818 {
819 WCHAR szDir[MAX_PATH];
820
821 _wsplitpath(option, szPath, szDir, NULL, NULL);
822 wcscat(szPath, szDir);
823 PathRemoveBackslash(szPath);
824 _path = szPath;
825 SelectOpt = FALSE;
826 }
827 else
828 _path = opt_str;
829 }
830
831 return true;
832 }
833
834 bool ExplorerCmd::IsValidPath() const
835 {
836 if (!_path.empty()) {
837 DWORD attribs = GetFileAttributes(_path);
838
839 if (attribs!=INVALID_FILE_ATTRIBUTES && (attribs&FILE_ATTRIBUTE_DIRECTORY))
840 return true; // file system path
841 else if (*_path==':' && _path.at(1)==':')
842 return true; // text encoded IDL
843 }
844
845 return false;
846 }
847
848 #else
849
850 void explorer_show_frame(int cmdShow, LPTSTR lpCmdLine)
851 {
852 if (!lpCmdLine)
853 lpCmdLine = TEXT("explorer.exe");
854
855 launch_file(GetDesktopWindow(), lpCmdLine, cmdShow);
856 }
857
858 #endif
859
860
861 PopupMenu::PopupMenu(UINT nid)
862 {
863 HMENU hMenu = LoadMenu(g_Globals._hInstance, MAKEINTRESOURCE(nid));
864 _hmenu = GetSubMenu(hMenu, 0);
865 RemoveMenu(hMenu, 0, MF_BYPOSITION);
866 DestroyMenu(hMenu);
867 }
868
869
870 /// "About Explorer" Dialog
871 struct ExplorerAboutDlg : public
872 CtlColorParent<
873 OwnerDrawParent<Dialog>
874 >
875 {
876 typedef CtlColorParent<
877 OwnerDrawParent<Dialog>
878 > super;
879
880 ExplorerAboutDlg(HWND hwnd)
881 : super(hwnd)
882 {
883 SetWindowIcon(hwnd, IDI_REACTOS);
884
885 new FlatButton(hwnd, IDOK);
886
887 _hfont = CreateFont(20, 0, 0, 0, FW_BOLD, TRUE, 0, 0, 0, 0, 0, 0, 0, TEXT("Sans Serif"));
888 new ColorStatic(hwnd, IDC_ROS_EXPLORER, RGB(32,32,128), 0, _hfont);
889
890 new HyperlinkCtrl(hwnd, IDC_WWW);
891
892 FmtString ver_txt(ResString(IDS_EXPLORER_VERSION_STR), (LPCTSTR)ResString(IDS_VERSION_STR));
893 SetWindowText(GetDlgItem(hwnd, IDC_VERSION_TXT), ver_txt);
894
895 HWND hwnd_winver = GetDlgItem(hwnd, IDC_WIN_VERSION);
896 SetWindowText(hwnd_winver, get_windows_version_str());
897 SetWindowFont(hwnd_winver, GetStockFont(DEFAULT_GUI_FONT), FALSE);
898
899 CenterWindow(hwnd);
900 }
901
902 ~ExplorerAboutDlg()
903 {
904 DeleteObject(_hfont);
905 }
906
907 LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
908 {
909 switch(nmsg) {
910 case WM_PAINT:
911 Paint();
912 break;
913
914 default:
915 return super::WndProc(nmsg, wparam, lparam);
916 }
917
918 return 0;
919 }
920
921 void Paint()
922 {
923 PaintCanvas canvas(_hwnd);
924
925 HICON hicon = (HICON) LoadImage(g_Globals._hInstance, MAKEINTRESOURCE(IDI_REACTOS_BIG), IMAGE_ICON, 0, 0, LR_SHARED);
926
927 DrawIconEx(canvas, 20, 10, hicon, 0, 0, 0, 0, DI_NORMAL);
928 }
929
930 protected:
931 HFONT _hfont;
932 };
933
934 void explorer_about(HWND hwndParent)
935 {
936 Dialog::DoModal(IDD_ABOUT_EXPLORER, WINDOW_CREATOR(ExplorerAboutDlg), hwndParent);
937 }
938
939
940 static void InitInstance(HINSTANCE hInstance)
941 {
942 CONTEXT("InitInstance");
943
944 setlocale(LC_COLLATE, ""); // set collating rules to local settings for compareName
945
946 #ifndef ROSSHELL
947 // register frame window class
948 g_Globals._hframeClass = IconWindowClass(CLASSNAME_FRAME,IDI_EXPLORER);
949
950 // register child window class
951 WindowClass(CLASSNAME_CHILDWND, CS_CLASSDC|CS_DBLCLKS).Register();
952
953 // register tree window class
954 WindowClass(CLASSNAME_WINEFILETREE, CS_CLASSDC|CS_DBLCLKS).Register();
955 #endif
956
957 g_Globals._cfStrFName = RegisterClipboardFormat(CFSTR_FILENAME);
958 }
959
960
961 int explorer_main(HINSTANCE hInstance, LPTSTR lpCmdLine, int cmdShow)
962 {
963 CONTEXT("explorer_main");
964
965 // initialize Common Controls library
966 CommonControlInit usingCmnCtrl;
967
968 try {
969 InitInstance(hInstance);
970 } catch(COMException& e) {
971 HandleException(e, GetDesktopWindow());
972 return -1;
973 }
974
975 #ifndef ROSSHELL
976 if (cmdShow != SW_HIDE) {
977 /* // don't maximize if being called from the ROS desktop
978 if (cmdShow == SW_SHOWNORMAL)
979 ///@todo read window placement from registry
980 cmdShow = SW_MAXIMIZE;
981 */
982
983 explorer_show_frame(cmdShow, lpCmdLine);
984 }
985 #endif
986
987 Window::MessageLoop();
988
989 return 1;
990 }
991
992
993 static bool SetShellReadyEvent(LPCTSTR evtName)
994 {
995 HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, evtName);
996 if (!hEvent)
997 return false;
998
999 SetEvent(hEvent);
1000 CloseHandle(hEvent);
1001
1002 return true;
1003 }
1004
1005
1006 int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nShowCmd)
1007 {
1008 CONTEXT("WinMain()");
1009
1010 BOOL any_desktop_running = IsAnyDesktopRunning();
1011
1012 BOOL startup_desktop;
1013
1014 // strip extended options from the front of the command line
1015 String ext_options;
1016
1017 while(*lpCmdLine == '-') {
1018 while(*lpCmdLine && !_istspace((unsigned)*lpCmdLine))
1019 ext_options += *lpCmdLine++;
1020
1021 while(_istspace((unsigned)*lpCmdLine))
1022 ++lpCmdLine;
1023 }
1024
1025 // command line option "-install" to replace previous shell application with ROS Explorer
1026 if (_tcsstr(ext_options,TEXT("-install"))) {
1027 // install ROS Explorer into the registry
1028 TCHAR path[MAX_PATH];
1029
1030 int l = GetModuleFileName(0, path, COUNTOF(path));
1031 if (l) {
1032 HKEY hkey;
1033
1034 if (!RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"), &hkey)) {
1035
1036 ///@todo save previous shell application in config file
1037
1038 RegSetValueEx(hkey, TEXT("Shell"), 0, REG_SZ, (LPBYTE)path, l*sizeof(TCHAR));
1039 RegCloseKey(hkey);
1040 }
1041
1042 if (!RegOpenKey(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"), &hkey)) {
1043
1044 ///@todo save previous shell application in config file
1045
1046 RegSetValueEx(hkey, TEXT("Shell"), 0, REG_SZ, (LPBYTE)TEXT(""), l*sizeof(TCHAR));
1047 RegCloseKey(hkey);
1048 }
1049 }
1050
1051 HWND shellWindow = GetShellWindow();
1052
1053 if (shellWindow) {
1054 DWORD pid;
1055
1056 // terminate shell process for NT like systems
1057 GetWindowThreadProcessId(shellWindow, &pid);
1058 HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
1059
1060 // On Win 9x it's sufficient to destroy the shell window.
1061 DestroyWindow(shellWindow);
1062
1063 if (TerminateProcess(hProcess, 0))
1064 WaitForSingleObject(hProcess, INFINITE);
1065
1066 CloseHandle(hProcess);
1067 }
1068
1069 startup_desktop = TRUE;
1070 } else {
1071 // create desktop window and task bar only, if there is no other shell and we are
1072 // the first explorer instance
1073 // MS Explorer looks additionally into the registry entry HKCU\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\shell,
1074 // to decide wether it is currently configured as shell application.
1075 startup_desktop = !any_desktop_running;
1076 }
1077
1078
1079 bool autostart = !any_desktop_running;
1080
1081 // disable autostart if the SHIFT key is pressed
1082 if (GetAsyncKeyState(VK_SHIFT) < 0)
1083 autostart = false;
1084
1085 #ifdef _DEBUG //MF: disabled for debugging
1086 autostart = false;
1087 #endif
1088
1089 // If there is given the command line option "-desktop", create desktop window anyways
1090 if (_tcsstr(ext_options,TEXT("-desktop")))
1091 startup_desktop = TRUE;
1092 #ifndef ROSSHELL
1093 else if (_tcsstr(ext_options,TEXT("-nodesktop")))
1094 startup_desktop = FALSE;
1095
1096 // Don't display cabinet window in desktop mode
1097 if (startup_desktop && !_tcsstr(ext_options,TEXT("-explorer")))
1098 nShowCmd = SW_HIDE;
1099 #endif
1100
1101 if (_tcsstr(ext_options,TEXT("-noautostart")))
1102 autostart = false;
1103 else if (_tcsstr(ext_options,TEXT("-autostart")))
1104 autostart = true;
1105
1106 #ifndef __WINE__
1107 if (_tcsstr(ext_options,TEXT("-console"))) {
1108 AllocConsole();
1109
1110 _dup2(_open_osfhandle((long)GetStdHandle(STD_INPUT_HANDLE), _O_RDONLY), 0);
1111 _dup2(_open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), 0), 1);
1112 _dup2(_open_osfhandle((long)GetStdHandle(STD_ERROR_HANDLE), 0), 2);
1113
1114 g_Globals._log = _fdopen(1, "w");
1115 setvbuf(g_Globals._log, 0, _IONBF, 0);
1116
1117 LOG(TEXT("starting explorer debug log\n"));
1118 }
1119 #endif
1120
1121
1122 if (startup_desktop) {
1123 // hide the XP login screen (Credit to Nicolas Escuder)
1124 // another undocumented event: "Global\\msgina: ReturnToWelcome"
1125 if (!SetShellReadyEvent(TEXT("msgina: ShellReadyEvent")))
1126 SetShellReadyEvent(TEXT("Global\\msgina: ShellReadyEvent"));
1127 }
1128 #ifdef ROSSHELL
1129 else
1130 return 0; // no shell to launch, so exit immediatelly
1131 #endif
1132
1133
1134 if (!any_desktop_running) {
1135 // launch the shell DDE server
1136 if (g_SHDOCVW_ShellDDEInit)
1137 (*g_SHDOCVW_ShellDDEInit)(TRUE);
1138 }
1139
1140
1141 bool use_gdb_stub = false; // !IsDebuggerPresent();
1142
1143 if (_tcsstr(ext_options,TEXT("-debug")))
1144 use_gdb_stub = true;
1145
1146 if (_tcsstr(ext_options,TEXT("-break"))) {
1147 LOG(TEXT("debugger breakpoint"));
1148 __debugbreak();
1149 }
1150
1151 #ifdef _M_IX86
1152 // activate GDB remote debugging stub if no other debugger is running
1153 if (use_gdb_stub) {
1154 LOG(TEXT("waiting for debugger connection...\n"));
1155
1156 initialize_gdb_stub();
1157 }
1158 #endif
1159
1160 g_Globals.init(hInstance);
1161
1162 // initialize COM and OLE before creating the desktop window
1163 OleInit usingCOM;
1164
1165 // init common controls library
1166 CommonControlInit usingCmnCtrl;
1167
1168 g_Globals.read_persistent();
1169
1170 if (startup_desktop) {
1171 WaitCursor wait;
1172
1173 g_Globals._desktops.init();
1174
1175 g_Globals._hwndDesktop = DesktopWindow::Create();
1176 #ifdef _USE_HDESK
1177 g_Globals._desktops.get_current_Desktop()->_hwndDesktop = g_Globals._hwndDesktop;
1178 #endif
1179 }
1180
1181 if (_tcsstr(ext_options,TEXT("-?"))) {
1182 MessageBoxA(g_Globals._hwndDesktop,
1183 "/e open cabinet window in explorer mode\r\n"
1184 "/root open cabinet window in rooted mode\r\n"
1185 "/mdi open cabinet window in MDI mode\r\n"
1186 "/sdi open cabinet window in SDI mode\r\n"
1187 "\r\n"
1188 "-? display command line options\r\n"
1189 "\r\n"
1190 "-desktop start in desktop mode regardless of an already running shell\r\n"
1191 "-nodesktop disable desktop mode\r\n"
1192 "-explorer display cabinet window regardless of enabled desktop mode\r\n"
1193 "\r\n"
1194 "-install replace previous shell application with ROS Explorer\r\n"
1195 "\r\n"
1196 "-noautostart disable autostarts\r\n"
1197 "-autostart enable autostarts regardless of debug build\r\n"
1198 "\r\n"
1199 "-console open debug console\r\n"
1200 "\r\n"
1201 "-debug activate GDB remote debugging stub\r\n"
1202 "-break activate debugger breakpoint\r\n",
1203 "ROS Explorer - command line options", MB_OK);
1204 }
1205
1206 Thread* pSSOThread = NULL;
1207
1208 if (startup_desktop) {
1209 // launch SSO thread to allow message processing independent from the explorer main thread
1210 pSSOThread = new SSOThread;
1211 pSSOThread->Start();
1212 }
1213
1214 /**TODO launching autostart programs can be moved into a background thread. */
1215 if (autostart) {
1216 const char* argv[] = {"", "s"}; // call startup routine in SESSION_START mode
1217 startup(2, argv);
1218 }
1219
1220 #ifndef ROSSHELL
1221 if (g_Globals._hwndDesktop)
1222 g_Globals._desktop_mode = true;
1223 #endif
1224
1225
1226 int ret = explorer_main(hInstance, lpCmdLine, nShowCmd);
1227
1228
1229 // write configuration file
1230 g_Globals.write_persistent();
1231
1232 if (pSSOThread) {
1233 pSSOThread->Stop();
1234 delete pSSOThread;
1235 }
1236
1237 if (!any_desktop_running) {
1238 // shutdown the shell DDE server
1239 if (g_SHDOCVW_ShellDDEInit)
1240 (*g_SHDOCVW_ShellDDEInit)(FALSE);
1241 }
1242
1243 return ret;
1244 }