projects / reactos.git / blob
? search:


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