xref: /reactos/base/applications/rapps/gui.cpp (revision 4a7f3bdb) 
1 /*
2  * PROJECT:     ReactOS Applications Manager
3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4  * FILE:        base/applications/rapps/gui.cpp
5  * PURPOSE:     GUI classes for RAPPS
6  * COPYRIGHT:   Copyright 2015 David Quintana           (gigaherz@gmail.com)
7  *              Copyright 2017 Alexander Shaposhnikov   (sanchaez@reactos.org)
8  */
9 #include "rapps.h"
10 
11 #include "rapps.h"
12 #include "rosui.h"
13 #include "crichedit.h"
14 
15 #include <shlobj_undoc.h>
16 #include <shlguid_undoc.h>
17 
18 #include <atlbase.h>
19 #include <atlcom.h>
20 #include <atlwin.h>
21 #include <wininet.h>
22 #include <shellutils.h>
23 #include <rosctrls.h>
24 
25 #define SEARCH_TIMER_ID 'SR'
26 #define LISTVIEW_ICON_SIZE 24
27 #define TREEVIEW_ICON_SIZE 24
28 
29 HWND hListView = NULL;
30 
31 INT GetSystemColorDepth()
32 {
33     DEVMODEW pDevMode;
34     INT ColorDepth;
35 
36     pDevMode.dmSize = sizeof(pDevMode);
37     pDevMode.dmDriverExtra = 0;
38 
39     if (!EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &pDevMode))
40     {
41         /* TODO: Error message */
42         return ILC_COLOR;
43     }
44 
45     switch (pDevMode.dmBitsPerPel)
46     {
47     case 32: ColorDepth = ILC_COLOR32; break;
48     case 24: ColorDepth = ILC_COLOR24; break;
49     case 16: ColorDepth = ILC_COLOR16; break;
50     case  8: ColorDepth = ILC_COLOR8;  break;
51     case  4: ColorDepth = ILC_COLOR4;  break;
52     default: ColorDepth = ILC_COLOR;   break;
53     }
54 
55     return ColorDepth;
56 }
57 
58 class CAvailableAppView
59 {
60     static inline VOID InsertTextAfterLoaded_RichEdit(UINT uStringID,
61                                                       const ATL::CStringW& szText,
62                                                       DWORD StringFlags,
63                                                       DWORD TextFlags)
64     {
65         ATL::CStringW szLoadedText;
66         if (!szText.IsEmpty() && szLoadedText.LoadStringW(uStringID))
67         {
68             InsertRichEditText(szLoadedText, StringFlags);
69             InsertRichEditText(szText, TextFlags);
70         }
71     }
72 
73     static inline VOID InsertLoadedTextNewl_RichEdit(UINT uStringID,
74                                                      DWORD StringFlags)
75     {
76         ATL::CStringW szLoadedText;
77         if (szLoadedText.LoadStringW(uStringID))
78         {
79             InsertRichEditText(L"\n", 0);
80             InsertRichEditText(szLoadedText, StringFlags);
81             InsertRichEditText(L"\n", 0);
82         }
83     }
84 
85     static VOID InsertVersionInfo_RichEdit(CAvailableApplicationInfo* Info)
86     {
87         if (Info->IsInstalled())
88         {
89             if (Info->HasInstalledVersion())
90             {
91                 if (Info->HasUpdate())
92                     InsertLoadedTextNewl_RichEdit(IDS_STATUS_UPDATE_AVAILABLE, CFE_ITALIC);
93                 else
94                     InsertLoadedTextNewl_RichEdit(IDS_STATUS_INSTALLED, CFE_ITALIC);
95 
96                 InsertTextAfterLoaded_RichEdit(IDS_AINFO_VERSION, Info->m_szInstalledVersion, CFE_BOLD, 0);
97             }
98             else
99             {
100                 InsertLoadedTextNewl_RichEdit(IDS_STATUS_INSTALLED, CFE_ITALIC);
101             }
102         }
103         else
104         {
105             InsertLoadedTextNewl_RichEdit(IDS_STATUS_NOTINSTALLED, CFE_ITALIC);
106         }
107 
108         InsertTextAfterLoaded_RichEdit(IDS_AINFO_AVAILABLEVERSION, Info->m_szVersion, CFE_BOLD, 0);
109     }
110 
111     static VOID InsertLicenseInfo_RichEdit(CAvailableApplicationInfo* Info)
112     {
113         ATL::CStringW szLicense;
114         switch (Info->m_LicenseType)
115         {
116         case LICENSE_OPENSOURCE:
117             szLicense.LoadStringW(IDS_LICENSE_OPENSOURCE);
118             break;
119         case LICENSE_FREEWARE:
120             szLicense.LoadStringW(IDS_LICENSE_FREEWARE);
121             break;
122         case LICENSE_TRIAL:
123             szLicense.LoadStringW(IDS_LICENSE_TRIAL);
124             break;
125         default:
126             InsertTextAfterLoaded_RichEdit(IDS_AINFO_LICENSE, Info->m_szLicense, CFE_BOLD, 0);
127             return;
128         }
129 
130         szLicense += L" (" + Info->m_szLicense + L")";
131         InsertTextAfterLoaded_RichEdit(IDS_AINFO_LICENSE, szLicense, CFE_BOLD, 0);
132     }
133 
134     static VOID InsertLanguageInfo_RichEdit(CAvailableApplicationInfo* Info)
135     {
136         if (!Info->HasLanguageInfo())
137         {
138             return;
139         }
140 
141         const INT nTranslations = Info->m_LanguageLCIDs.GetSize();
142         ATL::CStringW szLangInfo;
143         ATL::CStringW szLoadedTextAvailability;
144         ATL::CStringW szLoadedAInfoText;
145 
146         szLoadedAInfoText.LoadStringW(IDS_AINFO_LANGUAGES);
147 
148         //TODO: replace those hardcoded strings
149         if (Info->HasNativeLanguage())
150         {
151             szLoadedTextAvailability.LoadStringW(IDS_LANGUAGE_AVAILABLE_TRANSLATION);
152             if (nTranslations > 1)
153             {
154                 ATL::CStringW buf;
155                 buf.LoadStringW(IDS_LANGUAGE_MORE_PLACEHOLDER);
156                 szLangInfo.Format(buf, nTranslations - 1);
157             }
158             else
159             {
160                 szLangInfo.LoadStringW(IDS_LANGUAGE_SINGLE);
161                 szLangInfo = L" (" + szLangInfo + L")";
162             }
163         }
164         else if (Info->HasEnglishLanguage())
165         {
166             szLoadedTextAvailability.LoadStringW(IDS_LANGUAGE_ENGLISH_TRANSLATION);
167             if (nTranslations > 1)
168             {
169                 ATL::CStringW buf;
170                 buf.LoadStringW(IDS_LANGUAGE_AVAILABLE_PLACEHOLDER);
171                 szLangInfo.Format(buf, nTranslations - 1);
172             }
173             else
174             {
175                 szLangInfo.LoadStringW(IDS_LANGUAGE_SINGLE);
176                 szLangInfo = L" (" + szLangInfo + L")";
177             }
178         }
179         else
180         {
181             szLoadedTextAvailability.LoadStringW(IDS_LANGUAGE_NO_TRANSLATION);
182         }
183 
184         InsertRichEditText(szLoadedAInfoText, CFE_BOLD);
185         InsertRichEditText(szLoadedTextAvailability, NULL);
186         InsertRichEditText(szLangInfo, CFE_ITALIC);
187     }
188 
189 public:
190     static BOOL ShowAvailableAppInfo(INT Index)
191     {
192         CAvailableApplicationInfo* Info = (CAvailableApplicationInfo*) ListViewGetlParam(Index);
193         if (!Info) return FALSE;
194 
195         NewRichEditText(Info->m_szName, CFE_BOLD);
196         InsertVersionInfo_RichEdit(Info);
197         InsertLicenseInfo_RichEdit(Info);
198         InsertLanguageInfo_RichEdit(Info);
199 
200         InsertTextAfterLoaded_RichEdit(IDS_AINFO_SIZE, Info->m_szSize, CFE_BOLD, 0);
201         InsertTextAfterLoaded_RichEdit(IDS_AINFO_URLSITE, Info->m_szUrlSite, CFE_BOLD, CFE_LINK);
202         InsertTextAfterLoaded_RichEdit(IDS_AINFO_DESCRIPTION, Info->m_szDesc, CFE_BOLD, 0);
203         InsertTextAfterLoaded_RichEdit(IDS_AINFO_URLDOWNLOAD, Info->m_szUrlDownload, CFE_BOLD, CFE_LINK);
204 
205         return TRUE;
206     }
207 };
208 
209 class CMainToolbar :
210     public CUiWindow< CToolbar<> >
211 {
212     const INT m_iToolbarHeight;
213     DWORD m_dButtonsWidthMax;
214 
215     WCHAR szInstallBtn[MAX_STR_LEN];
216     WCHAR szUninstallBtn[MAX_STR_LEN];
217     WCHAR szModifyBtn[MAX_STR_LEN];
218     WCHAR szSelectAll[MAX_STR_LEN];
219 
220     VOID AddImageToImageList(HIMAGELIST hImageList, UINT ImageIndex)
221     {
222         HICON hImage;
223 
224         if (!(hImage = (HICON) LoadImageW(hInst,
225                                           MAKEINTRESOURCE(ImageIndex),
226                                           IMAGE_ICON,
227                                           m_iToolbarHeight,
228                                           m_iToolbarHeight,
229                                           0)))
230         {
231             /* TODO: Error message */
232         }
233 
234         ImageList_AddIcon(hImageList, hImage);
235         DeleteObject(hImage);
236     }
237 
238     HIMAGELIST InitImageList()
239     {
240         HIMAGELIST hImageList;
241 
242         /* Create the toolbar icon image list */
243         hImageList = ImageList_Create(m_iToolbarHeight,//GetSystemMetrics(SM_CXSMICON),
244                                       m_iToolbarHeight,//GetSystemMetrics(SM_CYSMICON),
245                                       ILC_MASK | GetSystemColorDepth(),
246                                       1, 1);
247         if (!hImageList)
248         {
249             /* TODO: Error message */
250             return NULL;
251         }
252 
253         AddImageToImageList(hImageList, IDI_INSTALL);
254         AddImageToImageList(hImageList, IDI_UNINSTALL);
255         AddImageToImageList(hImageList, IDI_MODIFY);
256         AddImageToImageList(hImageList, IDI_CHECK_ALL);
257         AddImageToImageList(hImageList, IDI_REFRESH);
258         AddImageToImageList(hImageList, IDI_UPDATE_DB);
259         AddImageToImageList(hImageList, IDI_SETTINGS);
260         AddImageToImageList(hImageList, IDI_EXIT);
261 
262         return hImageList;
263     }
264 
265 public:
266     CMainToolbar() : m_iToolbarHeight(24)
267     {
268     }
269 
270     VOID OnGetDispInfo(LPTOOLTIPTEXT lpttt)
271     {
272         UINT idButton = (UINT) lpttt->hdr.idFrom;
273 
274         switch (idButton)
275         {
276         case ID_EXIT:
277             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_EXIT);
278             break;
279 
280         case ID_INSTALL:
281             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_INSTALL);
282             break;
283 
284         case ID_UNINSTALL:
285             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_UNINSTALL);
286             break;
287 
288         case ID_MODIFY:
289             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_MODIFY);
290             break;
291 
292         case ID_SETTINGS:
293             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_SETTINGS);
294             break;
295 
296         case ID_REFRESH:
297             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_REFRESH);
298             break;
299 
300         case ID_RESETDB:
301             lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_UPDATE_DB);
302             break;
303         }
304     }
305 
306     HWND Create(HWND hwndParent)
307     {
308         /* Create buttons */
309         TBBUTTON Buttons[] =
310         {   /* iBitmap, idCommand, fsState, fsStyle, bReserved[2], dwData, iString */
311             {  0, ID_INSTALL,   TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, (INT_PTR) szInstallBtn      },
312             {  1, ID_UNINSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, (INT_PTR) szUninstallBtn    },
313             {  2, ID_MODIFY,    TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, (INT_PTR) szModifyBtn       },
314             {  3, ID_CHECK_ALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, (INT_PTR) szSelectAll       },
315             { -1, 0,            TBSTATE_ENABLED, BTNS_SEP,                    { 0 }, 0, 0                           },
316             {  4, ID_REFRESH,   TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, 0                           },
317             {  5, ID_RESETDB,   TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, 0                           },
318             { -1, 0,            TBSTATE_ENABLED, BTNS_SEP,                    { 0 }, 0, 0                           },
319             {  6, ID_SETTINGS,  TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, 0                           },
320             {  7, ID_EXIT,      TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, { 0 }, 0, 0                           },
321         };
322 
323         LoadStringW(hInst, IDS_INSTALL, szInstallBtn, _countof(szInstallBtn));
324         LoadStringW(hInst, IDS_UNINSTALL, szUninstallBtn, _countof(szUninstallBtn));
325         LoadStringW(hInst, IDS_MODIFY, szModifyBtn, _countof(szModifyBtn));
326         LoadStringW(hInst, IDS_SELECT_ALL, szSelectAll, _countof(szSelectAll));
327 
328         m_hWnd = CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL,
329                                  WS_CHILD | WS_VISIBLE | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | TBSTYLE_LIST,
330                                  0, 0, 0, 0,
331                                  hwndParent,
332                                  0, hInst, NULL);
333 
334         if (!m_hWnd)
335         {
336             /* TODO: Show error message */
337             return FALSE;
338         }
339 
340         SendMessageW(TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_HIDECLIPPEDBUTTONS);
341         SetButtonStructSize();
342 
343         /* Set image list */
344         HIMAGELIST hImageList = InitImageList();
345 
346         if (!hImageList)
347         {
348             /* TODO: Show error message */
349             return FALSE;
350         }
351 
352         ImageList_Destroy((HIMAGELIST) SetImageList(hImageList));
353 
354         AddButtons(_countof(Buttons), Buttons);
355 
356         /* Remember ideal width to use as a max width of buttons */
357         SIZE size;
358         GetIdealSize(FALSE, &size);
359         m_dButtonsWidthMax = size.cx;
360 
361         return m_hWnd;
362     }
363 
364     VOID HideButtonCaption()
365     {
366         DWORD dCurrentExStyle = (DWORD) SendMessageW(TB_GETEXTENDEDSTYLE, 0, 0);
367         SendMessageW(TB_SETEXTENDEDSTYLE, 0, dCurrentExStyle | TBSTYLE_EX_MIXEDBUTTONS);
368     }
369 
370     VOID ShowButtonCaption()
371     {
372         DWORD dCurrentExStyle = (DWORD) SendMessageW(TB_GETEXTENDEDSTYLE, 0, 0);
373         SendMessageW(TB_SETEXTENDEDSTYLE, 0, dCurrentExStyle & ~TBSTYLE_EX_MIXEDBUTTONS);
374     }
375 
376     DWORD GetMaxButtonsWidth() const
377     {
378         return m_dButtonsWidthMax;
379     }
380 };
381 
382 class CAppsListView :
383     public CUiWindow<CListView>
384 {
385     struct SortContext
386     {
387         CAppsListView * lvw;
388         INT iSubItem;
389     };
390 
391     BOOL bHasAllChecked;
392     BOOL bAscending;
393     BOOL bHasCheckboxes;
394 
395 public:
396     CAppsListView() :
397         bHasAllChecked(FALSE),
398         bAscending(TRUE),
399         bHasCheckboxes(FALSE)
400     {
401     }
402 
403     VOID SetCheckboxesVisible(BOOL bIsVisible)
404     {
405         if (bIsVisible)
406         {
407             SetExtendedListViewStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT);
408         }
409         else
410         {
411             SetExtendedListViewStyle(LVS_EX_FULLROWSELECT);
412         }
413 
414         bHasCheckboxes = bIsVisible;
415     }
416 
417     VOID ColumnClick(LPNMLISTVIEW pnmv)
418     {
419         SortContext ctx = {this, pnmv->iSubItem};
420 
421         SortItems(s_CompareFunc, &ctx);
422 
423         bAscending = !bAscending;
424     }
425 
426     PVOID GetLParam(INT Index)
427     {
428         INT ItemIndex;
429         LVITEMW Item;
430 
431         if (Index == -1)
432         {
433             ItemIndex = (INT) SendMessage(LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
434             if (ItemIndex == -1)
435                 return NULL;
436         }
437         else
438         {
439             ItemIndex = Index;
440         }
441 
442         ZeroMemory(&Item, sizeof(Item));
443 
444         Item.mask = LVIF_PARAM;
445         Item.iItem = ItemIndex;
446         if (!GetItem(&Item))
447             return NULL;
448 
449         return (PVOID) Item.lParam;
450     }
451 
452     BOOL AddColumn(INT Index, ATL::CStringW& Text, INT Width, INT Format)
453     {
454         return AddColumn(Index, const_cast<LPWSTR>(Text.GetString()), Width, Format);
455     }
456 
457     BOOL AddColumn(INT Index, LPWSTR lpText, INT Width, INT Format)
458     {
459         LVCOLUMNW Column;
460 
461         ZeroMemory(&Column, sizeof(Column));
462 
463         Column.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
464         Column.iSubItem = Index;
465         Column.pszText = lpText;
466         Column.cx = Width;
467         Column.fmt = Format;
468 
469         return (InsertColumn(Index, &Column) == -1) ? FALSE : TRUE;
470     }
471 
472     INT AddItem(INT ItemIndex, INT IconIndex, LPWSTR lpText, LPARAM lParam)
473     {
474         LVITEMW Item;
475 
476         ZeroMemory(&Item, sizeof(Item));
477 
478         Item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
479         Item.pszText = lpText;
480         Item.lParam = lParam;
481         Item.iItem = ItemIndex;
482         Item.iImage = IconIndex;
483 
484         return InsertItem(&Item);
485     }
486 
487     static INT CALLBACK s_CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
488     {
489         SortContext * ctx = ((SortContext*) lParamSort);
490         return ctx->lvw->CompareFunc(lParam1, lParam2, ctx->iSubItem);
491     }
492 
493     INT CompareFunc(LPARAM lParam1, LPARAM lParam2, INT iSubItem)
494     {
495         ATL::CStringW Item1, Item2;
496         LVFINDINFOW IndexInfo;
497         INT Index;
498 
499         IndexInfo.flags = LVFI_PARAM;
500 
501         IndexInfo.lParam = lParam1;
502         Index = FindItem(-1, &IndexInfo);
503         GetItemText(Index, iSubItem, Item1.GetBuffer(MAX_STR_LEN), MAX_STR_LEN);
504         Item1.ReleaseBuffer();
505 
506         IndexInfo.lParam = lParam2;
507         Index = FindItem(-1, &IndexInfo);
508         GetItemText(Index, iSubItem, Item2.GetBuffer(MAX_STR_LEN), MAX_STR_LEN);
509         Item2.ReleaseBuffer();
510 
511         if (bAscending)
512             return Item2 == Item1;
513         else
514             return Item1 == Item2;
515 
516         return 0;
517     }
518 
519     HWND Create(HWND hwndParent)
520     {
521         RECT r = {205, 28, 465, 250};
522         DWORD style = WS_CHILD | WS_VISIBLE | LVS_SORTASCENDING | LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS;
523         HMENU menu = GetSubMenu(LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_APPLICATIONMENU)), 0);
524 
525         HWND hwnd = CListView::Create(hwndParent, r, NULL, style, WS_EX_CLIENTEDGE, menu);
526 
527         if (hwnd)
528         {
529             SetCheckboxesVisible(FALSE);
530         }
531 
532         return hwnd;
533     }
534 
535     BOOL GetCheckState(INT item)
536     {
537         return (BOOL) (GetItemState(item, LVIS_STATEIMAGEMASK) >> 12) - 1;
538     }
539 
540     VOID SetCheckState(INT item, BOOL fCheck)
541     {
542         if (bHasCheckboxes)
543         {
544             SetItemState(item, INDEXTOSTATEIMAGEMASK((fCheck) ? 2 : 1), LVIS_STATEIMAGEMASK);
545             SetSelected(item, fCheck);
546         }
547     }
548 
549     VOID SetSelected(INT item, BOOL value)
550     {
551         if (item < 0)
552         {
553             for (INT i = 0; i >= 0; i = GetNextItem(i, LVNI_ALL))
554             {
555                 CAvailableApplicationInfo* pAppInfo = (CAvailableApplicationInfo*) GetItemData(i);
556                 if (pAppInfo)
557                 {
558                     pAppInfo->m_IsSelected = value;
559                 }
560             }
561         }
562         else
563         {
564             CAvailableApplicationInfo* pAppInfo = (CAvailableApplicationInfo*) GetItemData(item);
565             if (pAppInfo)
566             {
567                 pAppInfo->m_IsSelected = value;
568             }
569         }
570     }
571 
572     VOID CheckAll()
573     {
574         if (bHasCheckboxes)
575         {
576             bHasAllChecked = !bHasAllChecked;
577             SetCheckState(-1, bHasAllChecked);
578         }
579     }
580 
581     ATL::CSimpleArray<CAvailableApplicationInfo> GetCheckedItems()
582     {
583         if (!bHasCheckboxes)
584         {
585             return ATL::CSimpleArray<CAvailableApplicationInfo>();
586         }
587 
588         ATL::CSimpleArray<CAvailableApplicationInfo> list;
589         for (INT i = 0; i >= 0; i = GetNextItem(i, LVNI_ALL))
590         {
591             if (GetCheckState(i) != FALSE)
592             {
593                 CAvailableApplicationInfo* pAppInfo = (CAvailableApplicationInfo*) GetItemData(i);
594                 list.Add(*pAppInfo);
595             }
596         }
597         return list;
598     }
599 
600     CAvailableApplicationInfo* GetSelectedData()
601     {
602         INT item = GetSelectionMark();
603         return (CAvailableApplicationInfo*) GetItemData(item);
604     }
605 };
606 
607 class CSideTreeView :
608     public CUiWindow<CTreeView>
609 {
610     HIMAGELIST hImageTreeView;
611 
612 public:
613     CSideTreeView() :
614         CUiWindow(),
615         hImageTreeView(ImageList_Create(TREEVIEW_ICON_SIZE, TREEVIEW_ICON_SIZE,
616                                         GetSystemColorDepth() | ILC_MASK,
617                                         0, 1))
618     {
619     }
620 
621     HTREEITEM AddItem(HTREEITEM hParent, ATL::CStringW &Text, INT Image, INT SelectedImage, LPARAM lParam)
622     {
623         return CUiWindow<CTreeView>::AddItem(hParent, const_cast<LPWSTR>(Text.GetString()), Image, SelectedImage, lParam);
624     }
625 
626     HTREEITEM AddCategory(HTREEITEM hRootItem, UINT TextIndex, UINT IconIndex)
627     {
628         ATL::CStringW szText;
629         INT Index;
630         HICON hIcon;
631 
632         hIcon = (HICON) LoadImageW(hInst,
633                                    MAKEINTRESOURCE(IconIndex),
634                                    IMAGE_ICON,
635                                    TREEVIEW_ICON_SIZE,
636                                    TREEVIEW_ICON_SIZE,
637                                    LR_CREATEDIBSECTION);
638         if (hIcon)
639         {
640             Index = ImageList_AddIcon(hImageTreeView, hIcon);
641             DestroyIcon(hIcon);
642         }
643 
644         szText.LoadStringW(TextIndex);
645         return AddItem(hRootItem, szText, Index, Index, TextIndex);
646     }
647 
648     HIMAGELIST SetImageList()
649     {
650         return CUiWindow<CTreeView>::SetImageList(hImageTreeView, TVSIL_NORMAL);
651     }
652 
653     VOID DestroyImageList()
654     {
655         if (hImageTreeView)
656             ImageList_Destroy(hImageTreeView);
657     }
658 
659     ~CSideTreeView()
660     {
661         DestroyImageList();
662     }
663 };
664 
665 class CSearchBar :
666     public CWindow
667 {
668 public:
669     const INT m_Width;
670     const INT m_Height;
671 
672     CSearchBar() : m_Width(200), m_Height(22)
673     {
674     }
675 
676     VOID SetText(LPCWSTR lpszText)
677     {
678         SendMessageW(SB_SETTEXT, SBT_NOBORDERS, (LPARAM) lpszText);
679     }
680 
681     HWND Create(HWND hwndParent)
682     {
683         ATL::CStringW szBuf;
684         m_hWnd = CreateWindowExW(WS_EX_CLIENTEDGE, L"Edit", NULL,
685                                  WS_CHILD | WS_VISIBLE | ES_LEFT | ES_AUTOHSCROLL,
686                                  0, 0, m_Width, m_Height,
687                                  hwndParent, (HMENU) NULL,
688                                  hInst, 0);
689 
690         SendMessageW(WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0);
691         szBuf.LoadStringW(IDS_SEARCH_TEXT);
692         SetWindowTextW(szBuf);
693         return m_hWnd;
694     }
695 
696 };
697 
698 class CMainWindow :
699     public CWindowImpl<CMainWindow, CWindow, CFrameWinTraits>
700 {
701     CUiPanel* m_ClientPanel;
702     CUiSplitPanel* m_VSplitter;
703     CUiSplitPanel* m_HSplitter;
704 
705     CMainToolbar* m_Toolbar;
706     CAppsListView* m_ListView;
707 
708     CSideTreeView* m_TreeView;
709     CUiWindow<CStatusBar>* m_StatusBar;
710     CUiWindow<CRichEdit>* m_RichEdit;
711 
712     CUiWindow<CSearchBar>* m_SearchBar;
713     CAvailableApps m_AvailableApps;
714 
715     LPWSTR pLink;
716 
717     INT nSelectedApps;
718 
719     BOOL bSearchEnabled;
720     BOOL bUpdating;
721 
722 public:
723     CMainWindow() :
724         m_ClientPanel(NULL),
725         pLink(NULL),
726         bSearchEnabled(FALSE)
727     {
728     }
729 
730 private:
731     VOID InitApplicationsList()
732     {
733         ATL::CStringW szText;
734 
735         /* Add columns to ListView */
736         szText.LoadStringW(IDS_APP_NAME);
737         m_ListView->AddColumn(0, szText, 250, LVCFMT_LEFT);
738 
739         szText.LoadStringW(IDS_APP_INST_VERSION);
740         m_ListView->AddColumn(1, szText, 90, LVCFMT_RIGHT);
741 
742         szText.LoadStringW(IDS_APP_DESCRIPTION);
743         m_ListView->AddColumn(3, szText, 300, LVCFMT_LEFT);
744 
745         // Unnesesary since the list updates on every TreeView selection
746         // UpdateApplicationsList(ENUM_ALL_COMPONENTS);
747     }
748 
749     HTREEITEM AddCategory(HTREEITEM hRootItem, UINT TextIndex, UINT IconIndex)
750     {
751         return m_TreeView->AddCategory(hRootItem, TextIndex, IconIndex);
752     }
753 
754     VOID InitCategoriesList()
755     {
756         HTREEITEM hRootItemInstalled, hRootItemAvailable;
757 
758         hRootItemInstalled = AddCategory(TVI_ROOT, IDS_INSTALLED, IDI_CATEGORY);
759         AddCategory(hRootItemInstalled, IDS_APPLICATIONS, IDI_APPS);
760         AddCategory(hRootItemInstalled, IDS_UPDATES, IDI_APPUPD);
761 
762         AddCategory(TVI_ROOT, IDS_SELECTEDFORINST, IDI_SELECTEDFORINST);
763 
764         hRootItemAvailable = AddCategory(TVI_ROOT, IDS_AVAILABLEFORINST, IDI_CATEGORY);
765         AddCategory(hRootItemAvailable, IDS_CAT_AUDIO, IDI_CAT_AUDIO);
766         AddCategory(hRootItemAvailable, IDS_CAT_VIDEO, IDI_CAT_VIDEO);
767         AddCategory(hRootItemAvailable, IDS_CAT_GRAPHICS, IDI_CAT_GRAPHICS);
768         AddCategory(hRootItemAvailable, IDS_CAT_GAMES, IDI_CAT_GAMES);
769         AddCategory(hRootItemAvailable, IDS_CAT_INTERNET, IDI_CAT_INTERNET);
770         AddCategory(hRootItemAvailable, IDS_CAT_OFFICE, IDI_CAT_OFFICE);
771         AddCategory(hRootItemAvailable, IDS_CAT_DEVEL, IDI_CAT_DEVEL);
772         AddCategory(hRootItemAvailable, IDS_CAT_EDU, IDI_CAT_EDU);
773         AddCategory(hRootItemAvailable, IDS_CAT_ENGINEER, IDI_CAT_ENGINEER);
774         AddCategory(hRootItemAvailable, IDS_CAT_FINANCE, IDI_CAT_FINANCE);
775         AddCategory(hRootItemAvailable, IDS_CAT_SCIENCE, IDI_CAT_SCIENCE);
776         AddCategory(hRootItemAvailable, IDS_CAT_TOOLS, IDI_CAT_TOOLS);
777         AddCategory(hRootItemAvailable, IDS_CAT_DRIVERS, IDI_CAT_DRIVERS);
778         AddCategory(hRootItemAvailable, IDS_CAT_LIBS, IDI_CAT_LIBS);
779         AddCategory(hRootItemAvailable, IDS_CAT_OTHER, IDI_CAT_OTHER);
780 
781         m_TreeView->SetImageList();
782         m_TreeView->Expand(hRootItemInstalled, TVE_EXPAND);
783         m_TreeView->Expand(hRootItemAvailable, TVE_EXPAND);
784         m_TreeView->SelectItem(hRootItemAvailable);
785     }
786 
787     BOOL CreateStatusBar()
788     {
789         m_StatusBar = new CUiWindow<CStatusBar>();
790         m_StatusBar->m_VerticalAlignment = UiAlign_RightBtm;
791         m_StatusBar->m_HorizontalAlignment = UiAlign_Stretch;
792         m_ClientPanel->Children().Append(m_StatusBar);
793 
794         return m_StatusBar->Create(m_hWnd, (HMENU) IDC_STATUSBAR) != NULL;
795     }
796 
797     BOOL CreateToolbar()
798     {
799         m_Toolbar = new CMainToolbar();
800         m_Toolbar->m_VerticalAlignment = UiAlign_LeftTop;
801         m_Toolbar->m_HorizontalAlignment = UiAlign_Stretch;
802         m_ClientPanel->Children().Append(m_Toolbar);
803 
804         return m_Toolbar->Create(m_hWnd) != NULL;
805     }
806 
807     BOOL CreateTreeView()
808     {
809         m_TreeView = new CSideTreeView();
810         m_TreeView->m_VerticalAlignment = UiAlign_Stretch;
811         m_TreeView->m_HorizontalAlignment = UiAlign_Stretch;
812         m_VSplitter->First().Append(m_TreeView);
813 
814         return m_TreeView->Create(m_hWnd) != NULL;
815     }
816 
817     BOOL CreateListView()
818     {
819         m_ListView = new CAppsListView();
820         m_ListView->m_VerticalAlignment = UiAlign_Stretch;
821         m_ListView->m_HorizontalAlignment = UiAlign_Stretch;
822         m_HSplitter->First().Append(m_ListView);
823 
824         hListView = m_ListView->Create(m_hWnd);
825         return hListView != NULL;
826     }
827 
828     BOOL CreateRichEdit()
829     {
830         m_RichEdit = new CUiWindow<CRichEdit>();
831         m_RichEdit->m_VerticalAlignment = UiAlign_Stretch;
832         m_RichEdit->m_HorizontalAlignment = UiAlign_Stretch;
833         m_HSplitter->Second().Append(m_RichEdit);
834 
835         return m_RichEdit->Create(m_hWnd) != NULL;
836     }
837 
838     BOOL CreateVSplitter()
839     {
840         m_VSplitter = new CUiSplitPanel();
841         m_VSplitter->m_VerticalAlignment = UiAlign_Stretch;
842         m_VSplitter->m_HorizontalAlignment = UiAlign_Stretch;
843         m_VSplitter->m_DynamicFirst = FALSE;
844         m_VSplitter->m_Horizontal = FALSE;
845         m_VSplitter->m_MinFirst = 0;
846         m_VSplitter->m_MinSecond = 320;
847         m_VSplitter->m_Pos = 240;
848         m_ClientPanel->Children().Append(m_VSplitter);
849 
850         return m_VSplitter->Create(m_hWnd) != NULL;
851     }
852 
853     BOOL CreateHSplitter()
854     {
855         m_HSplitter = new CUiSplitPanel();
856         m_HSplitter->m_VerticalAlignment = UiAlign_Stretch;
857         m_HSplitter->m_HorizontalAlignment = UiAlign_Stretch;
858         m_HSplitter->m_DynamicFirst = TRUE;
859         m_HSplitter->m_Horizontal = TRUE;
860         m_HSplitter->m_Pos = INT_MAX; //set INT_MAX to use lowest possible position (m_MinSecond)
861         m_HSplitter->m_MinFirst = 10;
862         m_HSplitter->m_MinSecond = 140;
863         m_VSplitter->Second().Append(m_HSplitter);
864 
865         return m_HSplitter->Create(m_hWnd) != NULL;
866     }
867 
868     BOOL CreateSearchBar()
869     {
870         m_SearchBar = new CUiWindow<CSearchBar>();
871         m_SearchBar->m_VerticalAlignment = UiAlign_LeftTop;
872         m_SearchBar->m_HorizontalAlignment = UiAlign_RightBtm;
873         m_SearchBar->m_Margin.top = 4;
874         m_SearchBar->m_Margin.right = 6;
875 
876         return m_SearchBar->Create(m_Toolbar->m_hWnd) != NULL;
877     }
878 
879     BOOL CreateLayout()
880     {
881         BOOL b = TRUE;
882         bUpdating = TRUE;
883 
884         m_ClientPanel = new CUiPanel();
885         m_ClientPanel->m_VerticalAlignment = UiAlign_Stretch;
886         m_ClientPanel->m_HorizontalAlignment = UiAlign_Stretch;
887 
888         // Top level
889         b = b && CreateStatusBar();
890         b = b && CreateToolbar();
891         b = b && CreateSearchBar();
892         b = b && CreateVSplitter();
893 
894         // Inside V Splitter
895         b = b && CreateHSplitter();
896         b = b && CreateTreeView();
897 
898         // Inside H Splitter
899         b = b && CreateListView();
900         b = b && CreateRichEdit();
901 
902         if (b)
903         {
904             RECT rTop;
905             RECT rBottom;
906 
907             /* Size status bar */
908             m_StatusBar->SendMessageW(WM_SIZE, 0, 0);
909 
910             /* Size tool bar */
911             m_Toolbar->AutoSize();
912 
913             ::GetWindowRect(m_Toolbar->m_hWnd, &rTop);
914             ::GetWindowRect(m_StatusBar->m_hWnd, &rBottom);
915 
916             m_VSplitter->m_Margin.top = rTop.bottom - rTop.top;
917             m_VSplitter->m_Margin.bottom = rBottom.bottom - rBottom.top;
918         }
919 
920         bUpdating = FALSE;
921         return b;
922     }
923 
924     BOOL InitControls()
925     {
926         if (CreateLayout())
927         {
928 
929             InitApplicationsList();
930             InitCategoriesList();
931 
932             nSelectedApps = 0;
933             UpdateStatusBarText();
934 
935             return TRUE;
936         }
937 
938         return FALSE;
939     }
940 
941     VOID OnSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
942     {
943 
944         /* Size status bar */
945         m_StatusBar->SendMessage(WM_SIZE, 0, 0);
946 
947         /* Size tool bar */
948         m_Toolbar->AutoSize();
949 
950         /* Automatically hide captions */
951         DWORD dToolbarTreshold = m_Toolbar->GetMaxButtonsWidth();
952         DWORD dSearchbarMargin = (LOWORD(lParam) - m_SearchBar->m_Width);
953 
954         if (dSearchbarMargin > dToolbarTreshold)
955         {
956             m_Toolbar->ShowButtonCaption();
957         }
958         else if (dSearchbarMargin < dToolbarTreshold)
959         {
960             m_Toolbar->HideButtonCaption();
961         }
962 
963         RECT r = {0, 0, LOWORD(lParam), HIWORD(lParam)};
964         HDWP hdwp = NULL;
965         INT count = m_ClientPanel->CountSizableChildren();
966 
967         hdwp = BeginDeferWindowPos(count);
968         if (hdwp)
969         {
970             hdwp = m_ClientPanel->OnParentSize(r, hdwp);
971             if (hdwp)
972             {
973                 EndDeferWindowPos(hdwp);
974             }
975 
976         }
977 
978         // TODO: Sub-layouts for children of children
979         count = m_SearchBar->CountSizableChildren();
980         hdwp = BeginDeferWindowPos(count);
981         if (hdwp)
982         {
983             hdwp = m_SearchBar->OnParentSize(r, hdwp);
984             if (hdwp)
985             {
986                 EndDeferWindowPos(hdwp);
987             }
988         }
989 
990     }
991 
992     BOOL ProcessWindowMessage(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT& theResult, DWORD dwMapId)
993     {
994         theResult = 0;
995         switch (Msg)
996         {
997         case WM_CREATE:
998             if (!InitControls())
999                 ::PostMessageW(hwnd, WM_CLOSE, 0, 0);
1000             break;
1001 
1002         case WM_DESTROY:
1003         {
1004             ShowWindow(SW_HIDE);
1005             SaveSettings(hwnd);
1006 
1007             FreeLogs();
1008             m_AvailableApps.FreeCachedEntries();
1009 
1010             if (IsInstalledEnum(SelectedEnumType))
1011                 FreeInstalledAppList();
1012 
1013             delete m_ClientPanel;
1014 
1015             PostQuitMessage(0);
1016             return 0;
1017         }
1018 
1019         case WM_COMMAND:
1020             OnCommand(wParam, lParam);
1021             break;
1022 
1023         case WM_NOTIFY:
1024         {
1025             LPNMHDR data = (LPNMHDR) lParam;
1026 
1027             switch (data->code)
1028             {
1029             case TVN_SELCHANGED:
1030             {
1031                 if (data->hwndFrom == m_TreeView->m_hWnd)
1032                 {
1033                     switch (((LPNMTREEVIEW) lParam)->itemNew.lParam)
1034                     {
1035                     case IDS_INSTALLED:
1036                         UpdateApplicationsList(ENUM_ALL_INSTALLED);
1037                         break;
1038 
1039                     case IDS_APPLICATIONS:
1040                         UpdateApplicationsList(ENUM_INSTALLED_APPLICATIONS);
1041                         break;
1042 
1043                     case IDS_UPDATES:
1044                         UpdateApplicationsList(ENUM_UPDATES);
1045                         break;
1046 
1047                     case IDS_AVAILABLEFORINST:
1048                         UpdateApplicationsList(ENUM_ALL_AVAILABLE);
1049                         break;
1050 
1051                     case IDS_CAT_AUDIO:
1052                         UpdateApplicationsList(ENUM_CAT_AUDIO);
1053                         break;
1054 
1055                     case IDS_CAT_DEVEL:
1056                         UpdateApplicationsList(ENUM_CAT_DEVEL);
1057                         break;
1058 
1059                     case IDS_CAT_DRIVERS:
1060                         UpdateApplicationsList(ENUM_CAT_DRIVERS);
1061                         break;
1062 
1063                     case IDS_CAT_EDU:
1064                         UpdateApplicationsList(ENUM_CAT_EDU);
1065                         break;
1066 
1067                     case IDS_CAT_ENGINEER:
1068                         UpdateApplicationsList(ENUM_CAT_ENGINEER);
1069                         break;
1070 
1071                     case IDS_CAT_FINANCE:
1072                         UpdateApplicationsList(ENUM_CAT_FINANCE);
1073                         break;
1074 
1075                     case IDS_CAT_GAMES:
1076                         UpdateApplicationsList(ENUM_CAT_GAMES);
1077                         break;
1078 
1079                     case IDS_CAT_GRAPHICS:
1080                         UpdateApplicationsList(ENUM_CAT_GRAPHICS);
1081                         break;
1082 
1083                     case IDS_CAT_INTERNET:
1084                         UpdateApplicationsList(ENUM_CAT_INTERNET);
1085                         break;
1086 
1087                     case IDS_CAT_LIBS:
1088                         UpdateApplicationsList(ENUM_CAT_LIBS);
1089                         break;
1090 
1091                     case IDS_CAT_OFFICE:
1092                         UpdateApplicationsList(ENUM_CAT_OFFICE);
1093                         break;
1094 
1095                     case IDS_CAT_OTHER:
1096                         UpdateApplicationsList(ENUM_CAT_OTHER);
1097                         break;
1098 
1099                     case IDS_CAT_SCIENCE:
1100                         UpdateApplicationsList(ENUM_CAT_SCIENCE);
1101                         break;
1102 
1103                     case IDS_CAT_TOOLS:
1104                         UpdateApplicationsList(ENUM_CAT_TOOLS);
1105                         break;
1106 
1107                     case IDS_CAT_VIDEO:
1108                         UpdateApplicationsList(ENUM_CAT_VIDEO);
1109                         break;
1110 
1111                     case IDS_SELECTEDFORINST:
1112                         UpdateApplicationsList(ENUM_CAT_SELECTED);
1113                         break;
1114                     }
1115                 }
1116 
1117                 HMENU mainMenu = ::GetMenu(hwnd);
1118                 HMENU lvwMenu = ::GetMenu(m_ListView->m_hWnd);
1119 
1120                 /* Disable/enable items based on treeview selection */
1121                 if (IsSelectedNodeInstalled())
1122                 {
1123                     EnableMenuItem(mainMenu, ID_REGREMOVE, MF_ENABLED);
1124                     EnableMenuItem(mainMenu, ID_INSTALL, MF_GRAYED);
1125                     EnableMenuItem(mainMenu, ID_UNINSTALL, MF_ENABLED);
1126                     EnableMenuItem(mainMenu, ID_MODIFY, MF_ENABLED);
1127 
1128                     EnableMenuItem(lvwMenu, ID_REGREMOVE, MF_ENABLED);
1129                     EnableMenuItem(lvwMenu, ID_INSTALL, MF_GRAYED);
1130                     EnableMenuItem(lvwMenu, ID_UNINSTALL, MF_ENABLED);
1131                     EnableMenuItem(lvwMenu, ID_MODIFY, MF_ENABLED);
1132 
1133                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_REGREMOVE, TRUE);
1134                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_INSTALL, FALSE);
1135                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_UNINSTALL, TRUE);
1136                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_MODIFY, TRUE);
1137                 }
1138                 else
1139                 {
1140                     EnableMenuItem(mainMenu, ID_REGREMOVE, MF_GRAYED);
1141                     EnableMenuItem(mainMenu, ID_INSTALL, MF_ENABLED);
1142                     EnableMenuItem(mainMenu, ID_UNINSTALL, MF_GRAYED);
1143                     EnableMenuItem(mainMenu, ID_MODIFY, MF_GRAYED);
1144 
1145                     EnableMenuItem(lvwMenu, ID_REGREMOVE, MF_GRAYED);
1146                     EnableMenuItem(lvwMenu, ID_INSTALL, MF_ENABLED);
1147                     EnableMenuItem(lvwMenu, ID_UNINSTALL, MF_GRAYED);
1148                     EnableMenuItem(lvwMenu, ID_MODIFY, MF_GRAYED);
1149 
1150                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_REGREMOVE, FALSE);
1151                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_INSTALL, TRUE);
1152                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_UNINSTALL, FALSE);
1153                     m_Toolbar->SendMessageW(TB_ENABLEBUTTON, ID_MODIFY, FALSE);
1154                 }
1155             }
1156             break;
1157 
1158             case LVN_ITEMCHANGED:
1159             {
1160                 LPNMLISTVIEW pnic = (LPNMLISTVIEW) lParam;
1161 
1162                 if (pnic->hdr.hwndFrom == m_ListView->m_hWnd)
1163                 {
1164                     /* Check if this is a valid item
1165                     * (technically, it can be also an unselect) */
1166                     INT ItemIndex = pnic->iItem;
1167                     if (ItemIndex == -1 ||
1168                         ItemIndex >= ListView_GetItemCount(pnic->hdr.hwndFrom))
1169                     {
1170                         break;
1171                     }
1172 
1173                     /* Check if the focus has been moved to another item */
1174                     if ((pnic->uChanged & LVIF_STATE) &&
1175                         (pnic->uNewState & LVIS_FOCUSED) &&
1176                         !(pnic->uOldState & LVIS_FOCUSED))
1177                     {
1178                         if (IsInstalledEnum(SelectedEnumType))
1179                             ShowInstalledAppInfo(ItemIndex);
1180                         if (IsAvailableEnum(SelectedEnumType))
1181                             CAvailableAppView::ShowAvailableAppInfo(ItemIndex);
1182                     }
1183                     /* Check if the item is checked */
1184                     if ((pnic->uNewState & LVIS_STATEIMAGEMASK) && !bUpdating)
1185                     {
1186                         BOOL checked = m_ListView->GetCheckState(pnic->iItem);
1187                         /* FIXME: HAX!
1188                         - preventing decremention below zero as a safeguard for ReactOS
1189                           In ReactOS this action is triggered whenever user changes *selection*, but should be only when *checkbox* state toggled
1190                           Maybe LVIS_STATEIMAGEMASK is set incorrectly
1191                         */
1192                         nSelectedApps +=
1193                             (checked)
1194                             ? 1
1195                             : ((nSelectedApps > 0)
1196                                ? -1
1197                                : 0);
1198 
1199                         /* Update item's selection status */
1200                         m_ListView->SetSelected(pnic->iItem, checked);
1201 
1202                         UpdateStatusBarText();
1203                     }
1204                 }
1205             }
1206             break;
1207 
1208             case LVN_COLUMNCLICK:
1209             {
1210                 LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
1211 
1212                 m_ListView->ColumnClick(pnmv);
1213             }
1214             break;
1215 
1216             case NM_CLICK:
1217             {
1218                 if (data->hwndFrom == m_ListView->m_hWnd && ((LPNMLISTVIEW) lParam)->iItem != -1)
1219                 {
1220                     if (IsInstalledEnum(SelectedEnumType))
1221                         ShowInstalledAppInfo(-1);
1222                     if (IsAvailableEnum(SelectedEnumType))
1223                         CAvailableAppView::ShowAvailableAppInfo(-1);
1224                 }
1225             }
1226             break;
1227 
1228             case NM_DBLCLK:
1229             {
1230                 if (data->hwndFrom == m_ListView->m_hWnd && ((LPNMLISTVIEW) lParam)->iItem != -1)
1231                 {
1232                     /* this won't do anything if the program is already installed */
1233                     SendMessageW(hwnd, WM_COMMAND, ID_INSTALL, 0);
1234                 }
1235             }
1236             break;
1237 
1238             case NM_RCLICK:
1239             {
1240                 if (data->hwndFrom == m_ListView->m_hWnd && ((LPNMLISTVIEW) lParam)->iItem != -1)
1241                 {
1242                     ShowPopupMenu(m_ListView->m_hWnd, 0, ID_INSTALL);
1243                 }
1244             }
1245             break;
1246 
1247             case EN_LINK:
1248                 OnLink((ENLINK*) lParam);
1249                 break;
1250 
1251             case TTN_GETDISPINFO:
1252                 m_Toolbar->OnGetDispInfo((LPTOOLTIPTEXT) lParam);
1253                 break;
1254             }
1255         }
1256         break;
1257 
1258         case WM_SIZE:
1259             OnSize(hwnd, wParam, lParam);
1260             break;
1261 
1262         case WM_SIZING:
1263         {
1264             LPRECT pRect = (LPRECT) lParam;
1265 
1266             if (pRect->right - pRect->left < 565)
1267                 pRect->right = pRect->left + 565;
1268 
1269             if (pRect->bottom - pRect->top < 300)
1270                 pRect->bottom = pRect->top + 300;
1271 
1272             return TRUE;
1273         }
1274 
1275         case WM_SYSCOLORCHANGE:
1276         {
1277             /* Forward WM_SYSCOLORCHANGE to common controls */
1278             m_ListView->SendMessageW(WM_SYSCOLORCHANGE, 0, 0);
1279             m_TreeView->SendMessageW(WM_SYSCOLORCHANGE, 0, 0);
1280             m_Toolbar->SendMessageW(WM_SYSCOLORCHANGE, 0, 0);
1281             m_ListView->SendMessageW(EM_SETBKGNDCOLOR, 0, GetSysColor(COLOR_BTNFACE));
1282         }
1283         break;
1284 
1285         case WM_TIMER:
1286             if (wParam == SEARCH_TIMER_ID)
1287             {
1288                 ::KillTimer(hwnd, SEARCH_TIMER_ID);
1289                 if (bSearchEnabled)
1290                     UpdateApplicationsList(-1);
1291             }
1292             break;
1293         }
1294 
1295         return FALSE;
1296     }
1297 
1298     virtual VOID OnLink(ENLINK *Link)
1299     {
1300         switch (Link->msg)
1301         {
1302         case WM_LBUTTONUP:
1303         case WM_RBUTTONUP:
1304         {
1305             if (pLink) HeapFree(GetProcessHeap(), 0, pLink);
1306 
1307             pLink = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
1308                 (max(Link->chrg.cpMin, Link->chrg.cpMax) -
1309                  min(Link->chrg.cpMin, Link->chrg.cpMax) + 1) * sizeof(WCHAR));
1310             if (!pLink)
1311             {
1312                 /* TODO: Error message */
1313                 return;
1314             }
1315 
1316             m_RichEdit->SendMessageW(EM_SETSEL, Link->chrg.cpMin, Link->chrg.cpMax);
1317             m_RichEdit->SendMessageW(EM_GETSELTEXT, 0, (LPARAM) pLink);
1318 
1319             ShowPopupMenu(m_RichEdit->m_hWnd, IDR_LINKMENU, -1);
1320         }
1321         break;
1322         }
1323     }
1324 
1325     BOOL IsSelectedNodeInstalled()
1326     {
1327         HTREEITEM hSelectedItem = m_TreeView->GetSelection();
1328         TV_ITEM tItem;
1329 
1330         tItem.mask = TVIF_PARAM | TVIF_HANDLE;
1331         tItem.hItem = hSelectedItem;
1332         m_TreeView->GetItem(&tItem);
1333         switch (tItem.lParam)
1334         {
1335         case IDS_INSTALLED:
1336         case IDS_APPLICATIONS:
1337         case IDS_UPDATES:
1338             return TRUE;
1339         default:
1340             return FALSE;
1341         }
1342     }
1343 
1344     VOID OnCommand(WPARAM wParam, LPARAM lParam)
1345     {
1346         WORD wCommand = LOWORD(wParam);
1347 
1348         if (lParam == (LPARAM) m_SearchBar->m_hWnd)
1349         {
1350             ATL::CStringW szBuf;
1351 
1352             switch (HIWORD(wParam))
1353             {
1354             case EN_SETFOCUS:
1355             {
1356                 ATL::CStringW szWndText;
1357 
1358                 szBuf.LoadStringW(IDS_SEARCH_TEXT);
1359                 m_SearchBar->GetWindowTextW(szWndText);
1360                 if (szBuf == szWndText)
1361                 {
1362                     bSearchEnabled = FALSE;
1363                     m_SearchBar->SetWindowTextW(L"");
1364                 }
1365             }
1366             break;
1367 
1368             case EN_KILLFOCUS:
1369             {
1370                 m_SearchBar->GetWindowTextW(szBuf);
1371                 if (szBuf.IsEmpty())
1372                 {
1373                     szBuf.LoadStringW(IDS_SEARCH_TEXT);
1374                     bSearchEnabled = FALSE;
1375                     m_SearchBar->SetWindowTextW(szBuf.GetString());
1376                 }
1377             }
1378             break;
1379 
1380             case EN_CHANGE:
1381             {
1382                 ATL::CStringW szWndText;
1383 
1384                 if (!bSearchEnabled)
1385                 {
1386                     bSearchEnabled = TRUE;
1387                     break;
1388                 }
1389 
1390                 szBuf.LoadStringW(IDS_SEARCH_TEXT);
1391                 m_SearchBar->GetWindowTextW(szWndText);
1392                 if (szBuf == szWndText)
1393                 {
1394                     szSearchPattern.Empty();
1395                 }
1396                 else
1397                 {
1398                     szSearchPattern = szWndText;
1399                 }
1400 
1401                 DWORD dwDelay;
1402                 SystemParametersInfoW(SPI_GETMENUSHOWDELAY, 0, &dwDelay, 0);
1403                 SetTimer(SEARCH_TIMER_ID, dwDelay);
1404             }
1405             break;
1406             }
1407 
1408             return;
1409         }
1410 
1411         switch (wCommand)
1412         {
1413         case ID_OPEN_LINK:
1414             ShellExecuteW(m_hWnd, L"open", pLink, NULL, NULL, SW_SHOWNOACTIVATE);
1415             HeapFree(GetProcessHeap(), 0, pLink);
1416             break;
1417 
1418         case ID_COPY_LINK:
1419             CopyTextToClipboard(pLink);
1420             HeapFree(GetProcessHeap(), 0, pLink);
1421             break;
1422 
1423         case ID_SETTINGS:
1424             CreateSettingsDlg(m_hWnd);
1425             break;
1426 
1427         case ID_EXIT:
1428             PostMessageW(WM_CLOSE, 0, 0);
1429             break;
1430 
1431         case ID_INSTALL:
1432             if (IsAvailableEnum(SelectedEnumType))
1433             {
1434                 if (nSelectedApps > 0)
1435                 {
1436                     CDownloadManager::DownloadListOfApplications(m_AvailableApps.GetSelected());
1437                     UpdateApplicationsList(-1);
1438                 }
1439                 else if (CDownloadManager::DownloadApplication(m_ListView->GetSelectedData()))
1440                 {
1441                     UpdateApplicationsList(-1);
1442                 }
1443 
1444             }
1445             break;
1446 
1447         case ID_UNINSTALL:
1448             if (UninstallApplication(-1, FALSE))
1449                 UpdateApplicationsList(-1);
1450             break;
1451 
1452         case ID_MODIFY:
1453             if (UninstallApplication(-1, TRUE))
1454                 UpdateApplicationsList(-1);
1455             break;
1456 
1457         case ID_REGREMOVE:
1458             RemoveAppFromRegistry(-1);
1459             break;
1460 
1461         case ID_REFRESH:
1462             UpdateApplicationsList(-1);
1463             break;
1464 
1465         case ID_RESETDB:
1466             CAvailableApps::ForceUpdateAppsDB();
1467             UpdateApplicationsList(-1);
1468             break;
1469 
1470         case ID_HELP:
1471             MessageBoxW(L"Help not implemented yet", NULL, MB_OK);
1472             break;
1473 
1474         case ID_ABOUT:
1475             ShowAboutDialog();
1476             break;
1477 
1478         case ID_CHECK_ALL:
1479             m_ListView->CheckAll();
1480             break;
1481         }
1482     }
1483 
1484     VOID FreeInstalledAppList()
1485     {
1486         INT Count = m_ListView->GetItemCount() - 1;
1487         PINSTALLED_INFO Info;
1488 
1489         while (Count >= 0)
1490         {
1491             Info = (PINSTALLED_INFO) ListViewGetlParam(Count);
1492             if (Info)
1493             {
1494                 RegCloseKey(Info->hSubKey);
1495                 delete Info;
1496             }
1497             Count--;
1498         }
1499     }
1500 
1501     static BOOL SearchPatternMatch(LPCWSTR szHaystack, LPCWSTR szNeedle)
1502     {
1503         if (!*szNeedle)
1504             return TRUE;
1505         /* TODO: Improve pattern search beyond a simple case-insensitive substring search. */
1506         return StrStrIW(szHaystack, szNeedle) != NULL;
1507     }
1508 
1509     static BOOL CALLBACK s_EnumInstalledAppProc(INT ItemIndex, ATL::CStringW &m_szName, PINSTALLED_INFO Info)
1510     {
1511         PINSTALLED_INFO ItemInfo;
1512         ATL::CStringW szText;
1513         INT Index;
1514 
1515         if (!SearchPatternMatch(m_szName.GetString(), szSearchPattern))
1516         {
1517             RegCloseKey(Info->hSubKey);
1518             return TRUE;
1519         }
1520 
1521         ItemInfo = new INSTALLED_INFO(*Info);
1522         if (!ItemInfo)
1523         {
1524             RegCloseKey(Info->hSubKey);
1525             return FALSE;
1526         }
1527 
1528         Index = ListViewAddItem(ItemIndex, 0, m_szName, (LPARAM) ItemInfo);
1529 
1530         /* Get version info */
1531         GetApplicationString(ItemInfo->hSubKey, L"DisplayVersion", szText);
1532         ListView_SetItemText(hListView, Index, 1, const_cast<LPWSTR>(szText.GetString()));
1533 
1534         /* Get comments */
1535         GetApplicationString(ItemInfo->hSubKey, L"Comments", szText);
1536         ListView_SetItemText(hListView, Index, 2, const_cast<LPWSTR>(szText.GetString()));
1537 
1538         return TRUE;
1539     }
1540 
1541     static BOOL CALLBACK s_EnumAvailableAppProc(CAvailableApplicationInfo* Info, LPCWSTR szFolderPath)
1542     {
1543         INT Index;
1544         HICON hIcon = NULL;
1545 
1546         HIMAGELIST hImageListView = ListView_GetImageList(hListView, LVSIL_SMALL);
1547 
1548         if (!SearchPatternMatch(Info->m_szName.GetString(), szSearchPattern) &&
1549             !SearchPatternMatch(Info->m_szDesc.GetString(), szSearchPattern))
1550         {
1551             return TRUE;
1552         }
1553 
1554         /* Load icon from file */
1555         ATL::CStringW szIconPath;
1556         szIconPath.Format(L"%lsicons\\%ls.ico", szFolderPath, Info->m_szName.GetString());
1557         hIcon = (HICON) LoadImageW(NULL,
1558                                    szIconPath.GetString(),
1559                                    IMAGE_ICON,
1560                                    LISTVIEW_ICON_SIZE,
1561                                    LISTVIEW_ICON_SIZE,
1562                                    LR_LOADFROMFILE);
1563 
1564         if (!hIcon || GetLastError() != ERROR_SUCCESS)
1565         {
1566             /* Load default icon */
1567             hIcon = (HICON) LoadIconW(hInst, MAKEINTRESOURCEW(IDI_MAIN));
1568         }
1569 
1570         Index = ImageList_AddIcon(hImageListView, hIcon);
1571         DestroyIcon(hIcon);
1572 
1573         Index = ListViewAddItem(Info->m_Category, Index, Info->m_szName.GetString(), (LPARAM) Info);
1574         ListView_SetImageList(hListView, hImageListView, LVSIL_SMALL);
1575 
1576         ListView_SetItemText(hListView, Index, 1, const_cast<LPWSTR>(Info->m_szVersion.GetString()));
1577         ListView_SetItemText(hListView, Index, 2, const_cast<LPWSTR>(Info->m_szDesc.GetString()));
1578         ListView_SetCheckState(hListView, Index, Info->m_IsSelected);
1579 
1580         return TRUE;
1581     }
1582 
1583     VOID UpdateStatusBarText()
1584     {
1585         if (m_StatusBar)
1586         {
1587             ATL::CStringW szBuffer;
1588 
1589             szBuffer.Format(IDS_APPS_COUNT, m_ListView->GetItemCount(), nSelectedApps);
1590             m_StatusBar->SetText(szBuffer);
1591         }
1592     }
1593 
1594     VOID UpdateApplicationsList(INT EnumType)
1595     {
1596         ATL::CStringW szBuffer1, szBuffer2;
1597         HIMAGELIST hImageListView;
1598         BOOL bWasInInstalled = IsInstalledEnum(SelectedEnumType);
1599 
1600         bUpdating = TRUE;
1601         m_ListView->SetRedraw(FALSE);
1602 
1603         if (EnumType < 0)
1604         {
1605             EnumType = SelectedEnumType;
1606         }
1607 
1608         //if previous one was INSTALLED purge the list
1609         //TODO: make the Installed category a separate class to avoid doing this
1610         if (bWasInInstalled)
1611         {
1612             FreeInstalledAppList();
1613         }
1614 
1615         m_ListView->DeleteAllItems();
1616 
1617         // Create new ImageList
1618         hImageListView = ImageList_Create(LISTVIEW_ICON_SIZE,
1619                                           LISTVIEW_ICON_SIZE,
1620                                           GetSystemColorDepth() | ILC_MASK,
1621                                           0, 1);
1622         HIMAGELIST hImageListBuf = m_ListView->SetImageList(hImageListView, LVSIL_SMALL);
1623         if (hImageListBuf)
1624         {
1625             ImageList_Destroy(hImageListBuf);
1626         }
1627 
1628         if (IsInstalledEnum(EnumType))
1629         {
1630             if (!bWasInInstalled)
1631             {
1632                 m_ListView->SetCheckboxesVisible(FALSE);
1633             }
1634 
1635             HICON hIcon = (HICON) LoadIconW(hInst, MAKEINTRESOURCEW(IDI_MAIN));
1636             ImageList_AddIcon(hImageListView, hIcon);
1637             DestroyIcon(hIcon);
1638 
1639             // Enum installed applications and updates
1640             EnumInstalledApplications(EnumType, TRUE, s_EnumInstalledAppProc);
1641             EnumInstalledApplications(EnumType, FALSE, s_EnumInstalledAppProc);
1642         }
1643         else if (IsAvailableEnum(EnumType))
1644         {
1645             if (bWasInInstalled)
1646             {
1647                 m_ListView->SetCheckboxesVisible(TRUE);
1648             }
1649 
1650             // Enum available applications
1651             m_AvailableApps.Enum(EnumType, s_EnumAvailableAppProc);
1652         }
1653 
1654         SelectedEnumType = EnumType;
1655         UpdateStatusBarText();
1656         SetWelcomeText();
1657 
1658         // Set automatic column width for program names if the list is not empty
1659         if (m_ListView->GetItemCount() > 0)
1660         {
1661             ListView_SetColumnWidth(m_ListView->GetWindow(), 0, LVSCW_AUTOSIZE);
1662         }
1663 
1664         bUpdating = FALSE;
1665         m_ListView->SetRedraw(TRUE);
1666     }
1667 
1668 public:
1669     static ATL::CWndClassInfo& GetWndClassInfo()
1670     {
1671         DWORD csStyle = CS_VREDRAW | CS_HREDRAW;
1672         static ATL::CWndClassInfo wc =
1673         {
1674             {
1675                 sizeof(WNDCLASSEX),
1676                 csStyle,
1677                 StartWindowProc,
1678                 0,
1679                 0,
1680                 NULL,
1681                 LoadIconW(_AtlBaseModule.GetModuleInstance(), MAKEINTRESOURCEW(IDI_MAIN)),
1682                 LoadCursorW(NULL, IDC_ARROW),
1683                 (HBRUSH) (COLOR_BTNFACE + 1),
1684                 MAKEINTRESOURCEW(IDR_MAINMENU),
1685                 L"RAppsWnd",
1686                 NULL
1687             },
1688             NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
1689         };
1690         return wc;
1691     }
1692 
1693     HWND Create()
1694     {
1695         ATL::CStringW szWindowName;
1696         szWindowName.LoadStringW(IDS_APPTITLE);
1697 
1698         RECT r = {
1699             (SettingsInfo.bSaveWndPos ? SettingsInfo.Left : CW_USEDEFAULT),
1700             (SettingsInfo.bSaveWndPos ? SettingsInfo.Top : CW_USEDEFAULT),
1701             (SettingsInfo.bSaveWndPos ? SettingsInfo.Width : 680),
1702             (SettingsInfo.bSaveWndPos ? SettingsInfo.Height : 450)
1703         };
1704         r.right += r.left;
1705         r.bottom += r.top;
1706 
1707         return CWindowImpl::Create(NULL, r, szWindowName.GetString(), WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_WINDOWEDGE);
1708     }
1709 
1710     CStatusBar * GetStatusBar()
1711     {
1712         return m_StatusBar;
1713     }
1714 
1715     CAppsListView * GetListView()
1716     {
1717         return m_ListView;
1718     }
1719 
1720     CRichEdit * GetRichEdit()
1721     {
1722         return m_RichEdit;
1723     }
1724 
1725     CAvailableApps * GetAvailableApps()
1726     {
1727         return &m_AvailableApps;
1728     }
1729 };
1730 
1731 // global interface
1732 CMainWindow * g_MainWindow;
1733 
1734 HWND CreateMainWindow()
1735 {
1736     g_MainWindow = new CMainWindow();
1737     return g_MainWindow->Create();
1738 }
1739 
1740 DWORD_PTR ListViewGetlParam(INT item)
1741 {
1742     if (item < 0)
1743     {
1744         item = g_MainWindow->GetListView()->GetSelectionMark();
1745     }
1746     return g_MainWindow->GetListView()->GetItemData(item);
1747 }
1748 
1749 VOID SetStatusBarText(LPCWSTR szText)
1750 {
1751     g_MainWindow->GetStatusBar()->SetText(szText);
1752 }
1753 
1754 INT ListViewAddItem(INT ItemIndex, INT IconIndex, LPWSTR lpName, LPARAM lParam)
1755 {
1756     return g_MainWindow->GetListView()->AddItem(ItemIndex, IconIndex, lpName, lParam);
1757 }
1758 
1759 VOID NewRichEditText(LPCWSTR szText, DWORD flags)
1760 {
1761     g_MainWindow->GetRichEdit()->SetText(szText, flags);
1762 }
1763 
1764 VOID InsertRichEditText(LPCWSTR szText, DWORD flags)
1765 {
1766     g_MainWindow->GetRichEdit()->InsertText(szText, flags);
1767 }
1768 
1769 CAvailableApps* GetAvailableApps()
1770 {
1771     return g_MainWindow->GetAvailableApps();
1772 }
1773 
1774 // ATL version of functions above
1775 VOID SetStatusBarText(const ATL::CStringW& szText)
1776 {
1777     SetStatusBarText(szText.GetString());
1778 }
1779 
1780 INT ListViewAddItem(INT ItemIndex, INT IconIndex, const ATL::CStringW& Name, LPARAM lParam)
1781 {
1782     return ListViewAddItem(ItemIndex, IconIndex, const_cast<LPWSTR>(Name.GetString()), lParam);
1783 }
1784 
1785 VOID NewRichEditText(const ATL::CStringW& szText, DWORD flags)
1786 {
1787     NewRichEditText(szText.GetString(), flags);
1788 }
1789 
1790 VOID InsertRichEditText(const ATL::CStringW& szText, DWORD flags)
1791 {
1792     InsertRichEditText(szText.GetString(), flags);
1793 }
1794