base/applications/rapps/gui.cpp

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