Make start menu icons small until we have 24x24 icons.
[reactos.git] / reactos / subsys / system / explorer / taskbar / startmenu.cpp
1 /*
2 * Copyright 2003, 2004 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 // startmenu.cpp
24 //
25 // Explorer start menu
26 //
27 // Martin Fuchs, 19.08.2003
28 //
29 // Credits: Thanks to Everaldo (http://www.everaldo.com) for his nice looking icons.
30 //
31
32
33 #include <precomp.h>
34
35 #include "../resource.h"
36
37 #include "desktopbar.h"
38 #include "startmenu.h"
39
40 #include "../dialogs/searchprogram.h"
41 #include "../dialogs/settings.h"
42
43
44 #define SHELLPATH_CONTROL_PANEL TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}")
45 #define SHELLPATH_PRINTERS TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}")
46 #define SHELLPATH_NET_CONNECTIONS TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{7007ACC7-3202-11D1-AAD2-00805FC1270E}")
47
48
49 StartMenu::StartMenu(HWND hwnd, bool big_icons)
50 : super(hwnd),
51 _big_icons(big_icons)
52 {
53 _next_id = IDC_FIRST_MENU;
54 _submenu_id = 0;
55
56 _border_left = 0;
57 _border_top = 0;
58 _bottom_max = INT_MAX;
59
60 _floating_btn = false;
61 _arrow_btns = false;
62 _scroll_mode = SCROLL_NOT;
63 _scroll_pos = 0;
64 _invisible_lines = 0;
65
66 _last_pos = WindowRect(hwnd).pos();
67 #ifdef _LIGHT_STARTMENU
68 _selected_id = -1;
69 _last_mouse_pos = 0;
70 #endif
71 }
72
73 StartMenu::StartMenu(HWND hwnd, const StartMenuCreateInfo& create_info, bool big_icons)
74 : super(hwnd),
75 _create_info(create_info),
76 _big_icons(big_icons)
77 {
78 for(StartMenuFolders::const_iterator it=create_info._folders.begin(); it!=create_info._folders.end(); ++it)
79 if (*it)
80 _dirs.push_back(ShellDirectory(GetDesktopFolder(), *it, _hwnd));
81
82 _next_id = IDC_FIRST_MENU;
83 _submenu_id = 0;
84
85 _border_left = 0;
86 _border_top = create_info._border_top;
87 _bottom_max = INT_MAX;
88
89 _floating_btn = create_info._border_top? true: false;
90 _arrow_btns = false;
91 _scroll_mode = SCROLL_NOT;
92 _scroll_pos = 0;
93 _invisible_lines = 0;
94
95 _last_pos = WindowRect(hwnd).pos();
96 #ifdef _LIGHT_STARTMENU
97 _selected_id = -1;
98 _last_mouse_pos = 0;
99 #endif
100 }
101
102 StartMenu::~StartMenu()
103 {
104 SendParent(PM_STARTMENU_CLOSED);
105 }
106
107
108 // We need this wrapper function for s_wcStartMenu, it calls the WIN32 API,
109 // though static C++ initializers are not allowed for Winelib applications.
110 BtnWindowClass& StartMenu::GetWndClasss()
111 {
112 static BtnWindowClass s_wcStartMenu(CLASSNAME_STARTMENU);
113
114 return s_wcStartMenu;
115 }
116
117
118 Window::CREATORFUNC_INFO StartMenu::s_def_creator = STARTMENU_CREATOR(StartMenu);
119
120 HWND StartMenu::Create(int x, int y, const StartMenuFolders& folders, HWND hwndParent, LPCTSTR title, bool parent_big_icons,
121 CREATORFUNC_INFO creator, void* info, const String& filter)
122 {
123 UINT style, ex_style;
124 int top_height;
125
126 if (hwndParent) {
127 style = WS_POPUP|WS_THICKFRAME|WS_CLIPCHILDREN|WS_VISIBLE;
128 ex_style = 0;
129 top_height = STARTMENU_TOP_BTN_SPACE;
130 } else {
131 style = WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_CLIPCHILDREN|WS_VISIBLE;
132 ex_style = WS_EX_TOOLWINDOW;
133 top_height = 0;
134 }
135
136 bool big_icons = false;
137 RECT rect = {x, y-STARTMENU_LINE_HEIGHT-top_height, x+STARTMENU_WIDTH_MIN, y};
138
139 #ifndef _LIGHT_STARTMENU
140 rect.top += STARTMENU_LINE_HEIGHT;
141 #endif
142
143 AdjustWindowRectEx(&rect, style, FALSE, ex_style);
144
145 StartMenuCreateInfo create_info;
146
147 create_info._folders = folders;
148 create_info._border_top = top_height;
149 create_info._creator = creator;
150 create_info._info = info;
151 create_info._filter = filter;
152
153 if (title)
154 create_info._title = title;
155
156 HWND hwnd = Window::Create(creator, &create_info, ex_style, GetWndClasss(), title,
157 style, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, hwndParent);
158
159 // make sure the window is not off the screen
160 MoveVisible(hwnd);
161
162 return hwnd;
163 }
164
165
166 LRESULT StartMenu::Init(LPCREATESTRUCT pcs)
167 {
168 try {
169 AddEntries();
170
171 if (super::Init(pcs))
172 return 1;
173
174 // create buttons for registered entries in _entries
175 for(ShellEntryMap::const_iterator it=_entries.begin(); it!=_entries.end(); ++it) {
176 const StartMenuEntry& sme = it->second;
177 bool hasSubmenu = false;
178
179 for(ShellEntrySet::const_iterator it=sme._entries.begin(); it!=sme._entries.end(); ++it)
180 if ((*it)->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
181 hasSubmenu = true;
182
183 #ifdef _LIGHT_STARTMENU
184 _buttons.push_back(SMBtnInfo(sme, it->first, hasSubmenu));
185 #else
186 AddButton(sme._title, sme._hIcon, hasSubmenu, it->first);
187 #endif
188 }
189
190 #ifdef _LIGHT_STARTMENU
191 if (_buttons.empty())
192 #else
193 if (!GetWindow(_hwnd, GW_CHILD))
194 #endif
195 AddButton(ResString(IDS_EMPTY), ICID_NONE, false, 0, false);
196
197 #ifdef _LIGHT_STARTMENU
198 ResizeToButtons();
199 #endif
200
201 #ifdef _LAZY_ICONEXTRACT
202 PostMessage(_hwnd, PM_UPDATE_ICONS, 0, 0);
203 #endif
204 } catch(COMException& e) {
205 HandleException(e, pcs->hwndParent); // destroys the start menu window while switching focus
206 }
207
208 return 0;
209 }
210
211 void StartMenu::AddEntries()
212 {
213 for(StartMenuShellDirs::iterator it=_dirs.begin(); it!=_dirs.end(); ++it) {
214 StartMenuDirectory& smd = *it;
215 ShellDirectory& dir = smd._dir;
216
217 if (!dir._scanned) {
218 WaitCursor wait;
219
220 #ifdef _LAZY_ICONEXTRACT
221 dir.smart_scan(SORT_NAME, SCAN_FILESYSTEM); // lazy icon extraction, try to read directly from filesystem
222 #else
223 dir.smart_scan(SORT_NAME, SCAN_EXTRACT_ICONS|SCAN_FILESYSTEM);
224 #endif
225 }
226
227 AddShellEntries(dir, -1, smd._ignore);
228 }
229 }
230
231
232 static LPTSTR trim_path_slash(LPTSTR path)
233 {
234 LPTSTR p = path;
235
236 while(*p)
237 ++p;
238
239 if (p>path && (p[-1]=='\\' || p[-1]=='/'))
240 *--p = '\0';
241
242 return path;
243 }
244
245 void StartMenu::AddShellEntries(const ShellDirectory& dir, int max, const String& ignore)
246 {
247 TCHAR ignore_path[MAX_PATH], ignore_dir[MAX_PATH], ignore_name[_MAX_FNAME], ignore_ext[_MAX_EXT];
248 TCHAR dir_path[MAX_PATH];
249
250 if (!ignore.empty()) {
251 _tsplitpath_s(ignore, ignore_path, COUNTOF(ignore_path), ignore_dir, COUNTOF(ignore_dir), ignore_name, COUNTOF(ignore_name), ignore_ext, COUNTOF(ignore_ext));
252
253 _tcscat(ignore_path, ignore_dir);
254 _tcscat(ignore_name, ignore_ext);
255
256 dir.get_path(dir_path, COUNTOF(dir_path));
257
258 if (_tcsicmp(trim_path_slash(dir_path), trim_path_slash(ignore_path)))
259 *ignore_name = '\0';
260 } else
261 *ignore_name = '\0';
262
263 String lwr_filter = _create_info._filter;
264 lwr_filter.toLower();
265
266 int cnt = 0;
267 for(Entry*entry=dir._down; entry; entry=entry->_next) {
268 // hide files like "desktop.ini"
269 if (entry->_shell_attribs & SFGAO_HIDDEN)
270 //not appropriate for drive roots: if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
271 continue;
272
273 // hide "Programs" subfolders if requested
274 if (*ignore_name && !_tcsicmp(entry->_data.cFileName, ignore_name))
275 continue;
276
277 // only 'max' entries shall be added.
278 if (++cnt == max)
279 break;
280
281 // filter only non-directory entries
282 if (!(entry->_data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) && !lwr_filter.empty()) {
283 String lwr_name = entry->_data.cFileName;
284 String lwr_disp = entry->_display_name;
285
286 lwr_name.toLower();
287 lwr_disp.toLower();
288
289 if (!_tcsstr(lwr_name,lwr_filter) && !_tcsstr(lwr_disp,lwr_filter))
290 continue;
291 }
292
293 if (entry->_etype == ET_SHELL)
294 AddEntry(dir._folder, static_cast<ShellEntry*>(entry));
295 else
296 AddEntry(dir._folder, entry);
297 }
298 }
299
300
301 LRESULT StartMenu::WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
302 {
303 switch(nmsg) {
304 case WM_PAINT: {
305 PaintCanvas canvas(_hwnd);
306 Paint(canvas);
307 break;}
308
309 case WM_SIZE:
310 ResizeButtons(LOWORD(lparam)-_border_left);
311 break;
312
313 case WM_MOVE: {
314 const POINTS& pos = MAKEPOINTS(lparam);
315
316 // move open submenus of floating menus
317 if (_submenu) {
318 int dx = pos.x - _last_pos.x;
319 int dy = pos.y - _last_pos.y;
320
321 if (dx || dy) {
322 WindowRect rt(_submenu);
323 SetWindowPos(_submenu, 0, rt.left+dx, rt.top+dy, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE);
324 //MoveVisible(_submenu);
325 }
326 }
327
328 _last_pos.x = pos.x;
329 _last_pos.y = pos.y;
330 goto def;}
331
332 case WM_NCHITTEST: {
333 LRESULT res = super::WndProc(nmsg, wparam, lparam);
334
335 if (res>=HTSIZEFIRST && res<=HTSIZELAST)
336 return HTCLIENT; // disable window resizing
337
338 return res;}
339
340 case WM_LBUTTONDOWN: {
341 RECT rect;
342
343 // check mouse cursor for coordinates of floating button
344 GetFloatingButtonRect(&rect);
345
346 if (PtInRect(&rect, Point(lparam))) {
347 // create a floating copy of the current start menu
348 WindowRect pos(_hwnd);
349
350 ///@todo do something similar to StartMenuRoot::TrackStartmenu() in order to automatically close submenus when clicking on the desktop background
351 StartMenu::Create(pos.left+3, pos.bottom-3, _create_info._folders, 0, _create_info._title, _big_icons, _create_info._creator, _create_info._info);
352 CloseStartMenu();
353 }
354
355 #ifdef _LIGHT_STARTMENU
356 int id = ButtonHitTest(Point(lparam));
357
358 if (id)
359 Command(id, BN_CLICKED);
360 #endif
361 break;}
362
363 case WM_SYSCOMMAND:
364 if ((wparam&0xFFF0) == SC_SIZE)
365 return 0; // disable window resizing
366 goto def;
367
368 case WM_ACTIVATEAPP:
369 // close start menu when activating another application
370 if (!wparam)
371 CloseStartMenu();
372 break; // don't call super::WndProc in case "this" has been deleted
373
374 case WM_CANCELMODE:
375 CloseStartMenu();
376
377 #ifdef _LIGHT_STARTMENU
378 if (_scroll_mode != SCROLL_NOT) {
379 ReleaseCapture();
380 KillTimer(_hwnd, 0);
381 }
382 #endif
383 break;
384
385 #ifdef _LIGHT_STARTMENU
386 case WM_MOUSEMOVE: {
387 // automatically set the focus to startmenu entries when moving the mouse over them
388 if (lparam != _last_mouse_pos) { // don't process WM_MOUSEMOVE when opening submenus using keyboard navigation
389 Point pt(lparam);
390
391 if (_arrow_btns) {
392 RECT rect_up, rect_down;
393
394 GetArrowButtonRects(&rect_up, &rect_down, _big_icons);
395
396 SCROLL_MODE scroll_mode = SCROLL_NOT;
397
398 if (PtInRect(&rect_up, pt))
399 scroll_mode = SCROLL_UP;
400 else if (PtInRect(&rect_down, pt))
401 scroll_mode = SCROLL_DOWN;
402
403 if (scroll_mode != _scroll_mode) {
404 if (scroll_mode == SCROLL_NOT) {
405 ReleaseCapture();
406 KillTimer(_hwnd, 0);
407 } else {
408 CloseSubmenus();
409 SetTimer(_hwnd, 0, 150, NULL); // 150 ms scroll interval
410 SetCapture(_hwnd);
411 }
412
413 _scroll_mode = scroll_mode;
414 }
415 }
416
417 int new_id = ButtonHitTest(pt);
418
419 if (new_id > 0 && new_id != _selected_id)
420 SelectButton(new_id);
421
422 _last_mouse_pos = lparam;
423 }
424 break;}
425
426 case WM_TIMER:
427 if (_scroll_mode == SCROLL_UP) {
428 if (_scroll_pos > 0) {
429 --_scroll_pos;
430 InvalidateRect(_hwnd, NULL, TRUE);
431 }
432 } else {
433 if (_scroll_pos <= _invisible_lines) {
434 ++_scroll_pos;
435 InvalidateRect(_hwnd, NULL, TRUE);
436 }
437 }
438 break;
439
440 case WM_KEYDOWN:
441 ProcessKey(wparam);
442 break;
443 #else
444 case PM_STARTENTRY_FOCUSED: { ///@todo use TrackMouseEvent() and WM_MOUSEHOVER to wait a bit before opening submenus
445 BOOL hasSubmenu = wparam;
446 HWND hctrl = (HWND)lparam;
447
448 // automatically open submenus
449 if (hasSubmenu) {
450 UpdateWindow(_hwnd); // draw focused button before waiting on submenu creation
451 //SendMessage(_hwnd, WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hctrl),BN_CLICKED), (LPARAM)hctrl);
452 Command(GetDlgCtrlID(hctrl), BN_CLICKED);
453 } else {
454 // close any open submenu
455 CloseOtherSubmenus();
456 }
457 break;}
458 #endif
459
460 #ifdef _LAZY_ICONEXTRACT
461 case PM_UPDATE_ICONS:
462 UpdateIcons(/*wparam*/);
463 break;
464 #endif
465
466 case PM_STARTENTRY_LAUNCHED:
467 if (GetWindowStyle(_hwnd) & WS_CAPTION) // don't automatically close floating menus
468 return 0;
469
470 // route message to the parent menu and close menus after launching an entry
471 if (!SendParent(nmsg, wparam, lparam))
472 CloseStartMenu();
473 return 1; // signal that we have received and processed the message
474
475 case PM_STARTMENU_CLOSED:
476 _submenu = 0;
477 break;
478
479 case PM_SELECT_ENTRY:
480 SelectButtonIndex(0, wparam!=0);
481 break;
482
483 #ifdef _LIGHT_STARTMENU
484 case WM_CONTEXTMENU: {
485 Point screen_pt(lparam), clnt_pt=screen_pt;
486 ScreenToClient(_hwnd, &clnt_pt);
487
488 int id = ButtonHitTest(clnt_pt);
489
490 if (id) {
491 StartMenuEntry& sme = _entries[id];
492
493 for(ShellEntrySet::iterator it=sme._entries.begin(); it!=sme._entries.end(); ++it) {
494 Entry* entry = *it;
495
496 if (entry) {
497 CHECKERROR(entry->do_context_menu(_hwnd, screen_pt, _cm_ifs)); // may close start menu because of focus loss
498 break; ///@todo handle context menu for more than one entry
499 }
500 }
501 }
502 break;}
503 #endif
504
505 default: def:
506 return super::WndProc(nmsg, wparam, lparam);
507 }
508
509 return 0;
510 }
511
512
513 #ifdef _LIGHT_STARTMENU
514
515 int StartMenu::ButtonHitTest(POINT pt)
516 {
517 ClientRect clnt(_hwnd);
518 const bool big_icons = _big_icons;
519 RECT rect = {_border_left, _border_top, clnt.right, STARTMENU_LINE_HEIGHT};
520
521 if (pt.x<rect.left || pt.x>rect.right)
522 return 0;
523
524 for(SMBtnVector::const_iterator it=_buttons.begin()+_scroll_pos; it!=_buttons.end(); ++it) {
525 const SMBtnInfo& info = *it;
526
527 if (rect.top > pt.y)
528 break;
529
530 rect.bottom = rect.top + (info._id==-1? STARTMENU_SEP_HEIGHT: STARTMENU_LINE_HEIGHT);
531
532 if (rect.bottom > _bottom_max)
533 break;
534
535 if (pt.y < rect.bottom) // PtInRect(&rect, pt)
536 return info._id;
537
538 rect.top = rect.bottom;
539 }
540
541 return 0;
542 }
543
544 void StartMenu::InvalidateSelection()
545 {
546 if (_selected_id <= 0)
547 return;
548
549 ClientRect clnt(_hwnd);
550 const bool big_icons = _big_icons;
551 RECT rect = {_border_left, _border_top, clnt.right, STARTMENU_LINE_HEIGHT};
552
553 for(SMBtnVector::const_iterator it=_buttons.begin()+_scroll_pos; it!=_buttons.end(); ++it) {
554 const SMBtnInfo& info = *it;
555
556 rect.bottom = rect.top + (info._id==-1? STARTMENU_SEP_HEIGHT: STARTMENU_LINE_HEIGHT);
557
558 if (info._id == _selected_id) {
559 InvalidateRect(_hwnd, &rect, TRUE);
560 break;
561 }
562
563 rect.top = rect.bottom;
564 }
565 }
566
567 const SMBtnInfo* StartMenu::GetButtonInfo(int id) const
568 {
569 for(SMBtnVector::const_iterator it=_buttons.begin(); it!=_buttons.end(); ++it)
570 if (it->_id == id)
571 return &*it;
572
573 return NULL;
574 }
575
576 bool StartMenu::SelectButton(int id, bool open_sub)
577 {
578 if (id == -1)
579 return false;
580
581 if (id == _selected_id)
582 return true;
583
584 InvalidateSelection();
585
586 const SMBtnInfo* btn = GetButtonInfo(id);
587
588 if (btn && btn->_enabled) {
589 _selected_id = id;
590
591 InvalidateSelection();
592
593 // automatically open submenus
594 if (btn->_hasSubmenu) {
595 if (open_sub)
596 OpenSubmenu();
597 } else
598 CloseOtherSubmenus(); // close any open submenu
599
600 return true;
601 } else {
602 _selected_id = -1;
603 return false;
604 }
605 }
606
607 bool StartMenu::OpenSubmenu(bool select_first)
608 {
609 if (_selected_id == -1)
610 return false;
611
612 InvalidateSelection();
613
614 const SMBtnInfo* btn = GetButtonInfo(_selected_id);
615
616 // automatically open submenus
617 if (btn->_hasSubmenu) {
618 //@@ allows destroying of startmenu when processing PM_UPDATE_ICONS -> GPF
619 UpdateWindow(_hwnd); // draw focused button before waiting on submenu creation
620 Command(_selected_id, BN_CLICKED);
621
622 if (select_first && _submenu)
623 SendMessage(_submenu, PM_SELECT_ENTRY, (WPARAM)false, 0);
624
625 return true;
626 } else
627 return false;
628 }
629
630
631 int StartMenu::GetSelectionIndex()
632 {
633 if (_selected_id == -1)
634 return -1;
635
636 for(int i=0; i<(int)_buttons.size(); ++i)
637 if (_buttons[i]._id == _selected_id)
638 return i;
639
640 return -1;
641 }
642
643 bool StartMenu::SelectButtonIndex(int idx, bool open_sub)
644 {
645 if (idx>=0 && idx<(int)_buttons.size())
646 return SelectButton(_buttons[idx]._id, open_sub);
647 else
648 return false;
649 }
650
651 void StartMenu::ProcessKey(int vk)
652 {
653 switch(vk) {
654 case VK_RETURN:
655 if (_selected_id)
656 Command(_selected_id, BN_CLICKED);
657 break;
658
659 case VK_UP:
660 Navigate(-1);
661 break;
662
663 case VK_DOWN:
664 Navigate(+1);
665 break;
666
667 case VK_HOME:
668 SelectButtonIndex(0, false);
669 break;
670
671 case VK_END:
672 SelectButtonIndex(_buttons.size()-1, false);
673 break;
674
675 case VK_LEFT:
676 if (_submenu)
677 CloseOtherSubmenus();
678 else if (!(GetWindowStyle(_hwnd) & WS_CAPTION)) // don't automatically close floating menus
679 DestroyWindow(_hwnd);
680 break;
681
682 case VK_RIGHT:
683 OpenSubmenu(true);
684 break;
685
686 case VK_ESCAPE:
687 CloseStartMenu();
688 break;
689
690 default:
691 if (vk>='0' && vk<='Z')
692 JumpToNextShortcut(vk);
693 }
694 }
695
696 bool StartMenu::Navigate(int step)
697 {
698 int idx = GetSelectionIndex();
699
700 if (idx == -1)
701 if (step > 0)
702 idx = 0 - step;
703 else
704 idx = _buttons.size() - step;
705
706 for(;;) {
707 idx += step;
708
709 if (idx<0 || idx>(int)_buttons.size())
710 break;
711
712 if (SelectButtonIndex(idx, false))
713 return true;
714 }
715
716 return false;
717 }
718
719 bool StartMenu::JumpToNextShortcut(char c)
720 {
721 int cur_idx = GetSelectionIndex();
722
723 if (cur_idx == -1)
724 cur_idx = 0;
725
726 int first_found = 0;
727 int found_more = 0;
728
729 SMBtnVector::const_iterator cur_it = _buttons.begin();
730 cur_it += cur_idx + 1;
731
732 // first search down from current item...
733 SMBtnVector::const_iterator it = cur_it;
734 for(; it!=_buttons.end(); ++it) {
735 const SMBtnInfo& btn = *it;
736
737 if (!btn._title.empty() && toupper((TBYTE)btn._title.at(0)) == c) {
738 if (!first_found)
739 first_found = btn._id;
740 else
741 ++found_more;
742 }
743 }
744
745 // ...now search from top to the current item
746 it = _buttons.begin();
747 for(; it!=_buttons.end() && it!=cur_it; ++it) {
748 const SMBtnInfo& btn = *it;
749
750 if (!btn._title.empty() && toupper((TBYTE)btn._title.at(0)) == c) {
751 if (!first_found)
752 first_found = btn._id;
753 else
754 ++found_more;
755 }
756 }
757
758 if (first_found) {
759 SelectButton(first_found);
760
761 if (!found_more)
762 Command(first_found, BN_CLICKED);
763
764 return true;
765 } else
766 return false;
767 }
768
769 #endif // _LIGHT_STARTMENU
770
771
772 bool StartMenu::GetButtonRect(int id, PRECT prect) const
773 {
774 #ifdef _LIGHT_STARTMENU
775 ClientRect clnt(_hwnd);
776 const bool big_icons = _big_icons;
777 RECT rect = {_border_left, _border_top, clnt.right, STARTMENU_LINE_HEIGHT};
778
779 for(SMBtnVector::const_iterator it=_buttons.begin()+_scroll_pos; it!=_buttons.end(); ++it) {
780 const SMBtnInfo& info = *it;
781
782 rect.bottom = rect.top + (info._id==-1? STARTMENU_SEP_HEIGHT: STARTMENU_LINE_HEIGHT);
783
784 if (info._id == id) {
785 *prect = rect;
786 return true;
787 }
788
789 rect.top = rect.bottom;
790 }
791
792 return false;
793 #else
794 HWND btn = GetDlgItem(_hwnd, id);
795
796 if (btn) {
797 GetWindowRect(btn, prect);
798 ScreenToClient(_hwnd, prect);
799
800 return true;
801 } else
802 return false;
803 #endif
804 }
805
806
807 void StartMenu::DrawFloatingButton(HDC hdc)
808 {
809 static ResIconEx floatingIcon(IDI_FLOATING, 8, 4);
810
811 ClientRect clnt(_hwnd);
812
813 DrawIconEx(hdc, clnt.right-12, 0, floatingIcon, 8, 4, 0, 0, DI_NORMAL);
814 }
815
816 void StartMenu::GetFloatingButtonRect(LPRECT prect)
817 {
818 GetClientRect(_hwnd, prect);
819
820 prect->right -= 4;
821 prect->left = prect->right - 8;
822 prect->bottom = 4;
823 }
824
825
826 void StartMenu::DrawArrows(HDC hdc, bool big_icons)
827 {
828 int cx = big_icons? 16: 8;
829 int cy = big_icons? 8: 4;
830
831 ResIconEx arrowUpIcon(IDI_ARROW_UP, cx, cy);
832 ResIconEx arrowDownIcon(IDI_ARROW_DOWN, cx, cy);
833
834 ClientRect clnt(_hwnd);
835
836 DrawIconEx(hdc, clnt.right/2-cx/2, _floating_btn?3:1, arrowUpIcon, cx, cy, 0, 0, DI_NORMAL);
837 DrawIconEx(hdc, clnt.right/2-cx/2, clnt.bottom-cy-1, arrowDownIcon, cx, cy, 0, 0, DI_NORMAL);
838 }
839
840 void StartMenu::GetArrowButtonRects(LPRECT prect_up, LPRECT prect_down, bool big_icons)
841 {
842 int cx = big_icons? 16: 8;
843 int cy = big_icons? 8: 4;
844
845 GetClientRect(_hwnd, prect_up);
846 *prect_down = *prect_up;
847
848 // prect_up->left = prect_up->right/2 - cx/2;
849 // prect_up->right = prect_up->left + cy;
850 prect_up->right -= cx;
851 prect_up->top = _floating_btn? cy-1: 1;
852 prect_up->bottom = prect_up->top + cy;
853
854 // prect_down->left = prect_down->right/2 - cx/2;
855 // prect_down->right = prect_down->left + cy;
856 prect_down->right -= cx;
857 prect_down->top = prect_down->bottom - cy - 1;
858 }
859
860
861 void StartMenu::Paint(PaintCanvas& canvas)
862 {
863 if (_floating_btn)
864 DrawFloatingButton(canvas);
865
866 #ifdef _LIGHT_STARTMENU
867 if (_arrow_btns)
868 DrawArrows(canvas, _big_icons);
869
870 ClientRect clnt(_hwnd);
871 const bool big_icons = _big_icons;
872 RECT rect = {_border_left, _border_top, clnt.right, STARTMENU_LINE_HEIGHT};
873
874 int sep_width = rect.right-rect.left - 4;
875
876 FontSelection font(canvas, GetStockFont(DEFAULT_GUI_FONT));
877 BkMode bk_mode(canvas, TRANSPARENT);
878
879 for(SMBtnVector::const_iterator it=_buttons.begin()+_scroll_pos; it!=_buttons.end(); ++it) {
880 const SMBtnInfo& btn = *it;
881
882 if (rect.top > canvas.rcPaint.bottom)
883 break;
884
885 if (btn._id == -1) { // a separator?
886 rect.bottom = rect.top + STARTMENU_SEP_HEIGHT;
887
888 if (rect.bottom > _bottom_max)
889 break;
890
891 BrushSelection brush_sel(canvas, GetSysColorBrush(COLOR_BTNSHADOW));
892 PatBlt(canvas, rect.left+2, rect.top+STARTMENU_SEP_HEIGHT/2-1, sep_width, 1, PATCOPY);
893
894 SelectBrush(canvas, GetSysColorBrush(COLOR_BTNHIGHLIGHT));
895 PatBlt(canvas, rect.left+2, rect.top+STARTMENU_SEP_HEIGHT/2, sep_width, 1, PATCOPY);
896 } else {
897 rect.bottom = rect.top + STARTMENU_LINE_HEIGHT;
898
899 if (rect.bottom > _bottom_max)
900 break;
901
902 if (rect.top >= canvas.rcPaint.top)
903 DrawStartMenuButton(canvas, rect, btn._title, btn, btn._id==_selected_id, false, _big_icons);
904 }
905
906 rect.top = rect.bottom;
907 }
908 #endif
909 }
910
911 #ifdef _LAZY_ICONEXTRACT
912 void StartMenu::UpdateIcons(/*int idx*/)
913 {
914 UpdateWindow(_hwnd);
915
916 #ifdef _SINGLE_ICONEXTRACT
917
918 //if (idx >= 0)
919 int idx = _scroll_pos;
920
921 for(; idx<(int)_buttons.size(); ++idx) {
922 SMBtnInfo& btn = _buttons[idx];
923
924 if (btn._icon_id==ICID_UNKNOWN && btn._id>0) {
925 StartMenuEntry& sme = _entries[btn._id];
926
927 btn._icon_id = ICID_NONE;
928
929 for(ShellEntrySet::iterator it=sme._entries.begin(); it!=sme._entries.end(); ++it) {
930 Entry* entry = *it;
931
932 if (entry->_icon_id == ICID_UNKNOWN)
933 try {
934 entry->extract_icon(_big_icons);
935 } catch(COMException&) {
936 // ignore unexpected exceptions while extracting icons
937 }
938
939 if (entry->_icon_id > ICID_NONE) {
940 btn._icon_id = (ICON_ID)/*@@*/ entry->_icon_id;
941
942 RECT rect;
943
944 GetButtonRect(btn._id, &rect);
945
946 if (rect.bottom > _bottom_max)
947 break;
948
949 WindowCanvas canvas(_hwnd);
950 DrawStartMenuButton(canvas, rect, NULL, btn, btn._id==_selected_id, false, _big_icons);
951
952 //InvalidateRect(_hwnd, &rect, FALSE);
953 //UpdateWindow(_hwnd);
954 //break;
955
956 break;
957 }
958 }
959 }
960 }
961
962 // if (++idx < (int)_buttons.size())
963 // PostMessage(_hwnd, PM_UPDATE_ICONS, idx, 0);
964
965 #else
966
967 int icons_extracted = 0;
968 int icons_updated = 0;
969
970 for(StartMenuShellDirs::iterator it=_dirs.begin(); it!=_dirs.end(); ++it) {
971 ShellDirectory& dir = it->_dir;
972
973 icons_extracted += dir.extract_icons();
974 }
975
976 if (icons_extracted) {
977 for(ShellEntryMap::iterator it1=_entries.begin(); it1!=_entries.end(); ++it1) {
978 StartMenuEntry& sme = it1->second;
979
980 if (!sme._hIcon) {
981 sme._hIcon = (HICON)-1;
982
983 for(ShellEntrySet::const_iterator it2=sme._entries.begin(); it2!=sme._entries.end(); ++it2) {
984 const Entry* sm_entry = *it2;
985
986 if (sm_entry->_hIcon) {
987 sme._hIcon = sm_entry->_hIcon;
988 break;
989 }
990 }
991 }
992 }
993
994 for(SMBtnVector::iterator it=_buttons.begin(); it!=_buttons.end(); ++it) {
995 SMBtnInfo& info = *it;
996
997 if (info._id>0 && !info._hIcon) {
998 info._hIcon = _entries[info._id]._hIcon;
999 ++icons_updated;
1000 }
1001 }
1002 }
1003
1004 if (icons_updated) {
1005 InvalidateRect(_hwnd, NULL, FALSE);
1006 UpdateWindow(_hwnd);
1007 }
1008 #endif
1009 }
1010 #endif
1011
1012
1013 // resize child button controls to accomodate for new window size
1014 void StartMenu::ResizeButtons(int cx)
1015 {
1016 HDWP hdwp = BeginDeferWindowPos(10);
1017
1018 for(HWND ctrl=GetWindow(_hwnd,GW_CHILD); ctrl; ctrl=GetNextWindow(ctrl,GW_HWNDNEXT)) {
1019 ClientRect rt(ctrl);
1020
1021 if (rt.right != cx) {
1022 int height = rt.bottom - rt.top;
1023
1024 // special handling for separator controls
1025 if (!height && (GetWindowStyle(ctrl)&SS_TYPEMASK)==SS_ETCHEDHORZ)
1026 height = 2;
1027
1028 hdwp = DeferWindowPos(hdwp, ctrl, 0, 0, 0, cx, height, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
1029 }
1030 }
1031
1032 EndDeferWindowPos(hdwp);
1033 }
1034
1035
1036 int StartMenu::Command(int id, int code)
1037 {
1038 #ifndef _LIGHT_STARTMENU
1039 switch(id) {
1040 case IDCANCEL:
1041 CloseStartMenu(id);
1042 break;
1043
1044 default: {
1045 #endif
1046 ShellEntryMap::iterator found = _entries.find(id);
1047
1048 if (found != _entries.end()) {
1049 ActivateEntry(id, found->second._entries);
1050 return 0;
1051 }
1052
1053 return super::Command(id, code);
1054 #ifndef _LIGHT_STARTMENU
1055 }
1056 }
1057
1058 return 0;
1059 #endif
1060 }
1061
1062
1063 ShellEntryMap::iterator StartMenu::AddEntry(const String& title, ICON_ID icon_id, Entry* entry)
1064 {
1065 // search for an already existing subdirectory entry with the same name
1066 if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1067 for(ShellEntryMap::iterator it=_entries.begin(); it!=_entries.end(); ++it) {
1068 StartMenuEntry& sme = it->second;
1069
1070 if (!_tcsicmp(sme._title, title)) ///@todo speed up by using a map indexed by name
1071 for(ShellEntrySet::iterator it2=sme._entries.begin(); it2!=sme._entries.end(); ++it2) {
1072 if ((*it2)->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1073 // merge the new shell entry with the existing of the same name
1074 sme._entries.insert(entry);
1075
1076 return it;
1077 }
1078 }
1079 }
1080
1081 ShellEntryMap::iterator sme = AddEntry(title, icon_id);
1082
1083 sme->second._entries.insert(entry);
1084
1085 return sme;
1086 }
1087
1088 ShellEntryMap::iterator StartMenu::AddEntry(const String& title, ICON_ID icon_id, int id)
1089 {
1090 if (id == -1)
1091 id = ++_next_id;
1092
1093 StartMenuEntry sme;
1094
1095 sme._title = title;
1096 sme._icon_id = icon_id;
1097
1098 ShellEntryMap::iterator it = _entries.insert(make_pair(id, sme)).first;
1099
1100 return it;
1101 }
1102
1103 ShellEntryMap::iterator StartMenu::AddEntry(const ShellFolder folder, ShellEntry* entry)
1104 {
1105 ICON_ID icon_id;
1106
1107 if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1108 icon_id = ICID_FOLDER;
1109 else
1110 icon_id = (ICON_ID)/*@@*/ entry->_icon_id;
1111
1112 return AddEntry(folder.get_name(entry->_pidl), icon_id, entry);
1113 }
1114
1115 ShellEntryMap::iterator StartMenu::AddEntry(const ShellFolder folder, Entry* entry)
1116 {
1117 ICON_ID icon_id;
1118
1119 if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1120 icon_id = ICID_FOLDER;
1121 else
1122 icon_id = (ICON_ID)/*@@*/ entry->_icon_id;
1123
1124 return AddEntry(entry->_display_name, icon_id, entry);
1125 }
1126
1127
1128 void StartMenu::AddButton(LPCTSTR title, ICON_ID icon_id, bool hasSubmenu, int id, bool enabled)
1129 {
1130 #ifdef _LIGHT_STARTMENU
1131 _buttons.push_back(SMBtnInfo(title, icon_id, id, hasSubmenu, enabled));
1132 #else
1133 DWORD style = enabled? WS_VISIBLE|WS_CHILD|BS_OWNERDRAW: WS_VISIBLE|WS_CHILD|BS_OWNERDRAW|WS_DISABLED;
1134
1135 WindowRect rect(_hwnd);
1136 ClientRect clnt(_hwnd);
1137
1138 // increase window height to make room for the new button
1139 rect.top -= STARTMENU_LINE_HEIGHT;
1140
1141 // move down if we are too high now
1142 if (rect.top < 0) {
1143 rect.top += STARTMENU_LINE_HEIGHT;
1144 rect.bottom += STARTMENU_LINE_HEIGHT;
1145 }
1146
1147 WindowCanvas canvas(_hwnd);
1148 FontSelection font(canvas, GetStockFont(DEFAULT_GUI_FONT));
1149
1150 // widen window, if it is too small
1151 int text_width = GetStartMenuBtnTextWidth(canvas, title, _hwnd) + ICON_SIZE_X + 10/*placeholder*/ + 16/*arrow*/;
1152
1153 int cx = clnt.right - _border_left;
1154 if (text_width > cx)
1155 rect.right += text_width-cx;
1156
1157 MoveWindow(_hwnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
1158
1159 StartMenuCtrl(_hwnd, _border_left, clnt.bottom, rect.right-rect.left-_border_left,
1160 title, id, g_Globals._icon_cache.get_icon(icon_id)._hIcon, hasSubmenu, style);
1161 #endif
1162 }
1163
1164 void StartMenu::AddSeparator()
1165 {
1166 #ifdef _LIGHT_STARTMENU
1167 _buttons.push_back(SMBtnInfo(NULL, ICID_NONE, -1, false));
1168 #else
1169 WindowRect rect(_hwnd);
1170 ClientRect clnt(_hwnd);
1171
1172 // increase window height to make room for the new separator
1173 rect.top -= STARTMENU_SEP_HEIGHT;
1174
1175 // move down if we are too high now
1176 if (rect.top < 0) {
1177 rect.top += STARTMENU_LINE_HEIGHT;
1178 rect.bottom += STARTMENU_LINE_HEIGHT;
1179 }
1180
1181 MoveWindow(_hwnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
1182
1183 StartMenuSeparator(_hwnd, _border_left, clnt.bottom, rect.right-rect.left-_border_left);
1184 #endif
1185 }
1186
1187
1188 bool StartMenu::CloseOtherSubmenus(int id)
1189 {
1190 if (_submenu) {
1191 if (IsWindow(_submenu)) {
1192 if (_submenu_id == id)
1193 return false;
1194 else {
1195 _submenu_id = 0;
1196 DestroyWindow(_submenu);
1197 // _submenu should be reset automatically by PM_STARTMENU_CLOSED, but safety first...
1198 }
1199 }
1200
1201 _submenu = 0;
1202 }
1203
1204 return true;
1205 }
1206
1207
1208 void StartMenu::CreateSubmenu(int id, LPCTSTR title, CREATORFUNC_INFO creator, void* info)
1209 {
1210 CreateSubmenu(id, StartMenuFolders(), title, creator, info);
1211 }
1212
1213 bool StartMenu::CreateSubmenu(int id, int folder_id, LPCTSTR title, CREATORFUNC_INFO creator, void* info)
1214 {
1215 try {
1216 SpecialFolderPath folder(folder_id, _hwnd);
1217
1218 StartMenuFolders new_folders;
1219 new_folders.push_back(folder);
1220
1221 CreateSubmenu(id, new_folders, title, creator, info);
1222
1223 return true;
1224 } catch(COMException&) {
1225 // ignore Exception and don't display anything
1226 CloseOtherSubmenus(id);
1227 _buttons[GetSelectionIndex()]._enabled = false; // disable entries for non-existing folders
1228 return false;
1229 }
1230 }
1231
1232 bool StartMenu::CreateSubmenu(int id, int folder_id1, int folder_id2, LPCTSTR title, CREATORFUNC_INFO creator, void* info)
1233 {
1234 StartMenuFolders new_folders;
1235
1236 try {
1237 new_folders.push_back(SpecialFolderPath(folder_id1, _hwnd));
1238 } catch(COMException&) {
1239 }
1240
1241 try {
1242 new_folders.push_back(SpecialFolderPath(folder_id2, _hwnd));
1243 } catch(COMException&) {
1244 }
1245
1246 if (!new_folders.empty()) {
1247 CreateSubmenu(id, new_folders, title, creator, info);
1248 return true;
1249 } else {
1250 CloseOtherSubmenus(id);
1251 _buttons[GetSelectionIndex()]._enabled = false; // disable entries for non-existing folders
1252 return false;
1253 }
1254 }
1255
1256 void StartMenu::CreateSubmenu(int id, const StartMenuFolders& new_folders, LPCTSTR title, CREATORFUNC_INFO creator, void* info)
1257 {
1258 // Only open one submenu at a time.
1259 if (!CloseOtherSubmenus(id))
1260 return;
1261
1262 RECT rect;
1263 int x, y;
1264
1265 if (GetButtonRect(id, &rect)) {
1266 ClientToScreen(_hwnd, &rect);
1267
1268 x = rect.right; // Submenus should overlap their parent a bit.
1269 const bool big_icons = _big_icons;
1270 y = rect.top+STARTMENU_LINE_HEIGHT +_border_top/*own border*/ -STARTMENU_TOP_BTN_SPACE/*border of new submenu*/;
1271 } else {
1272 WindowRect pos(_hwnd);
1273
1274 x = pos.right;
1275 y = pos.top;
1276 }
1277
1278 _submenu_id = id;
1279 _submenu = StartMenu::Create(x, y, new_folders, _hwnd, title, _big_icons, creator, info, _create_info._filter);
1280 }
1281
1282
1283 void StartMenu::ActivateEntry(int id, const ShellEntrySet& entries)
1284 {
1285 StartMenuFolders new_folders;
1286 String title;
1287
1288 for(ShellEntrySet::const_iterator it=entries.begin(); it!=entries.end(); ++it) {
1289 Entry* entry = const_cast<Entry*>(*it);
1290
1291 if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1292
1293 ///@todo If the user explicitly clicked on a submenu, display this folder as floating start menu.
1294
1295 if (entry->_etype == ET_SHELL)
1296 new_folders.push_back(entry->create_absolute_pidl());
1297 else {
1298 TCHAR path[MAX_PATH];
1299
1300 if (entry->get_path(path, COUNTOF(path)))
1301 new_folders.push_back(path);
1302 }
1303
1304 if (title.empty())
1305 title = entry->_display_name;
1306 } else {
1307 // The entry is no subdirectory, so there can only be one shell entry.
1308 assert(entries.size()==1);
1309
1310 HWND hparent = GetParent(_hwnd);
1311 ShellPath shell_path = entry->create_absolute_pidl();
1312
1313 // close start menus when launching the selected entry
1314 CloseStartMenu(id);
1315
1316 ///@todo launch in the background; specify correct HWND for error message box titles
1317 SHELLEXECUTEINFO shexinfo;
1318
1319 shexinfo.cbSize = sizeof(SHELLEXECUTEINFO);
1320 shexinfo.fMask = SEE_MASK_IDLIST; // SEE_MASK_INVOKEIDLIST is also possible.
1321 shexinfo.hwnd = hparent;
1322 shexinfo.lpVerb = NULL;
1323 shexinfo.lpFile = NULL;
1324 shexinfo.lpParameters = NULL;
1325 shexinfo.lpDirectory = NULL;
1326 shexinfo.nShow = SW_SHOWNORMAL;
1327
1328 shexinfo.lpIDList = &*shell_path;
1329
1330 // add PIDL to the recent file list
1331 SHAddToRecentDocs(SHARD_PIDL, shexinfo.lpIDList);
1332
1333 if (!ShellExecuteEx(&shexinfo))
1334 display_error(hparent, GetLastError());
1335
1336 // we may have deleted 'this' - ensure we leave the loop and function
1337 return;
1338 }
1339 }
1340
1341 if (!new_folders.empty()) {
1342 // Only open one submenu at a time.
1343 if (!CloseOtherSubmenus(id))
1344 return;
1345
1346 CreateSubmenu(id, new_folders, title);
1347 }
1348 }
1349
1350
1351 /// close all windows of the start menu popup
1352 void StartMenu::CloseStartMenu(int id)
1353 {
1354 if (!(GetWindowStyle(_hwnd) & WS_CAPTION)) { // don't automatically close floating menus
1355 if (!SendParent(PM_STARTENTRY_LAUNCHED, id, (LPARAM)_hwnd))
1356 DestroyWindow(_hwnd);
1357 } else if (_submenu) // instead close submenus of floating parent menus
1358 CloseSubmenus();
1359 }
1360
1361
1362 int GetStartMenuBtnTextWidth(HDC hdc, LPCTSTR title, HWND hwnd)
1363 {
1364 RECT rect = {0, 0, 0, 0};
1365 DrawText(hdc, title, -1, &rect, DT_SINGLELINE|DT_NOPREFIX|DT_CALCRECT);
1366
1367 return rect.right-rect.left;
1368 }
1369
1370 #ifdef _LIGHT_STARTMENU
1371 void DrawStartMenuButton(HDC hdc, const RECT& rect, LPCTSTR title, const SMBtnInfo& btn, bool has_focus, bool pushed, bool big_icons)
1372 #else
1373 void DrawStartMenuButton(HDC hdc, const RECT& rect, LPCTSTR title, HICON hIcon,
1374 bool hasSubmenu, bool enabled, bool has_focus, bool pushed, bool big_icons);
1375 #endif
1376 {
1377 UINT style = DFCS_BUTTONPUSH;
1378
1379 if (!btn._enabled)
1380 style |= DFCS_INACTIVE;
1381
1382 POINT iconPos = {rect.left+2, (rect.top+rect.bottom-ICON_SIZE_Y)/2};
1383 RECT textRect = {rect.left+ICON_SIZE_X+4, rect.top+2, rect.right-4, rect.bottom-4};
1384
1385 if (pushed) {
1386 style |= DFCS_PUSHED;
1387 ++iconPos.x; ++iconPos.y;
1388 ++textRect.left; ++textRect.top;
1389 ++textRect.right; ++textRect.bottom;
1390 }
1391
1392 int bk_color_idx = COLOR_BTNFACE;
1393 int text_color_idx = COLOR_BTNTEXT;
1394
1395 if (has_focus) {
1396 bk_color_idx = COLOR_HIGHLIGHT;
1397 text_color_idx = COLOR_HIGHLIGHTTEXT;
1398 }
1399
1400 COLORREF bk_color = GetSysColor(bk_color_idx);
1401 HBRUSH bk_brush = GetSysColorBrush(bk_color_idx);
1402
1403 if (title)
1404 FillRect(hdc, &rect, bk_brush);
1405
1406 if (btn._icon_id > ICID_NONE)
1407 g_Globals._icon_cache.get_icon(btn._icon_id).draw(hdc, iconPos.x, iconPos.y, ICON_SIZE_X, ICON_SIZE_Y, bk_color, bk_brush/*, big_icons*/);
1408
1409 // draw submenu arrow at the right
1410 if (btn._hasSubmenu) {
1411 ResIconEx arrowIcon(IDI_ARROW, ICON_SIZE_X, ICON_SIZE_Y);
1412 ResIconEx selArrowIcon(IDI_ARROW_SELECTED, ICON_SIZE_X, ICON_SIZE_Y);
1413
1414 DrawIconEx(hdc, rect.right-ICON_SIZE_X, iconPos.y,
1415 has_focus? selArrowIcon: arrowIcon,
1416 ICON_SIZE_X, ICON_SIZE_Y, 0, bk_brush, DI_NORMAL);
1417 }
1418
1419 if (title) {
1420 BkMode bk_mode(hdc, TRANSPARENT);
1421
1422 if (!btn._enabled) // dis->itemState & (ODS_DISABLED|ODS_GRAYED)
1423 DrawGrayText(hdc, &textRect, title, DT_SINGLELINE|DT_NOPREFIX|DT_VCENTER);
1424 else {
1425 TextColor lcColor(hdc, GetSysColor(text_color_idx));
1426 DrawText(hdc, title, -1, &textRect, DT_SINGLELINE|DT_NOPREFIX|DT_VCENTER);
1427 }
1428 }
1429 }
1430
1431
1432 #ifdef _LIGHT_STARTMENU
1433
1434 void StartMenu::ResizeToButtons()
1435 {
1436 WindowRect rect(_hwnd);
1437
1438 WindowCanvas canvas(_hwnd);
1439 FontSelection font(canvas, GetStockFont(DEFAULT_GUI_FONT));
1440
1441 const bool big_icons = _big_icons;
1442
1443 int max_width = STARTMENU_WIDTH_MIN;
1444 int height = 0;
1445
1446 for(SMBtnVector::const_iterator it=_buttons.begin(); it!=_buttons.end(); ++it) {
1447 int w = GetStartMenuBtnTextWidth(canvas, it->_title, _hwnd);
1448
1449 if (w > max_width)
1450 max_width = w;
1451
1452 if (it->_id == -1)
1453 height += STARTMENU_SEP_HEIGHT;
1454 else
1455 height += STARTMENU_LINE_HEIGHT;
1456 }
1457
1458 // calculate new window size
1459 int text_width = max_width + ICON_SIZE_X + 10/*placeholder*/ + 16/*arrow*/;
1460
1461 RECT rt_hgt = {rect.left, rect.bottom-_border_top-height, rect.left+_border_left+text_width, rect.bottom};
1462 AdjustWindowRectEx(&rt_hgt, GetWindowStyle(_hwnd), FALSE, GetWindowExStyle(_hwnd));
1463
1464 // ignore movement, only look at the size change
1465 rect.right = rect.left + (rt_hgt.right-rt_hgt.left);
1466 rect.top = rect.bottom - (rt_hgt.bottom-rt_hgt.top);
1467
1468 // move down if we are too high
1469 if (rect.top < 0) {
1470 int dy = -rect.top;
1471 rect.top += dy;
1472 rect.bottom += dy;
1473 }
1474
1475 // enable scroll mode for long start menus, which span more than the whole screen height
1476 int cyscreen = GetSystemMetrics(SM_CYSCREEN);
1477 int bottom_max = 0;
1478
1479 if (rect.bottom > cyscreen) {
1480 _arrow_btns = true;
1481
1482 _invisible_lines = (rect.bottom-cyscreen+(STARTMENU_LINE_HEIGHT-1))/STARTMENU_LINE_HEIGHT + 1;
1483 rect.bottom -= _invisible_lines * STARTMENU_LINE_HEIGHT;
1484
1485 bottom_max = rect.bottom;
1486
1487 if (_floating_btn)
1488 rect.bottom += 6; // lower scroll arrow
1489 else {
1490 _border_top += 6; // upper scroll arrow
1491 rect.bottom += 2*6; // upper+lower scroll arrow
1492 }
1493 }
1494
1495 MoveWindow(_hwnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
1496
1497 if (bottom_max) {
1498 POINT pt = {0, bottom_max};
1499
1500 ScreenToClient(_hwnd, &pt);
1501
1502 _bottom_max = pt.y;
1503 }
1504 }
1505
1506 #else // _LIGHT_STARTMENU
1507
1508 LRESULT StartMenuButton::WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
1509 {
1510 switch(nmsg) {
1511 case WM_MOUSEMOVE:
1512 // automatically set the focus to startmenu entries when moving the mouse over them
1513 if (GetFocus()!=_hwnd && !(GetWindowStyle(_hwnd)&WS_DISABLED))
1514 SetFocus(_hwnd);
1515 break;
1516
1517 case WM_SETFOCUS:
1518 PostParent(PM_STARTENTRY_FOCUSED, _hasSubmenu, (LPARAM)_hwnd);
1519 goto def;
1520
1521 case WM_CANCELMODE:
1522 // route WM_CANCELMODE to the startmenu window
1523 return SendParent(nmsg, wparam, lparam);
1524
1525 default: def:
1526 return super::WndProc(nmsg, wparam, lparam);
1527 }
1528
1529 return 0;
1530 }
1531
1532 void StartMenuButton::DrawItem(LPDRAWITEMSTRUCT dis)
1533 {
1534 TCHAR title[BUFFER_LEN];
1535
1536 GetWindowText(_hwnd, title, BUFFER_LEN);
1537
1538 DrawStartMenuButton(dis->hDC, dis->rcItem, title, _hIcon,
1539 _hasSubmenu,
1540 !(dis->itemState & ODS_DISABLED),
1541 dis->itemState&ODS_FOCUS? true: false,
1542 dis->itemState&ODS_SELECTED? true: false);
1543 }
1544
1545 #endif
1546
1547
1548 StartMenuRoot::StartMenuRoot(HWND hwnd)
1549 : super(hwnd, false) ///@todo big icons in start menu root
1550 {
1551 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1552 if (!g_Globals._SHRestricted || !SHRestricted(REST_NOCOMMONGROUPS))
1553 #endif
1554 try {
1555 // insert directory "All Users\Start Menu"
1556 ShellDirectory cmn_startmenu(GetDesktopFolder(), SpecialFolderPath(CSIDL_COMMON_STARTMENU, _hwnd), _hwnd);
1557 _dirs.push_back(StartMenuDirectory(cmn_startmenu, (LPCTSTR)SpecialFolderFSPath(CSIDL_COMMON_PROGRAMS, _hwnd)));
1558 } catch(COMException&) {
1559 // ignore exception and don't show additional shortcuts
1560 }
1561
1562 try {
1563 // insert directory "<user name>\Start Menu"
1564 ShellDirectory usr_startmenu(GetDesktopFolder(), SpecialFolderPath(CSIDL_STARTMENU, _hwnd), _hwnd);
1565 _dirs.push_back(StartMenuDirectory(usr_startmenu, (LPCTSTR)SpecialFolderFSPath(CSIDL_PROGRAMS, _hwnd)));
1566 } catch(COMException&) {
1567 // ignore exception and don't show additional shortcuts
1568 }
1569
1570 ReadLogoSize();
1571 }
1572
1573 void StartMenuRoot::ReadLogoSize()
1574 {
1575 // read size of logo bitmap
1576 BITMAP bmp_hdr;
1577 GetObject(ResBitmap(GetLogoResId()), sizeof(BITMAP), &bmp_hdr);
1578 _logo_size.cx = bmp_hdr.bmWidth;
1579 _logo_size.cy = bmp_hdr.bmHeight;
1580
1581 // cache logo width
1582 _border_left = _logo_size.cx + 1;
1583 }
1584
1585
1586 static void CalculateStartPos(HWND hwndOwner, RECT& rect, bool big_icons)
1587 {
1588 WindowRect pos(hwndOwner);
1589
1590 rect.left = pos.left;
1591 rect.top = pos.top-STARTMENU_LINE_HEIGHT-4;
1592 rect.right = pos.left+STARTMENU_WIDTH_MIN;
1593 rect.bottom = pos.top;
1594
1595 #ifndef _LIGHT_STARTMENU
1596 rect.top += STARTMENU_LINE_HEIGHT;
1597 #endif
1598
1599 AdjustWindowRectEx(&rect, WS_POPUP|WS_THICKFRAME|WS_CLIPCHILDREN|WS_VISIBLE, FALSE, 0);
1600 }
1601
1602 HWND StartMenuRoot::Create(HWND hwndOwner, bool big_icons)
1603 {
1604 RECT rect;
1605
1606 CalculateStartPos(hwndOwner, rect, big_icons);
1607
1608 return Window::Create(WINDOW_CREATOR(StartMenuRoot), 0, GetWndClasss(), TITLE_STARTMENU,
1609 WS_POPUP|WS_THICKFRAME|WS_CLIPCHILDREN,
1610 rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, hwndOwner);
1611 }
1612
1613
1614 void StartMenuRoot::TrackStartmenu()
1615 {
1616 MSG msg;
1617 HWND hwnd = _hwnd;
1618
1619 #ifdef _LIGHT_STARTMENU
1620 _selected_id = -1;
1621 #endif
1622
1623 #ifdef _LIGHT_STARTMENU
1624 // recalculate start menu root position
1625 RECT rect;
1626
1627 CalculateStartPos(GetParent(hwnd), rect, _big_icons);
1628
1629 SetWindowPos(hwnd, 0, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, 0);
1630
1631 ResizeToButtons();
1632 #endif
1633
1634 // show previously hidden start menu
1635 ShowWindow(hwnd, SW_SHOW);
1636 SetForegroundWindow(hwnd);
1637
1638 while(IsWindow(hwnd) && IsWindowVisible(hwnd)) {
1639 if (!GetMessage(&msg, 0, 0, 0)) {
1640 PostQuitMessage(msg.wParam);
1641 break;
1642 }
1643
1644 // Check for a mouse click on any window, that is not part of the start menu
1645 if (msg.message==WM_LBUTTONDOWN || msg.message==WM_MBUTTONDOWN || msg.message==WM_RBUTTONDOWN) {
1646 StartMenu* menu_wnd = NULL;
1647
1648 for(HWND hwnd=msg.hwnd; hwnd; hwnd=GetParent(hwnd)) {
1649 menu_wnd = WINDOW_DYNAMIC_CAST(StartMenu, hwnd);
1650
1651 if (menu_wnd)
1652 break;
1653 }
1654
1655 if (!menu_wnd) {
1656 CloseStartMenu();
1657 break;
1658 }
1659 }
1660
1661 try {
1662 if (pretranslate_msg(&msg))
1663 continue;
1664
1665 if (dispatch_dialog_msg(&msg))
1666 continue;
1667
1668 TranslateMessage(&msg);
1669
1670 try {
1671 DispatchMessage(&msg);
1672 } catch(COMException& e) {
1673 HandleException(e, _hwnd);
1674 }
1675 } catch(COMException& e) {
1676 HandleException(e, _hwnd);
1677 }
1678 }
1679 }
1680
1681
1682 LRESULT StartMenuRoot::Init(LPCREATESTRUCT pcs)
1683 {
1684 // add buttons for entries in _entries
1685 if (super::Init(pcs))
1686 return 1;
1687
1688 AddSeparator();
1689
1690
1691 #ifdef __MINGW32__
1692 HKEY hkey, hkeyAdv;
1693 DWORD value, len;
1694
1695 if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"), &hkey))
1696 hkey = 0;
1697
1698 if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced"), &hkeyAdv))
1699 hkeyAdv = 0;
1700
1701 #define IS_VALUE_ZERO(hk, name) \
1702 (!hk || (len=sizeof(value),RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE)&value, &len) || !value))
1703
1704 #define IS_VALUE_NOT_ZERO(hk, name) \
1705 (!hk || (len=sizeof(value),RegQueryValueEx(hk, name, NULL, NULL, (LPBYTE)&value, &len) || value>0))
1706 #endif
1707
1708
1709 // insert hard coded start entries
1710 AddButton(ResString(IDS_PROGRAMS), ICID_APPS, true, IDC_PROGRAMS);
1711
1712 AddButton(ResString(IDS_DOCUMENTS), ICID_DOCUMENTS, true, IDC_DOCUMENTS);
1713
1714 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1715 if (!g_Globals._SHRestricted || !SHRestricted(REST_NORECENTDOCSMENU))
1716 #else
1717 if (IS_VALUE_ZERO(hkey, _T("NoRecentDocsMenu")))
1718 #endif
1719 AddButton(ResString(IDS_RECENT), ICID_DOCUMENTS, true, IDC_RECENT);
1720
1721 AddButton(ResString(IDS_FAVORITES), ICID_FAVORITES, true, IDC_FAVORITES);
1722
1723 AddButton(ResString(IDS_SETTINGS), ICID_CONFIG, true, IDC_SETTINGS);
1724
1725 AddButton(ResString(IDS_BROWSE), ICID_FOLDER, true, IDC_BROWSE);
1726
1727 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1728 if (!g_Globals._SHRestricted || !SHRestricted(REST_NOFIND))
1729 #else
1730 if (IS_VALUE_ZERO(hkey, _T("NoFind")))
1731 #endif
1732 AddButton(ResString(IDS_SEARCH), ICID_SEARCH, true, IDC_SEARCH);
1733
1734 AddButton(ResString(IDS_START_HELP), ICID_INFO, false, IDC_START_HELP);
1735
1736 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1737 if (!g_Globals._SHRestricted || !SHRestricted(REST_NORUN))
1738 #else
1739 if (IS_VALUE_ZERO(hkey, _T("NoRun")))
1740 #endif
1741 AddButton(ResString(IDS_LAUNCH), ICID_ACTION, false, IDC_LAUNCH);
1742
1743
1744 AddSeparator();
1745
1746
1747 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1748 if (!g_Globals._SHRestricted || !SHRestricted(REST_NOCLOSE))
1749 #else
1750 if (IS_VALUE_NOT_ZERO(hkeyAdv, _T("StartMenuLogoff")))
1751 #endif
1752 AddButton(ResString(IDS_LOGOFF), ICID_LOGOFF, false, IDC_LOGOFF);
1753
1754
1755 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
1756 if (!g_Globals._SHRestricted || SHRestricted(REST_STARTMENULOGOFF) != 1)
1757 #else
1758 if (IS_VALUE_ZERO(hkey, _T("NoClose")))
1759 #endif
1760 AddButton(ResString(IDS_SHUTDOWN), ICID_LOGOFF, false, IDC_SHUTDOWN);
1761
1762
1763 #ifndef _ROS_
1764 AddButton(ResString(IDS_TERMINATE), ICID_LOGOFF, false, IDC_TERMINATE);
1765 #endif
1766
1767
1768 #ifdef __MINGW32__
1769 RegCloseKey(hkeyAdv);
1770 RegCloseKey(hkey);
1771 #endif
1772
1773
1774 #ifdef _LIGHT_STARTMENU
1775 // set the window size to fit all buttons
1776 ResizeToButtons();
1777 #endif
1778
1779 return 0;
1780 }
1781
1782
1783 void StartMenuRoot::AddEntries()
1784 {
1785 super::AddEntries();
1786
1787 AddButton(ResString(IDS_EXPLORE), ICID_EXPLORER, false, IDC_EXPLORE);
1788 }
1789
1790
1791 LRESULT StartMenuRoot::WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
1792 {
1793 switch(nmsg) {
1794 case WM_PAINT: {
1795 PaintCanvas canvas(_hwnd);
1796 Paint(canvas);
1797 break;}
1798
1799 case WM_DISPLAYCHANGE:
1800 // re-evaluate logo size using the correct color depth
1801 ReadLogoSize();
1802 break;
1803
1804 default:
1805 return super::WndProc(nmsg, wparam, lparam);
1806 }
1807
1808 return 0;
1809 }
1810
1811 void StartMenuRoot::Paint(PaintCanvas& canvas)
1812 {
1813 MemCanvas mem_dc;
1814 ResBitmap bmp(GetLogoResId());
1815 BitmapSelection sel(mem_dc, bmp);
1816
1817 ClientRect clnt(_hwnd);
1818 int h = min(_logo_size.cy, clnt.bottom);
1819
1820 RECT rect = {0, 0, _logo_size.cx, clnt.bottom-h};
1821 HBRUSH hbr = CreateSolidBrush(GetPixel(mem_dc, 0, 0));
1822 FillRect(canvas, &rect, hbr);
1823 DeleteObject(hbr);
1824
1825 PatBlt(canvas, _logo_size.cx, 0, 1, clnt.bottom, WHITENESS);
1826
1827 BitBlt(canvas, 0, clnt.bottom-h, _logo_size.cx, h, mem_dc, 0, 0, SRCCOPY);
1828
1829 super::Paint(canvas);
1830 }
1831
1832 UINT StartMenuRoot::GetLogoResId()
1833 {
1834 WindowCanvas dc(_hwnd);
1835
1836 int clr_bits = GetDeviceCaps(dc, BITSPIXEL);
1837
1838 if (clr_bits > 8)
1839 return IDB_LOGOV;
1840 else if (clr_bits > 4)
1841 return IDB_LOGOV256;
1842 else
1843 return IDB_LOGOV16;
1844 }
1845
1846
1847 void StartMenuRoot::CloseStartMenu(int id)
1848 {
1849 if (_submenu)
1850 CloseSubmenus();
1851
1852 ShowWindow(_hwnd, SW_HIDE);
1853 }
1854
1855 void StartMenuRoot::ProcessKey(int vk)
1856 {
1857 switch(vk) {
1858 case VK_LEFT:
1859 if (_submenu)
1860 CloseOtherSubmenus();
1861 // don't close start menu root
1862 break;
1863
1864 default:
1865 super::ProcessKey(vk);
1866 }
1867 }
1868
1869
1870 int StartMenuHandler::Command(int id, int code)
1871 {
1872 switch(id) {
1873
1874 // start menu root
1875
1876 case IDC_PROGRAMS:
1877 CreateSubmenu(id, CSIDL_COMMON_PROGRAMS, CSIDL_PROGRAMS, ResString(IDS_PROGRAMS));
1878 break;
1879
1880 case IDC_EXPLORE:
1881 CloseStartMenu(id);
1882 explorer_show_frame(SW_SHOWNORMAL);
1883 break;
1884
1885 case IDC_LAUNCH:
1886 CloseStartMenu(id);
1887 ShowLaunchDialog(g_Globals._hwndDesktopBar);
1888 break;
1889
1890 case IDC_DOCUMENTS:
1891 CreateSubmenu(id, CSIDL_PERSONAL, ResString(IDS_DOCUMENTS));
1892 break;
1893
1894 case IDC_RECENT:
1895 CreateSubmenu(id, CSIDL_RECENT, ResString(IDS_RECENT), STARTMENU_CREATOR(RecentStartMenu));
1896 break;
1897
1898 case IDC_FAVORITES:
1899 #ifndef _SHELL32_FAVORITES
1900 CreateSubmenu(id, ResString(IDS_FAVORITES), STARTMENU_CREATOR(FavoritesMenu), &static_cast<BookmarkList&>(g_Globals._favorites));
1901 #else
1902 CreateSubmenu(id, CSIDL_COMMON_FAVORITES, CSIDL_FAVORITES, ResString(IDS_FAVORITES));
1903 #endif
1904 break;
1905
1906 case IDC_BROWSE:
1907 CreateSubmenu(id, ResString(IDS_BROWSE), STARTMENU_CREATOR(BrowseMenu));
1908 break;
1909
1910 case IDC_SETTINGS:
1911 CreateSubmenu(id, ResString(IDS_SETTINGS), STARTMENU_CREATOR(SettingsMenu));
1912 break;
1913
1914 case IDC_SEARCH:
1915 CreateSubmenu(id, ResString(IDS_SEARCH), STARTMENU_CREATOR(SearchMenu));
1916 break;
1917
1918 case IDC_START_HELP:
1919 CloseStartMenu(id);
1920 MessageBox(g_Globals._hwndDesktopBar, TEXT("Help not yet implemented"), ResString(IDS_TITLE), MB_OK);
1921 break;
1922
1923 case IDC_LOGOFF:
1924 CloseStartMenu(id);
1925 ShowLogoffDialog(g_Globals._hwndDesktopBar);
1926 break;
1927
1928 #ifndef _ROS_
1929 case IDC_TERMINATE:
1930 DestroyWindow(GetParent(_hwnd));
1931 break;
1932 #endif
1933
1934 case IDC_SHUTDOWN:
1935 CloseStartMenu(id);
1936 ShowExitWindowsDialog(g_Globals._hwndDesktopBar);
1937 break;
1938
1939
1940 // settings menu
1941
1942 case ID_DESKTOPBAR_SETTINGS:
1943 CloseStartMenu(id);
1944 ExplorerPropertySheet(g_Globals._hwndDesktopBar);
1945 break;
1946
1947 case IDC_CONTROL_PANEL: {
1948 CloseStartMenu(id);
1949 #ifndef ROSSHELL
1950 #ifndef _NO_MDI
1951 XMLPos explorer_options = g_Globals.get_cfg("general/explorer");
1952 bool mdi = XMLBool(explorer_options, "mdi", true);
1953
1954 if (mdi)
1955 MDIMainFrame::Create(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}"), 0);
1956 else
1957 #endif
1958 SDIMainFrame::Create(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}"), 0);
1959 #else
1960 launch_file(_hwnd, SHELLPATH_CONTROL_PANEL);
1961 #endif
1962 break;}
1963
1964 case IDC_SETTINGS_MENU:
1965 CreateSubmenu(id, CSIDL_CONTROLS, ResString(IDS_SETTINGS_MENU));
1966 break;
1967
1968 case IDC_PRINTERS: {
1969 CloseStartMenu(id);
1970
1971 #ifndef ROSSHELL
1972 #ifdef _ROS_ // to be removed when printer folder will be implemented
1973 MessageBox(0, TEXT("printer folder not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
1974 #else
1975 #ifndef _NO_MDI
1976 XMLPos explorer_options = g_Globals.get_cfg("general/explorer");
1977 bool mdi = XMLBool(explorer_options, "mdi", true);
1978
1979 if (mdi)
1980 MDIMainFrame::Create(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}"), 0);
1981 else
1982 #endif
1983 SDIMainFrame::Create(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}"), 0);
1984 #endif
1985 #else
1986 launch_file(_hwnd, SHELLPATH_PRINTERS);
1987 #endif
1988 break;}
1989
1990 case IDC_PRINTERS_MENU:
1991 CreateSubmenu(id, CSIDL_PRINTERS, CSIDL_PRINTHOOD, ResString(IDS_PRINTERS));
1992 /* StartMenuFolders new_folders;
1993
1994 try {
1995 new_folders.push_back(ShellPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}")));
1996 } catch(COMException&) {
1997 }
1998
1999 CreateSubmenu(id, new_folders, ResString(IDS_PRINTERS));*/
2000 break;
2001
2002 case IDC_ADMIN:
2003 #ifndef ROSSHELL
2004 CreateSubmenu(id, CSIDL_COMMON_ADMINTOOLS, CSIDL_ADMINTOOLS, ResString(IDS_ADMIN));
2005 //CloseStartMenu(id);
2006 //MainFrame::Create(SpecialFolderPath(CSIDL_COMMON_ADMINTOOLS, _hwnd), OWM_PIDL);
2007 #else
2008 launch_file(_hwnd, SpecialFolderFSPath(CSIDL_COMMON_ADMINTOOLS, _hwnd));
2009 #endif
2010 break;
2011
2012 case IDC_CONNECTIONS:
2013 #ifndef ROSSHELL
2014 #ifdef _ROS_ // to be removed when RAS will be implemented
2015 MessageBox(0, TEXT("RAS folder not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
2016 #else
2017 CreateSubmenu(id, CSIDL_CONNECTIONS, ResString(IDS_CONNECTIONS));
2018 //CloseStartMenu(id);
2019 //MainFrame::Create(SpecialFolderPath(CSIDL_CONNECTIONS, _hwnd), OWM_PIDL);
2020 #endif
2021 #else
2022 launch_file(_hwnd, SHELLPATH_NET_CONNECTIONS);
2023 #endif
2024 break;
2025
2026
2027 // browse menu
2028
2029 case IDC_NETWORK:
2030 #ifdef _ROS_ ///@todo to be removed when network browsing will be implemented in shell namespace
2031 MessageBox(0, TEXT("network not yet implemented"), ResString(IDS_TITLE), MB_OK);
2032 #else
2033 CreateSubmenu(id, CSIDL_NETWORK, ResString(IDS_NETWORK));
2034 #endif
2035 break;
2036
2037 case IDC_DRIVES:
2038 ///@todo exclude removable drives
2039 CreateSubmenu(id, CSIDL_DRIVES, ResString(IDS_DRIVES));
2040 break;
2041
2042
2043 // search menu
2044
2045 case IDC_SEARCH_PROGRAM:
2046 CloseStartMenu(id);
2047 Dialog::DoModal(IDD_SEARCH_PROGRAM, WINDOW_CREATOR(FindProgramDlg));
2048 break;
2049
2050 case IDC_SEARCH_FILES:
2051 CloseStartMenu(id);
2052 ShowSearchDialog();
2053 break;
2054
2055 case IDC_SEARCH_COMPUTER:
2056 CloseStartMenu(id);
2057 ShowSearchComputer();
2058 break;
2059
2060
2061 default:
2062 return super::Command(id, code);
2063 }
2064
2065 return 0;
2066 }
2067
2068
2069 void StartMenuHandler::ShowSearchDialog()
2070 {
2071 #ifndef _ROS_ ///@todo to be removed when SHFindFiles() will be implemented in shell32.dll
2072 static DynamicFct<SHFINDFILES> SHFindFiles(TEXT("SHELL32"), 90);
2073
2074 if (SHFindFiles)
2075 (*SHFindFiles)(NULL, NULL);
2076 else
2077 #endif
2078 MessageBox(0, TEXT("SHFindFiles() not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
2079 }
2080
2081 void StartMenuHandler::ShowSearchComputer()
2082 {
2083 #ifndef _ROS_ ///@todo to be removed when SHFindComputer() will be implemented in shell32.dll
2084 static DynamicFct<SHFINDCOMPUTER> SHFindComputer(TEXT("SHELL32"), 91);
2085
2086 if (SHFindComputer)
2087 (*SHFindComputer)(NULL, NULL);
2088 else
2089 #endif
2090 MessageBox(0, TEXT("SHFindComputer() not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
2091 }
2092
2093 void StartMenuHandler::ShowLaunchDialog(HWND hwndOwner)
2094 {
2095 ///@todo All text phrases should be put into the resources.
2096 static LPCSTR szTitle = "Run";
2097 static LPCSTR szText = "Type the name of a program, folder, document, or Internet resource, and Explorer will open it for you.";
2098
2099 static DynamicFct<RUNFILEDLG> RunFileDlg(TEXT("SHELL32"), 61);
2100
2101 // Show "Run..." dialog
2102 if (RunFileDlg) {
2103 #ifndef _ROS_ /* FIXME: our shell32 always expects Ansi strings */
2104 if ((HIWORD(GetVersion())>>14) == W_VER_NT) {
2105 WCHAR wTitle[40], wText[256];
2106
2107 MultiByteToWideChar(CP_ACP, 0, szTitle, -1, wTitle, 40);
2108 MultiByteToWideChar(CP_ACP, 0, szText, -1, wText, 256);
2109
2110 (*RunFileDlg)(hwndOwner, 0, NULL, (LPCSTR)wTitle, (LPCSTR)wText, RFF_CALCDIRECTORY);
2111 }
2112 else
2113 #endif
2114 (*RunFileDlg)(hwndOwner, 0, NULL, szTitle, szText, RFF_CALCDIRECTORY);
2115 }
2116 }
2117
2118 void StartMenuHandler::ShowLogoffDialog(HWND hwndOwner)
2119 {
2120 static DynamicFct<LOGOFFWINDOWSDIALOG> LogoffWindowsDialog(TEXT("SHELL32"), 54);
2121 // static DynamicFct<RESTARTWINDOWSDLG> RestartDialog(TEXT("SHELL32"), 59);
2122
2123 if (LogoffWindowsDialog)
2124 (*LogoffWindowsDialog)(0);
2125 /* The RestartDialog function prompts about some system setting change. This is not what we want to display here.
2126 else if (RestartDialog)
2127 return (*RestartDialog)(hwndOwner, (LPWSTR)L"You selected <Log Off>.\n\n", EWX_LOGOFF) == 1; ///@todo ANSI string conversion if needed
2128 */
2129 else
2130 MessageBox(hwndOwner, TEXT("LogoffWindowsDialog() not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
2131 }
2132
2133 void ShowExitWindowsDialog(HWND hwndOwner)
2134 {
2135 static DynamicFct<EXITWINDOWSDLG> ExitWindowsDialog(TEXT("SHELL32"), 60);
2136
2137 if (ExitWindowsDialog)
2138 (*ExitWindowsDialog)(hwndOwner);
2139 else
2140 MessageBox(hwndOwner, TEXT("ExitWindowsDialog() not yet implemented in SHELL32"), ResString(IDS_TITLE), MB_OK);
2141 }
2142
2143
2144 void SettingsMenu::AddEntries()
2145 {
2146 super::AddEntries();
2147
2148 #if defined(ROSSHELL) || defined(_ROS_) // _ROS_ to be removed when printer/network will be implemented
2149 AddButton(ResString(IDS_PRINTERS), ICID_PRINTER, false, IDC_PRINTERS_MENU);
2150 AddButton(ResString(IDS_CONNECTIONS), ICID_NETWORK, false, IDC_CONNECTIONS);
2151 #else
2152 AddButton(ResString(IDS_PRINTERS), ICID_PRINTER, true, IDC_PRINTERS_MENU);
2153 AddButton(ResString(IDS_CONNECTIONS), ICID_NETWORK, true, IDC_CONNECTIONS);
2154 #endif
2155 AddButton(ResString(IDS_ADMIN), ICID_CONFIG, true, IDC_ADMIN);
2156
2157 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
2158 if (!g_Globals._SHRestricted || !SHRestricted(REST_NOCONTROLPANEL))
2159 #endif
2160 AddButton(ResString(IDS_SETTINGS_MENU), ICID_CONFIG, true, IDC_SETTINGS_MENU);
2161
2162 AddButton(ResString(IDS_DESKTOPBAR_SETTINGS), ICID_CONFIG, false, ID_DESKTOPBAR_SETTINGS);
2163
2164 AddButton(ResString(IDS_PRINTERS), ICID_PRINTER, false, IDC_PRINTERS);
2165
2166 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
2167 if (!g_Globals._SHRestricted || !SHRestricted(REST_NOCONTROLPANEL))
2168 #endif
2169 AddButton(ResString(IDS_CONTROL_PANEL), ICID_CONFIG, false, IDC_CONTROL_PANEL);
2170 }
2171
2172 void BrowseMenu::AddEntries()
2173 {
2174 super::AddEntries();
2175
2176 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
2177 if (!g_Globals._SHRestricted || !SHRestricted(REST_NONETHOOD)) // or REST_NOENTIRENETWORK ?
2178 #endif
2179 #if defined(ROSSHELL) || defined(_ROS_) // _ROS_ to be removed when printer/network will be implemented
2180 AddButton(ResString(IDS_NETWORK), ICID_NETWORK, false, IDC_NETWORK);
2181 #else
2182 AddButton(ResString(IDS_NETWORK), ICID_NETWORK, true, IDC_NETWORK);
2183 #endif
2184
2185 AddButton(ResString(IDS_DRIVES), ICID_FOLDER, true, IDC_DRIVES);
2186 }
2187
2188 void SearchMenu::AddEntries()
2189 {
2190 super::AddEntries();
2191
2192 AddButton(ResString(IDS_SEARCH_FILES), ICID_SEARCH_DOC, false, IDC_SEARCH_FILES);
2193
2194 #ifndef __MINGW32__ // SHRestricted() missing in MinGW (as of 29.10.2003)
2195 if (!g_Globals._SHRestricted || !SHRestricted(REST_HASFINDCOMPUTERS))
2196 #endif
2197 AddButton(ResString(IDS_SEARCH_COMPUTER),ICID_COMPUTER, false, IDC_SEARCH_COMPUTER);
2198
2199 AddButton(ResString(IDS_SEARCH_PRG), ICID_APPS, false, IDC_SEARCH_PROGRAM);
2200 }
2201
2202
2203 void RecentStartMenu::AddEntries()
2204 {
2205 for(StartMenuShellDirs::iterator it=_dirs.begin(); it!=_dirs.end(); ++it) {
2206 StartMenuDirectory& smd = *it;
2207 ShellDirectory& dir = smd._dir;
2208
2209 if (!dir._scanned) {
2210 WaitCursor wait;
2211
2212 #ifdef _LAZY_ICONEXTRACT
2213 dir.smart_scan(SORT_NAME, SCAN_FILESYSTEM);
2214 #else
2215 dir.smart_scan(SORT_NAME, SCAN_EXTRACT_ICONS|SCAN_FILESYSTEM);
2216 #endif
2217 }
2218
2219 dir.sort_directory(SORT_DATE);
2220 AddShellEntries(dir, RECENT_DOCS_COUNT, smd._ignore); ///@todo read max. count of entries from registry
2221 }
2222 }
2223
2224
2225 #ifndef _SHELL32_FAVORITES
2226
2227 void FavoritesMenu::AddEntries()
2228 {
2229 super::AddEntries();
2230
2231 String lwr_filter = _create_info._filter;
2232 lwr_filter.toLower();
2233
2234 for(BookmarkList::iterator it=_bookmarks.begin(); it!=_bookmarks.end(); ++it) {
2235 BookmarkNode& node = *it;
2236
2237 int id = ++_next_id;
2238
2239 _entries[id] = node;
2240
2241 if (node._type == BookmarkNode::BMNT_FOLDER) {
2242 BookmarkFolder& folder = *node._pfolder;
2243
2244 AddButton(folder._name, ICID_FOLDER, true, id);
2245 } else if (node._type == BookmarkNode::BMNT_BOOKMARK) {
2246 Bookmark& bookmark = *node._pbookmark;
2247
2248 ICON_ID icon = ICID_NONE;
2249
2250 if (!bookmark._icon_path.empty())
2251 icon = g_Globals._icon_cache.extract(bookmark._icon_path, bookmark._icon_idx);
2252
2253 // filter non-directory entries
2254 if (!lwr_filter.empty()) {
2255 String lwr_name = bookmark._name;
2256 String lwr_desc = bookmark._description;
2257 String lwr_url = bookmark._url;
2258
2259 lwr_name.toLower();
2260 lwr_desc.toLower();
2261 lwr_url.toLower();
2262
2263 if (!_tcsstr(lwr_name,lwr_filter) && !_tcsstr(lwr_desc,lwr_filter) && !_tcsstr(lwr_url,lwr_filter))
2264 continue;
2265 }
2266
2267 AddButton(bookmark._name, icon!=ICID_NONE?icon:ICID_BOOKMARK, false, id);
2268 }
2269 }
2270 }
2271
2272 int FavoritesMenu::Command(int id, int code)
2273 {
2274 BookmarkMap::iterator found = _entries.find(id);
2275
2276 if (found != _entries.end()) {
2277 BookmarkNode& node = found->second;
2278
2279 if (node._type == BookmarkNode::BMNT_FOLDER) {
2280 BookmarkFolder& folder = *node._pfolder;
2281
2282 if (CloseOtherSubmenus(id))
2283 CreateSubmenu(id, folder._name, STARTMENU_CREATOR(FavoritesMenu), &static_cast<BookmarkList&>(folder._bookmarks));
2284 } else if (node._type == BookmarkNode::BMNT_BOOKMARK) {
2285 Bookmark& bookmark = *node._pbookmark;
2286
2287 String url = bookmark._url;
2288 HWND hparent = GetParent(_hwnd);
2289
2290 CloseStartMenu(id);
2291
2292 launch_file(hparent, url, SW_SHOWNORMAL);
2293 }
2294
2295 return 0;
2296 }
2297
2298 return super::Command(id, code);
2299 }
2300
2301 #endif