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