xref: /reactos/base/applications/rapps/gui.cpp (revision 8a92b556) 
1 /*
2  * PROJECT:     ReactOS Applications Manager
3  * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4  * PURPOSE:     GUI classes for RAPPS
5  * COPYRIGHT:   Copyright 2015 David Quintana           (gigaherz@gmail.com)
6  *              Copyright 2017 Alexander Shaposhnikov   (sanchaez@reactos.org)
7  *              Copyright 2020 He Yang                  (1160386205@qq.com)
8  */
9 
10 #include "rapps.h"
11 #include "rosui.h"
12 #include "crichedit.h"
13 #include "appview.h"
14 #include "asyncinet.h"
15 #include "misc.h"
16 #include "gui.h"
17 #include "appview.h"
18 #include "winmain.h"
19 #include <shlobj_undoc.h>
20 #include <shlguid_undoc.h>
21 
22 #include <atlbase.h>
23 #include <atlcom.h>
24 #include <atltypes.h>
25 #include <atlwin.h>
26 #include <wininet.h>
27 #include <shellutils.h>
28 #include <rosctrls.h>
29 #include <gdiplus.h>
30 #include <math.h>
31 
32 #define SEARCH_TIMER_ID 'SR'
33 #define TREEVIEW_ICON_SIZE 24
34 
35 
36 
37 // **** CSideTreeView ****
38 
39 CSideTreeView::CSideTreeView() :
40     CUiWindow(),
41     hImageTreeView(ImageList_Create(TREEVIEW_ICON_SIZE, TREEVIEW_ICON_SIZE,
42         GetSystemColorDepth() | ILC_MASK,
43         0, 1))
44 {
45 }
46 
47 HTREEITEM CSideTreeView::AddItem(HTREEITEM hParent, ATL::CStringW &Text, INT Image, INT SelectedImage, LPARAM lParam)
48 {
49     return CUiWindow<CTreeView>::AddItem(hParent, const_cast<LPWSTR>(Text.GetString()), Image, SelectedImage, lParam);
50 }
51 
52 HTREEITEM CSideTreeView::AddCategory(HTREEITEM hRootItem, UINT TextIndex, UINT IconIndex)
53 {
54     ATL::CStringW szText;
55     INT Index = 0;
56     HICON hIcon;
57 
58     hIcon = (HICON)LoadImageW(hInst,
59         MAKEINTRESOURCE(IconIndex),
60         IMAGE_ICON,
61         TREEVIEW_ICON_SIZE,
62         TREEVIEW_ICON_SIZE,
63         LR_CREATEDIBSECTION);
64     if (hIcon)
65     {
66         Index = ImageList_AddIcon(hImageTreeView, hIcon);
67         DestroyIcon(hIcon);
68     }
69 
70     szText.LoadStringW(TextIndex);
71     return AddItem(hRootItem, szText, Index, Index, TextIndex);
72 }
73 
74 HIMAGELIST CSideTreeView::SetImageList()
75 {
76     return CUiWindow<CTreeView>::SetImageList(hImageTreeView, TVSIL_NORMAL);
77 }
78 
79 VOID CSideTreeView::DestroyImageList()
80 {
81     if (hImageTreeView)
82         ImageList_Destroy(hImageTreeView);
83 }
84 
85 CSideTreeView::~CSideTreeView()
86 {
87     DestroyImageList();
88 }
89 // **** CSideTreeView ****
90 
91 
92 
93 // **** CMainWindow ****
94 
95 CMainWindow::CMainWindow() :
96     m_ClientPanel(NULL),
97     SelectedEnumType(ENUM_ALL_INSTALLED)
98 {
99 }
100 
101 CMainWindow::~CMainWindow()
102 {
103     LayoutCleanup();
104 }
105 
106 VOID CMainWindow::InitCategoriesList()
107 {
108     HTREEITEM hRootItemInstalled, hRootItemAvailable;
109 
110     hRootItemInstalled = m_TreeView->AddCategory(TVI_ROOT, IDS_INSTALLED, IDI_CATEGORY);
111     m_TreeView->AddCategory(hRootItemInstalled, IDS_APPLICATIONS, IDI_APPS);
112     m_TreeView->AddCategory(hRootItemInstalled, IDS_UPDATES, IDI_APPUPD);
113 
114     m_TreeView->AddCategory(TVI_ROOT, IDS_SELECTEDFORINST, IDI_SELECTEDFORINST);
115 
116     hRootItemAvailable = m_TreeView->AddCategory(TVI_ROOT, IDS_AVAILABLEFORINST, IDI_CATEGORY);
117     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_AUDIO, IDI_CAT_AUDIO);
118     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_VIDEO, IDI_CAT_VIDEO);
119     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_GRAPHICS, IDI_CAT_GRAPHICS);
120     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_GAMES, IDI_CAT_GAMES);
121     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_INTERNET, IDI_CAT_INTERNET);
122     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_OFFICE, IDI_CAT_OFFICE);
123     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_DEVEL, IDI_CAT_DEVEL);
124     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_EDU, IDI_CAT_EDU);
125     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_ENGINEER, IDI_CAT_ENGINEER);
126     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_FINANCE, IDI_CAT_FINANCE);
127     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_SCIENCE, IDI_CAT_SCIENCE);
128     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_TOOLS, IDI_CAT_TOOLS);
129     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_DRIVERS, IDI_CAT_DRIVERS);
130     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_LIBS, IDI_CAT_LIBS);
131     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_THEMES, IDI_CAT_THEMES);
132     m_TreeView->AddCategory(hRootItemAvailable, IDS_CAT_OTHER, IDI_CAT_OTHER);
133 
134     m_TreeView->SetImageList();
135     m_TreeView->Expand(hRootItemInstalled, TVE_EXPAND);
136     m_TreeView->Expand(hRootItemAvailable, TVE_EXPAND);
137     m_TreeView->SelectItem(hRootItemAvailable);
138 }
139 
140 BOOL CMainWindow::CreateStatusBar()
141 {
142     m_StatusBar = new CUiWindow<CStatusBar>();
143     m_StatusBar->m_VerticalAlignment = UiAlign_RightBtm;
144     m_StatusBar->m_HorizontalAlignment = UiAlign_Stretch;
145     m_ClientPanel->Children().Append(m_StatusBar);
146 
147     return m_StatusBar->Create(m_hWnd, (HMENU)IDC_STATUSBAR) != NULL;
148 }
149 
150 BOOL CMainWindow::CreateTreeView()
151 {
152     m_TreeView = new CSideTreeView();
153     m_TreeView->m_VerticalAlignment = UiAlign_Stretch;
154     m_TreeView->m_HorizontalAlignment = UiAlign_Stretch;
155     m_VSplitter->First().Append(m_TreeView);
156 
157     return m_TreeView->Create(m_hWnd) != NULL;
158 }
159 
160 BOOL CMainWindow::CreateApplicationView()
161 {
162     m_ApplicationView = new CApplicationView(this); // pass this to ApplicationView for callback purpose
163     m_ApplicationView->m_VerticalAlignment = UiAlign_Stretch;
164     m_ApplicationView->m_HorizontalAlignment = UiAlign_Stretch;
165     m_VSplitter->Second().Append(m_ApplicationView);
166 
167     return m_ApplicationView->Create(m_hWnd) != NULL;
168 }
169 
170 BOOL CMainWindow::CreateVSplitter()
171 {
172     m_VSplitter = new CUiSplitPanel();
173     m_VSplitter->m_VerticalAlignment = UiAlign_Stretch;
174     m_VSplitter->m_HorizontalAlignment = UiAlign_Stretch;
175     m_VSplitter->m_DynamicFirst = FALSE;
176     m_VSplitter->m_Horizontal = FALSE;
177     m_VSplitter->m_MinFirst = 0;
178 
179     // TODO: m_MinSecond should be calculate dynamically instead of hard-coded
180     m_VSplitter->m_MinSecond = 480;
181     m_VSplitter->m_Pos = 240;
182     m_ClientPanel->Children().Append(m_VSplitter);
183 
184     return m_VSplitter->Create(m_hWnd) != NULL;
185 }
186 
187 BOOL CMainWindow::CreateLayout()
188 {
189     BOOL b = TRUE;
190     bUpdating = TRUE;
191 
192     m_ClientPanel = new CUiPanel();
193     m_ClientPanel->m_VerticalAlignment = UiAlign_Stretch;
194     m_ClientPanel->m_HorizontalAlignment = UiAlign_Stretch;
195 
196     // Top level
197     b = b && CreateStatusBar();
198     b = b && CreateVSplitter();
199 
200     // Inside V Splitter
201     b = b && CreateTreeView();
202     b = b && CreateApplicationView();
203 
204     if (b)
205     {
206         RECT rBottom;
207 
208         /* Size status bar */
209         m_StatusBar->SendMessageW(WM_SIZE, 0, 0);
210 
211         ::GetWindowRect(m_StatusBar->m_hWnd, &rBottom);
212 
213         m_VSplitter->m_Margin.bottom = rBottom.bottom - rBottom.top;
214     }
215 
216     bUpdating = FALSE;
217     return b;
218 }
219 
220 VOID CMainWindow::LayoutCleanup()
221 {
222     delete m_TreeView;
223     delete m_ApplicationView;
224     delete m_VSplitter;
225     delete m_StatusBar;
226     return;
227 }
228 
229 BOOL CMainWindow::InitControls()
230 {
231     if (CreateLayout())
232     {
233         InitCategoriesList();
234 
235         UpdateStatusBarText();
236 
237         return TRUE;
238     }
239 
240     return FALSE;
241 }
242 
243 VOID CMainWindow::OnSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
244 {
245     if (wParam == SIZE_MINIMIZED)
246         return;
247 
248     /* Size status bar */
249     m_StatusBar->SendMessage(WM_SIZE, 0, 0);
250 
251 
252     RECT r = { 0, 0, LOWORD(lParam), HIWORD(lParam) };
253     HDWP hdwp = NULL;
254     INT count = m_ClientPanel->CountSizableChildren();
255 
256     hdwp = BeginDeferWindowPos(count);
257     if (hdwp)
258     {
259         hdwp = m_ClientPanel->OnParentSize(r, hdwp);
260         if (hdwp)
261         {
262             EndDeferWindowPos(hdwp);
263         }
264     }
265 }
266 
267 BOOL CMainWindow::RemoveSelectedAppFromRegistry()
268 {
269     if (!IsInstalledEnum(SelectedEnumType))
270         return FALSE;
271 
272     ATL::CStringW szMsgText, szMsgTitle;
273 
274     if (!szMsgText.LoadStringW(IDS_APP_REG_REMOVE) ||
275         !szMsgTitle.LoadStringW(IDS_INFORMATION))
276         return FALSE;
277 
278     if (MessageBoxW(szMsgText, szMsgTitle, MB_YESNO | MB_ICONQUESTION) == IDYES)
279     {
280         CInstalledApplicationInfo *InstalledApp = (CInstalledApplicationInfo *)m_ApplicationView->GetFocusedItemData();
281         if (!InstalledApp)
282             return FALSE;
283 
284         LSTATUS Result = InstalledApp->RemoveFromRegistry();
285         if (Result != ERROR_SUCCESS)
286         {
287             // TODO: popup a messagebox telling user it fails somehow
288             return FALSE;
289         }
290 
291         // as it's already removed form registry, this will also remove it from the list
292         UpdateApplicationsList(-1);
293         return TRUE;
294     }
295 
296     return FALSE;
297 }
298 
299 BOOL CMainWindow::UninstallSelectedApp(BOOL bModify)
300 {
301     if (!IsInstalledEnum(SelectedEnumType))
302         return FALSE;
303 
304     CInstalledApplicationInfo *InstalledApp = (CInstalledApplicationInfo *)m_ApplicationView->GetFocusedItemData();
305     if (!InstalledApp)
306         return FALSE;
307 
308     return InstalledApp->UninstallApplication(bModify);
309 }
310 
311 BOOL CMainWindow::ProcessWindowMessage(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT &theResult, DWORD dwMapId)
312 {
313     theResult = 0;
314     switch (Msg)
315     {
316     case WM_CREATE:
317         if (!InitControls())
318             ::PostMessageW(hwnd, WM_CLOSE, 0, 0);
319         break;
320 
321     case WM_DESTROY:
322     {
323         ShowWindow(SW_HIDE);
324         SaveSettings(hwnd, &SettingsInfo);
325 
326         FreeLogs();
327         m_AvailableApps.FreeCachedEntries();
328         m_InstalledApps.FreeCachedEntries();
329 
330         delete m_ClientPanel;
331 
332         PostQuitMessage(0);
333         return 0;
334     }
335 
336     case WM_COMMAND:
337         OnCommand(wParam, lParam);
338         break;
339 
340     case WM_NOTIFY:
341     {
342         LPNMHDR data = (LPNMHDR)lParam;
343 
344         switch (data->code)
345         {
346         case TVN_SELCHANGED:
347         {
348             if (data->hwndFrom == m_TreeView->m_hWnd)
349             {
350                 switch (((LPNMTREEVIEW)lParam)->itemNew.lParam)
351                 {
352                 case IDS_INSTALLED:
353                     UpdateApplicationsList(ENUM_ALL_INSTALLED);
354                     break;
355 
356                 case IDS_APPLICATIONS:
357                     UpdateApplicationsList(ENUM_INSTALLED_APPLICATIONS);
358                     break;
359 
360                 case IDS_UPDATES:
361                     UpdateApplicationsList(ENUM_UPDATES);
362                     break;
363 
364                 case IDS_AVAILABLEFORINST:
365                     UpdateApplicationsList(ENUM_ALL_AVAILABLE);
366                     break;
367 
368                 case IDS_CAT_AUDIO:
369                     UpdateApplicationsList(ENUM_CAT_AUDIO);
370                     break;
371 
372                 case IDS_CAT_DEVEL:
373                     UpdateApplicationsList(ENUM_CAT_DEVEL);
374                     break;
375 
376                 case IDS_CAT_DRIVERS:
377                     UpdateApplicationsList(ENUM_CAT_DRIVERS);
378                     break;
379 
380                 case IDS_CAT_EDU:
381                     UpdateApplicationsList(ENUM_CAT_EDU);
382                     break;
383 
384                 case IDS_CAT_ENGINEER:
385                     UpdateApplicationsList(ENUM_CAT_ENGINEER);
386                     break;
387 
388                 case IDS_CAT_FINANCE:
389                     UpdateApplicationsList(ENUM_CAT_FINANCE);
390                     break;
391 
392                 case IDS_CAT_GAMES:
393                     UpdateApplicationsList(ENUM_CAT_GAMES);
394                     break;
395 
396                 case IDS_CAT_GRAPHICS:
397                     UpdateApplicationsList(ENUM_CAT_GRAPHICS);
398                     break;
399 
400                 case IDS_CAT_INTERNET:
401                     UpdateApplicationsList(ENUM_CAT_INTERNET);
402                     break;
403 
404                 case IDS_CAT_LIBS:
405                     UpdateApplicationsList(ENUM_CAT_LIBS);
406                     break;
407 
408                 case IDS_CAT_OFFICE:
409                     UpdateApplicationsList(ENUM_CAT_OFFICE);
410                     break;
411 
412                 case IDS_CAT_OTHER:
413                     UpdateApplicationsList(ENUM_CAT_OTHER);
414                     break;
415 
416                 case IDS_CAT_SCIENCE:
417                     UpdateApplicationsList(ENUM_CAT_SCIENCE);
418                     break;
419 
420                 case IDS_CAT_TOOLS:
421                     UpdateApplicationsList(ENUM_CAT_TOOLS);
422                     break;
423 
424                 case IDS_CAT_VIDEO:
425                     UpdateApplicationsList(ENUM_CAT_VIDEO);
426                     break;
427 
428                 case IDS_CAT_THEMES:
429                     UpdateApplicationsList(ENUM_CAT_THEMES);
430                     break;
431 
432                 case IDS_SELECTEDFORINST:
433                     UpdateApplicationsList(ENUM_CAT_SELECTED);
434                     break;
435                 }
436             }
437 
438             HMENU mainMenu = ::GetMenu(hwnd);
439 
440             /* Disable/enable items based on treeview selection */
441             if (IsSelectedNodeInstalled())
442             {
443                 EnableMenuItem(mainMenu, ID_REGREMOVE, MF_ENABLED);
444                 EnableMenuItem(mainMenu, ID_INSTALL, MF_GRAYED);
445                 EnableMenuItem(mainMenu, ID_UNINSTALL, MF_ENABLED);
446                 EnableMenuItem(mainMenu, ID_MODIFY, MF_ENABLED);
447             }
448             else
449             {
450                 EnableMenuItem(mainMenu, ID_REGREMOVE, MF_GRAYED);
451                 EnableMenuItem(mainMenu, ID_INSTALL, MF_ENABLED);
452                 EnableMenuItem(mainMenu, ID_UNINSTALL, MF_GRAYED);
453                 EnableMenuItem(mainMenu, ID_MODIFY, MF_GRAYED);
454             }
455         }
456         break;
457 
458         }
459     }
460     break;
461 
462     case WM_SIZE:
463         OnSize(hwnd, wParam, lParam);
464         break;
465 
466     case WM_SIZING:
467     {
468         LPRECT pRect = (LPRECT)lParam;
469 
470         if (pRect->right - pRect->left < 565)
471             pRect->right = pRect->left + 565;
472 
473         if (pRect->bottom - pRect->top < 300)
474             pRect->bottom = pRect->top + 300;
475 
476         return TRUE;
477     }
478 
479     case WM_SYSCOLORCHANGE:
480     {
481         /* Forward WM_SYSCOLORCHANGE to common controls */
482         m_ApplicationView->SendMessageW(WM_SYSCOLORCHANGE, wParam, lParam);
483         m_TreeView->SendMessageW(WM_SYSCOLORCHANGE, wParam, lParam);
484     }
485     break;
486 
487     case WM_TIMER:
488         if (wParam == SEARCH_TIMER_ID)
489         {
490             ::KillTimer(hwnd, SEARCH_TIMER_ID);
491 
492             UpdateApplicationsList(-1);
493         }
494         break;
495     }
496 
497     return FALSE;
498 }
499 
500 BOOL CMainWindow::IsSelectedNodeInstalled()
501 {
502     HTREEITEM hSelectedItem = m_TreeView->GetSelection();
503     TV_ITEM tItem;
504 
505     tItem.mask = TVIF_PARAM | TVIF_HANDLE;
506     tItem.hItem = hSelectedItem;
507     m_TreeView->GetItem(&tItem);
508     switch (tItem.lParam)
509     {
510     case IDS_INSTALLED:
511     case IDS_APPLICATIONS:
512     case IDS_UPDATES:
513         return TRUE;
514     default:
515         return FALSE;
516     }
517 }
518 
519 VOID CMainWindow::ShowAboutDlg()
520 {
521     ATL::CStringW szApp;
522     ATL::CStringW szAuthors;
523     HICON hIcon;
524 
525     szApp.LoadStringW(IDS_APPTITLE);
526     szAuthors.LoadStringW(IDS_APP_AUTHORS);
527     hIcon = LoadIconW(hInst, MAKEINTRESOURCEW(IDI_MAIN));
528     ShellAboutW(m_hWnd, szApp, szAuthors, hIcon);
529     DestroyIcon(hIcon);
530 }
531 
532 VOID CMainWindow::OnCommand(WPARAM wParam, LPARAM lParam)
533 {
534     WORD wCommand = LOWORD(wParam);
535 
536     if (!lParam)
537     {
538         switch (wCommand)
539         {
540         case ID_SETTINGS:
541             CreateSettingsDlg(m_hWnd);
542             break;
543 
544         case ID_EXIT:
545             PostMessageW(WM_CLOSE, 0, 0);
546             break;
547 
548         case ID_INSTALL:
549             if (IsAvailableEnum(SelectedEnumType))
550             {
551                 ATL::CSimpleArray<CAvailableApplicationInfo> AppsList;
552 
553                 // enum all selected apps
554                 m_AvailableApps.Enum(ENUM_CAT_SELECTED, s_EnumSelectedAppForDownloadProc, (PVOID)&AppsList);
555 
556                 if (AppsList.GetSize())
557                 {
558                     if (DownloadListOfApplications(AppsList, FALSE))
559                     {
560                         m_AvailableApps.RemoveAllSelected();
561                         UpdateApplicationsList(-1);
562                     }
563                 }
564                 else
565                 {
566                     // use the currently focused item in application-view
567                     CAvailableApplicationInfo *FocusedApps = (CAvailableApplicationInfo *)m_ApplicationView->GetFocusedItemData();
568                     if (FocusedApps)
569                     {
570                         if (DownloadApplication(FocusedApps, FALSE))
571                         {
572                             UpdateApplicationsList(-1);
573                         }
574                     }
575                     else
576                     {
577                         // TODO: in this case, Install button in toolbar (and all other places) should be disabled
578                         // or at least popup a messagebox telling user to select/check some app first
579                     }
580                 }
581             }
582             break;
583 
584         case ID_UNINSTALL:
585             if (UninstallSelectedApp(FALSE))
586                 UpdateApplicationsList(-1);
587             break;
588 
589         case ID_MODIFY:
590             if (UninstallSelectedApp(TRUE))
591                 UpdateApplicationsList(-1);
592             break;
593 
594         case ID_REGREMOVE:
595             RemoveSelectedAppFromRegistry();
596             break;
597 
598         case ID_REFRESH:
599             UpdateApplicationsList(-1);
600             break;
601 
602         case ID_RESETDB:
603             CAvailableApps::ForceUpdateAppsDB();
604             UpdateApplicationsList(-1);
605             break;
606 
607         case ID_HELP:
608             MessageBoxW(L"Help not implemented yet", NULL, MB_OK);
609             break;
610 
611         case ID_ABOUT:
612             ShowAboutDlg();
613             break;
614 
615         case ID_CHECK_ALL:
616             m_ApplicationView->CheckAll();
617             break;
618         }
619     }
620 }
621 
622 BOOL CALLBACK CMainWindow::EnumInstalledAppProc(CInstalledApplicationInfo *Info)
623 {
624     if (!SearchPatternMatch(Info->szDisplayName.GetString(), szSearchPattern))
625     {
626         return TRUE;
627     }
628     return m_ApplicationView->AddInstalledApplication(Info, Info); // currently, the callback param is Info itself
629 }
630 
631 BOOL CALLBACK CMainWindow::EnumAvailableAppProc(CAvailableApplicationInfo *Info, BOOL bInitialCheckState)
632 {
633     if (!SearchPatternMatch(Info->m_szName.GetString(), szSearchPattern) &&
634         !SearchPatternMatch(Info->m_szDesc.GetString(), szSearchPattern))
635     {
636         return TRUE;
637     }
638     return m_ApplicationView->AddAvailableApplication(Info, bInitialCheckState, Info); // currently, the callback param is Info itself
639 }
640 
641 BOOL CALLBACK CMainWindow::s_EnumInstalledAppProc(CInstalledApplicationInfo *Info, PVOID param)
642 {
643     CMainWindow *pThis = (CMainWindow *)param;
644     return pThis->EnumInstalledAppProc(Info);
645 }
646 
647 BOOL CALLBACK CMainWindow::s_EnumAvailableAppProc(CAvailableApplicationInfo *Info, BOOL bInitialCheckState, PVOID param)
648 {
649     CMainWindow *pThis = (CMainWindow *)param;
650     return pThis->EnumAvailableAppProc(Info, bInitialCheckState);
651 }
652 
653 BOOL CALLBACK CMainWindow::s_EnumSelectedAppForDownloadProc(CAvailableApplicationInfo *Info, BOOL bInitialCheckState, PVOID param)
654 {
655     ATL::CSimpleArray<CAvailableApplicationInfo> *pAppList = (ATL::CSimpleArray<CAvailableApplicationInfo> *)param;
656     pAppList->Add(*Info);
657     return TRUE;
658 }
659 
660 VOID CMainWindow::UpdateStatusBarText()
661 {
662     if (m_StatusBar)
663     {
664         ATL::CStringW szBuffer;
665 
666         szBuffer.Format(IDS_APPS_COUNT, m_ApplicationView->GetItemCount(), m_AvailableApps.GetSelectedCount());
667         m_StatusBar->SetText(szBuffer);
668     }
669 }
670 
671 VOID CMainWindow::UpdateApplicationsList(INT EnumType)
672 {
673     bUpdating = TRUE;
674 
675     if (EnumType == -1)
676     {
677         // keep the old enum type
678         EnumType = SelectedEnumType;
679     }
680     else
681     {
682         SelectedEnumType = EnumType;
683     }
684 
685     m_ApplicationView->SetRedraw(FALSE);
686     if (IsInstalledEnum(EnumType))
687     {
688         // set the display type of application-view. this will remove all the item in application-view too.
689         m_ApplicationView->SetDisplayAppType(AppViewTypeInstalledApps);
690 
691         // enum installed softwares
692         m_InstalledApps.Enum(EnumType, s_EnumInstalledAppProc, this);
693     }
694     else if (IsAvailableEnum(EnumType))
695     {
696         // set the display type of application-view. this will remove all the item in application-view too.
697         m_ApplicationView->SetDisplayAppType(AppViewTypeAvailableApps);
698 
699         // enum available softwares
700         m_AvailableApps.Enum(EnumType, s_EnumAvailableAppProc, this);
701     }
702     m_ApplicationView->SetRedraw(TRUE);
703     m_ApplicationView->RedrawWindow(0, 0, RDW_INVALIDATE | RDW_ALLCHILDREN); // force the child window to repaint
704     UpdateStatusBarText();
705     bUpdating = FALSE;
706 }
707 
708 ATL::CWndClassInfo &CMainWindow::GetWndClassInfo()
709 {
710     DWORD csStyle = CS_VREDRAW | CS_HREDRAW;
711     static ATL::CWndClassInfo wc =
712     {
713         {
714             sizeof(WNDCLASSEX),
715             csStyle,
716             StartWindowProc,
717             0,
718             0,
719             NULL,
720             LoadIconW(_AtlBaseModule.GetModuleInstance(), MAKEINTRESOURCEW(IDI_MAIN)),
721             LoadCursorW(NULL, IDC_ARROW),
722             (HBRUSH)(COLOR_BTNFACE + 1),
723             MAKEINTRESOURCEW(IDR_MAINMENU),
724             szWindowClass,
725             NULL
726         },
727         NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
728     };
729     return wc;
730 }
731 
732 HWND CMainWindow::Create()
733 {
734     ATL::CStringW szWindowName;
735     szWindowName.LoadStringW(IDS_APPTITLE);
736 
737     RECT r = {
738         (SettingsInfo.bSaveWndPos ? SettingsInfo.Left : CW_USEDEFAULT),
739         (SettingsInfo.bSaveWndPos ? SettingsInfo.Top : CW_USEDEFAULT),
740         (SettingsInfo.bSaveWndPos ? SettingsInfo.Width : 680),
741         (SettingsInfo.bSaveWndPos ? SettingsInfo.Height : 450)
742     };
743     r.right += r.left;
744     r.bottom += r.top;
745 
746     return CWindowImpl::Create(NULL, r, szWindowName.GetString(), WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_WINDOWEDGE);
747 }
748 
749 // this function is called when a item of application-view is checked/unchecked
750 // CallbackParam is the param passed to application-view when adding the item (the one getting focus now).
751 BOOL CMainWindow::ItemCheckStateChanged(BOOL bChecked, LPVOID CallbackParam)
752 {
753     if (!bUpdating)
754     {
755         if (bChecked)
756         {
757             if (!m_AvailableApps.AddSelected((CAvailableApplicationInfo *)CallbackParam))
758             {
759                 return FALSE;
760             }
761         }
762         else
763         {
764             if (!m_AvailableApps.RemoveSelected((CAvailableApplicationInfo *)CallbackParam))
765             {
766                 return FALSE;
767             }
768         }
769 
770         UpdateStatusBarText();
771         return TRUE;
772     }
773     else
774     {
775         return TRUE;
776     }
777 }
778 
779 // this function is called when one or more application(s) should be installed install
780 // if Info is not zero, this app should be installed. otherwise those checked apps should be installed
781 BOOL CMainWindow::InstallApplication(CAvailableApplicationInfo *Info)
782 {
783     if (Info)
784     {
785         if (DownloadApplication(Info, FALSE))
786         {
787             UpdateApplicationsList(-1);
788             return TRUE;
789         }
790     }
791     else
792     {
793         ATL::CSimpleArray<CAvailableApplicationInfo> AppsList;
794 
795         // enum all selected apps
796         m_AvailableApps.Enum(ENUM_CAT_SELECTED, s_EnumSelectedAppForDownloadProc, (PVOID)&AppsList);
797 
798         if (AppsList.GetSize())
799         {
800             if (DownloadListOfApplications(AppsList, FALSE))
801             {
802                 m_AvailableApps.RemoveAllSelected();
803                 UpdateApplicationsList(-1);
804                 return TRUE;
805             }
806         }
807     }
808 
809     return FALSE;
810 }
811 
812 BOOL CMainWindow::SearchTextChanged(ATL::CStringW &SearchText)
813 {
814     if (szSearchPattern == SearchText)
815     {
816         return FALSE;
817     }
818 
819     szSearchPattern = SearchText;
820 
821     DWORD dwDelay;
822     SystemParametersInfoW(SPI_GETMENUSHOWDELAY, 0, &dwDelay, 0);
823     SetTimer(SEARCH_TIMER_ID, dwDelay);
824 
825     return TRUE;
826 }
827 
828 void CMainWindow::HandleTabOrder(int direction)
829 {
830     ATL::CSimpleArray<HWND> TabOrderHwndList;
831 
832     m_TreeView->AppendTabOrderWindow(direction, TabOrderHwndList);
833     m_ApplicationView->AppendTabOrderWindow(direction, TabOrderHwndList);
834 
835 
836     if (TabOrderHwndList.GetSize() == 0)
837     {
838         // in case the list is empty
839         return;
840     }
841 
842     int FocusIndex;
843 
844     if ((FocusIndex = TabOrderHwndList.Find(GetFocus())) == -1)
845     {
846         FocusIndex = 0; // focus the first window in the list
847     }
848     else
849     {
850         FocusIndex += direction;
851         FocusIndex += TabOrderHwndList.GetSize(); // FocusIndex might be negative. we don't want to mod a negative number
852         FocusIndex %= TabOrderHwndList.GetSize();
853     }
854 
855     ::SetFocus(TabOrderHwndList[FocusIndex]);
856     return;
857 }
858 // **** CMainWindow ****
859 
860 
861 
862 VOID MainWindowLoop(INT nShowCmd)
863 {
864     HACCEL KeyBrd;
865     MSG Msg;
866 
867     CMainWindow* wnd = new CMainWindow();
868     if (!wnd)
869         return;
870 
871     hMainWnd = wnd->Create();
872     if (!hMainWnd)
873         return;
874 
875     /* Maximize it if we must */
876     wnd->ShowWindow((SettingsInfo.bSaveWndPos && SettingsInfo.Maximized) ? SW_MAXIMIZE : nShowCmd);
877     wnd->UpdateWindow();
878 
879     /* Load the menu hotkeys */
880     KeyBrd = LoadAcceleratorsW(NULL, MAKEINTRESOURCEW(HOTKEYS));
881 
882     /* Message Loop */
883     while (GetMessageW(&Msg, NULL, 0, 0))
884     {
885         if (!TranslateAcceleratorW(hMainWnd, KeyBrd, &Msg))
886         {
887             if (Msg.message == WM_CHAR &&
888                 Msg.wParam == VK_TAB)
889             {
890                 // Move backwards if shift is held down
891                 int direction = (GetKeyState(VK_SHIFT) & 0x8000) ? -1 : 1;
892 
893                 wnd->HandleTabOrder(direction);
894                 continue;
895             }
896 
897             TranslateMessage(&Msg);
898             DispatchMessageW(&Msg);
899         }
900     }
901 
902     delete wnd;
903 }
904