88d1df6fd97091656c458cfde1ea6aacbb5b8f4a
[reactos.git] / reactos / dll / win32 / devmgr_new / devmgmt / MainWindow.cpp
1 /*
2 * PROJECT: ReactOS Device Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/devmgr/devmgr/MainWindow.cpp
5 * PURPOSE: Implements the main container window for the device view
6 * COPYRIGHT: Copyright 2014 - 2015 Ged Murphy <gedmurphy@reactos.org>
7 */
8
9
10 #include "stdafx.h"
11 #include "devmgmt.h"
12 #include "MainWindow.h"
13
14
15 /* DATA *****************************************************/
16
17 #define BTN_PROPERTIES 0
18 #define BTN_SCAN_HARDWARE 1
19 #define BTN_ENABLE_DRV 2
20 #define BTN_DISABLE_DRV 3
21 #define BTN_UPDATE_DRV 4
22 #define BTN_UNINSTALL_DRV 5
23
24
25 // menu hints
26 static const MENU_HINT MainMenuHintTable[] =
27 {
28 // File Menu
29 { IDC_EXIT, IDS_HINT_EXIT },
30
31 // Action Menu
32 { IDC_PROPERTIES, IDS_HINT_PROPERTIES },
33 { IDC_SCAN_HARDWARE, IDS_HINT_SCAN },
34 { IDC_ENABLE_DRV, IDS_HINT_ENABLE },
35 { IDC_DISABLE_DRV, IDS_HINT_DISABLE },
36 { IDC_UPDATE_DRV, IDS_HINT_UPDATE },
37 { IDC_UNINSTALL_DRV, IDS_HINT_UNINSTALL },
38 { IDC_ADD_HARDWARE, IDS_HINT_ADD },
39
40
41 // View Menu
42 { IDC_DEVBYTYPE, IDS_HINT_DEV_BY_TYPE},
43 { IDC_DEVBYCONN, IDS_HINT_DEV_BY_CONN},
44 { IDC_RESBYTYPE, IDS_HINT_RES_BY_TYPE},
45 { IDC_RESBYCONN, IDS_HINT_RES_BY_TYPE},
46 { IDC_SHOWHIDDEN, IDS_HINT_SHOW_HIDDEN },
47
48 { IDC_ABOUT, IDS_HINT_ABOUT }
49
50 };
51
52
53 // system menu hints
54 static const MENU_HINT SystemMenuHintTable[] =
55 {
56 {SC_RESTORE, IDS_HINT_SYS_RESTORE},
57 {SC_MOVE, IDS_HINT_SYS_MOVE},
58 {SC_SIZE, IDS_HINT_SYS_SIZE},
59 {SC_MINIMIZE, IDS_HINT_SYS_MINIMIZE},
60 {SC_MAXIMIZE, IDS_HINT_SYS_MAXIMIZE},
61 {SC_CLOSE, IDS_HINT_SYS_CLOSE},
62 };
63
64 static TBBUTTON TbButtons[] =
65 {
66 { BTN_PROPERTIES, IDC_PROPERTIES, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 },
67 { BTN_SCAN_HARDWARE, IDC_SCAN_HARDWARE, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 },
68 { 2, IDC_STATIC, TBSTATE_ENABLED, BTNS_SEP, 0, 0 },
69 { BTN_ENABLE_DRV, IDC_ENABLE_DRV, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 },
70 { BTN_DISABLE_DRV, IDC_DISABLE_DRV, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 },
71 { BTN_UPDATE_DRV, IDC_UPDATE_DRV, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 },
72 { BTN_UNINSTALL_DRV, IDC_UNINSTALL_DRV, TBSTATE_ENABLED, BTNS_BUTTON, 0, 0 }
73 };
74
75
76 /* PUBLIC METHODS **********************************************/
77
78 CMainWindow::CMainWindow(void) :
79 m_ToolbarhImageList(NULL),
80 m_hMainWnd(NULL),
81 m_hStatusBar(NULL),
82 m_hToolBar(NULL),
83 m_CmdShow(0)
84 {
85 m_szMainWndClass = L"DevMgmtWndClass";
86 }
87
88 CMainWindow::~CMainWindow(void)
89 {
90 // Destroy any previous list
91 if (m_ToolbarhImageList) ImageList_Destroy(m_ToolbarhImageList);
92 }
93
94 bool
95 CMainWindow::Initialize(LPCTSTR lpCaption,
96 int nCmdShow)
97 {
98 CAtlStringW szCaption;
99 WNDCLASSEXW wc = {0};
100
101 // Store the show window value
102 m_CmdShow = nCmdShow;
103
104 // Setup the window class struct
105 wc.cbSize = sizeof(WNDCLASSEXW);
106 wc.lpfnWndProc = MainWndProc;
107 wc.hInstance = g_hInstance;
108 wc.hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCEW(IDI_MAIN_ICON));
109 wc.hCursor = LoadCursor(NULL, IDC_ARROW);
110 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
111 wc.lpszMenuName = MAKEINTRESOURCEW(IDR_MAINMENU);
112 wc.lpszClassName = m_szMainWndClass;
113 wc.hIconSm = (HICON)LoadImage(g_hInstance,
114 MAKEINTRESOURCE(IDI_MAIN_ICON),
115 IMAGE_ICON,
116 16,
117 16,
118 LR_SHARED);
119
120 // Register the window
121 if (RegisterClassExW(&wc))
122 {
123 // Create the main window and store the object pointer
124 m_hMainWnd = CreateWindowExW(WS_EX_WINDOWEDGE,
125 m_szMainWndClass,
126 lpCaption,
127 WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
128 CW_USEDEFAULT,
129 CW_USEDEFAULT,
130 550,
131 500,
132 NULL,
133 NULL,
134 g_hInstance,
135 this);
136 }
137
138 // Return creation result
139 return !!(m_hMainWnd);
140 }
141
142 void
143 CMainWindow::Uninitialize()
144 {
145 // Unregister the window class
146 UnregisterClassW(m_szMainWndClass, g_hInstance);
147 }
148
149 int
150 CMainWindow::Run()
151 {
152 MSG Msg;
153
154 // Pump the message queue
155 while (GetMessageW(&Msg, NULL, 0, 0 ) != 0)
156 {
157 TranslateMessage(&Msg);
158 DispatchMessageW(&Msg);
159 }
160
161 return 0;
162 }
163
164
165 /* PRIVATE METHODS **********************************************/
166
167 bool
168 CMainWindow::MainWndMenuHint(WORD CmdId,
169 const MENU_HINT *HintArray,
170 DWORD HintsCount,
171 UINT DefHintId)
172 {
173 bool Found = false;
174 const MENU_HINT *LastHint;
175 UINT HintId = DefHintId;
176
177 LastHint = HintArray + HintsCount;
178 while (HintArray != LastHint)
179 {
180 if (HintArray->CmdId == CmdId)
181 {
182 HintId = HintArray->HintId;
183 Found = true;
184 break;
185 }
186 HintArray++;
187 }
188
189 StatusBarLoadString(m_hStatusBar,
190 SB_SIMPLEID,
191 g_hInstance,
192 HintId);
193
194 return Found;
195 }
196
197 void
198 CMainWindow::UpdateStatusBar(
199 _In_ bool InMenuLoop
200 )
201 {
202 SendMessageW(m_hStatusBar,
203 SB_SIMPLE,
204 (WPARAM)InMenuLoop,
205 0);
206 }
207
208 bool
209 CMainWindow::RefreshView(ViewType Type)
210 {
211 UINT CheckId = 0;
212 BOOL bSuccess;
213
214 // Refreshed the cached view
215 m_DeviceView->Refresh(Type, FALSE, TRUE, NULL);
216
217 // Get the menu item id
218 switch (Type)
219 {
220 case DevicesByType: CheckId = IDC_DEVBYTYPE; break;
221 case DevicesByConnection: CheckId = IDC_DEVBYCONN; break;
222 case ResourcesByType: CheckId = IDC_RESBYTYPE; break;
223 case ResourcesByConnection: CheckId = IDC_RESBYCONN; break;
224 default: ATLASSERT(FALSE); break;
225 }
226
227 // Set the new check item
228 bSuccess = CheckMenuRadioItem(m_hMenu,
229 IDC_DEVBYTYPE,
230 IDC_RESBYCONN,
231 CheckId,
232 MF_BYCOMMAND);
233
234 return TRUE;
235 }
236
237 bool
238 CMainWindow::CreateToolBar()
239 {
240 TBADDBITMAP TbAddBitmap;
241 INT Index;
242
243 DWORD dwStyles = WS_CHILDWINDOW | TBSTYLE_FLAT | TBSTYLE_WRAPABLE | TBSTYLE_TOOLTIPS | CCS_NODIVIDER;
244 DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
245
246 // Create the toolbar window
247 m_hToolBar = CreateWindowExW(dwExStyles,
248 TOOLBARCLASSNAME,
249 NULL,
250 dwStyles,
251 0, 0, 0, 0,
252 m_hMainWnd,
253 (HMENU)IDC_TOOLBAR,
254 g_hInstance,
255 NULL);
256 if (m_hToolBar == NULL) return FALSE;
257
258 // Don't show clipped buttons
259 SendMessageW(m_hToolBar,
260 TB_SETEXTENDEDSTYLE,
261 0,
262 TBSTYLE_EX_HIDECLIPPEDBUTTONS);
263
264 SendMessageW(m_hToolBar, TB_SETBITMAPSIZE, 0, MAKELONG(16, 16));
265
266 // Set the struct size, the toobar needs this...
267 SendMessageW(m_hToolBar,
268 TB_BUTTONSTRUCTSIZE,
269 sizeof(TBBUTTON),
270 0);
271
272 TbAddBitmap.hInst = g_hInstance;
273 TbAddBitmap.nID = IDB_TOOLBAR;
274 Index = SendMessageW(m_hToolBar, TB_ADDBITMAP, _countof(TbButtons), (LPARAM)&TbAddBitmap);
275
276 SendMessageW(m_hToolBar, TB_ADDBUTTONSW, _countof(TbButtons), (LPARAM)TbButtons);
277 SendMessageW(m_hToolBar, TB_AUTOSIZE, 0, 0);
278
279 if (TRUE)
280 {
281 ShowWindow(m_hToolBar, SW_SHOW);
282 }
283
284 return TRUE;
285 }
286
287 bool
288 CMainWindow::CreateStatusBar()
289 {
290 int StatWidths[] = {110, -1}; // widths of status bar
291 bool bRet = FALSE;
292
293 // Create the status bar
294 m_hStatusBar = CreateWindowExW(0,
295 STATUSCLASSNAME,
296 NULL,
297 WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
298 0, 0, 0, 0,
299 m_hMainWnd,
300 (HMENU)IDC_STATUSBAR,
301 g_hInstance,
302 NULL);
303 if (m_hStatusBar)
304 {
305 // Set the width
306 bRet = (SendMessageW(m_hStatusBar,
307 SB_SETPARTS,
308 sizeof(StatWidths) / sizeof(int),
309 (LPARAM)StatWidths) != 0);
310 }
311
312 return bRet;
313 }
314
315 void CMainWindow::UpdateToolbar()
316 {
317 WORD State;
318
319 CNode *Node = m_DeviceView->GetSelectedNode();
320
321 // properties button
322 if (Node->HasProperties())
323 {
324 State = TBSTATE_ENABLED;
325 }
326 else
327 {
328 State = TBSTATE_HIDDEN;
329 }
330 SendMessageW(m_hToolBar, TB_SETSTATE, IDC_PROPERTIES, MAKELPARAM(State, 0));
331 SendMessageW(m_hToolBar, TB_SETSTATE, IDC_UPDATE_DRV, MAKELPARAM(State, 0)); //hack
332 SendMessageW(m_hToolBar, TB_SETSTATE, IDC_UNINSTALL_DRV, MAKELPARAM(State, 0)); // hack
333
334
335
336 // enable driver button
337 if (Node->GetNodeType() == DeviceNode &&
338 dynamic_cast<CDeviceNode *>(Node)->IsDisabled())
339 {
340 State = TBSTATE_ENABLED;
341 }
342 else
343 {
344 State = TBSTATE_HIDDEN;
345 }
346 SendMessageW(m_hToolBar, TB_SETSTATE, IDC_ENABLE_DRV, MAKELPARAM(State, 0));
347
348 // disable driver button
349 if (Node->GetNodeType() == DeviceNode &&
350 dynamic_cast<CDeviceNode *>(Node)->CanDisable() &&
351 !dynamic_cast<CDeviceNode *>(Node)->IsDisabled())
352 {
353 State = TBSTATE_ENABLED;
354 }
355 else
356 {
357 State = TBSTATE_HIDDEN;
358 }
359 SendMessageW(m_hToolBar, TB_SETSTATE, IDC_DISABLE_DRV, MAKELPARAM(State, 0));
360
361
362
363
364
365 }
366
367
368
369 bool
370 CMainWindow::StatusBarLoadString(IN HWND hStatusBar,
371 IN INT PartId,
372 IN HINSTANCE hInstance,
373 IN UINT uID)
374 {
375 CAtlStringW szMessage;
376 bool bRet = false;
377
378 // Load the string
379 if (szMessage.LoadStringW(hInstance, uID))
380 {
381 // Show the string on the status bar
382 bRet = (SendMessageW(hStatusBar,
383 SB_SETTEXT,
384 (WPARAM)PartId,
385 (LPARAM)szMessage.GetBuffer()) != 0);
386 }
387
388 return bRet;
389 }
390
391 LRESULT
392 CMainWindow::OnCreate(HWND hwnd)
393 {
394 LRESULT RetCode;
395
396 RetCode = -1;
397 m_hMainWnd = hwnd;
398
399 // Store a handle to the main menu
400 m_hMenu = GetMenu(m_hMainWnd);
401
402 // Create the toolbar and statusbar
403 if (CreateToolBar() && CreateStatusBar())
404 {
405 // Create the device view object
406 m_DeviceView = new CDeviceView(m_hMainWnd);
407 if (m_DeviceView->Initialize())
408 {
409 // Do the initial scan
410 m_DeviceView->Refresh(m_DeviceView->GetCurrentView(),
411 true,
412 true,
413 NULL);
414
415 // Display the window according to the user request
416 ShowWindow(hwnd, m_CmdShow);
417 RetCode = 0;
418 }
419 }
420
421 return RetCode;
422 }
423
424 LRESULT
425 CMainWindow::OnSize()
426 {
427 RECT rcClient, rcTool, rcStatus;
428 INT lvHeight, iToolHeight, iStatusHeight;
429
430 // Autosize the toolbar
431 SendMessage(m_hToolBar, TB_AUTOSIZE, 0, 0);
432
433 // Get the toolbar rect and save the height
434 GetWindowRect(m_hToolBar, &rcTool);
435 iToolHeight = rcTool.bottom - rcTool.top;
436
437 // Resize the status bar
438 SendMessage(m_hStatusBar, WM_SIZE, 0, 0);
439
440 // Get the statusbar rect and save the height
441 GetWindowRect(m_hStatusBar, &rcStatus);
442 iStatusHeight = rcStatus.bottom - rcStatus.top;
443
444 // Get the full client rect
445 GetClientRect(m_hMainWnd, &rcClient);
446
447 // Calculate the remaining height for the treeview
448 lvHeight = rcClient.bottom - iToolHeight - iStatusHeight;
449
450 // Resize the device view
451 m_DeviceView->OnSize(0,
452 iToolHeight,
453 rcClient.right,
454 lvHeight);
455
456 return 0;
457 }
458
459 LRESULT
460 CMainWindow::OnNotify(LPARAM lParam)
461 {
462 LPNMHDR NmHdr = (LPNMHDR)lParam;
463 LRESULT Ret;
464
465 switch (NmHdr->code)
466 {
467 case TVN_SELCHANGED:
468 {
469 UpdateToolbar();
470 break;
471 }
472
473 case NM_DBLCLK:
474 {
475 m_DeviceView->DisplayPropertySheet();
476 break;
477 }
478
479 case NM_RCLICK:
480 {
481 Ret = m_DeviceView->OnRightClick(NmHdr);
482 break;
483 }
484
485 case NM_RETURN:
486 {
487 m_DeviceView->DisplayPropertySheet();
488 break;
489 }
490
491 case TTN_GETDISPINFO:
492 {
493 LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT)lParam;
494
495 UINT_PTR idButton = lpttt->hdr.idFrom;
496 switch (idButton)
497 {
498 case IDC_PROPERTIES:
499 lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_PROPERTIES);
500 break;
501 case IDC_SCAN_HARDWARE:
502 lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_SCAN);
503 break;
504 case IDC_ENABLE_DRV:
505 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_ENABLE);
506 break;
507 case IDC_DISABLE_DRV:
508 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_DISABLE);
509 break;
510 case IDC_UPDATE_DRV:
511 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_UPDATE);
512 break;
513 case IDC_UNINSTALL_DRV:
514 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_UNINSTALL);
515 break;
516 }
517 break;
518 }
519 }
520
521 return 0;
522 }
523
524 LRESULT
525 CMainWindow::OnContext(LPARAM lParam)
526 {
527 return m_DeviceView->OnContextMenu(lParam);
528 }
529
530 LRESULT
531 CMainWindow::OnCommand(WPARAM wParam,
532 LPARAM /*lParam*/)
533 {
534 LRESULT RetCode = 0;
535 WORD Msg;
536
537 // Get the message
538 Msg = LOWORD(wParam);
539
540 switch (Msg)
541 {
542 case IDC_PROPERTIES:
543 case IDC_SCAN_HARDWARE:
544 case IDC_ENABLE_DRV:
545 case IDC_DISABLE_DRV:
546 case IDC_UPDATE_DRV:
547 case IDC_UNINSTALL_DRV:
548 case IDC_ADD_HARDWARE:
549 {
550 m_DeviceView->OnAction(Msg);
551 break;
552 }
553
554 case IDC_ACTIONMENU:
555 {
556 // Create a popup menu with all the actions for the selected node
557 HMENU hMenu = CreatePopupMenu();
558 m_DeviceView->CreateActionMenu(hMenu, true);
559
560 // Calculate where to put the menu
561 RECT rc;
562 GetMenuItemRect(m_hMainWnd, m_hMenu, 1, &rc);
563 LONG Height = rc.bottom - rc.top;
564
565 // Display the menu
566 TrackPopupMenuEx(hMenu,
567 TPM_RIGHTBUTTON,
568 rc.left,
569 rc.top + Height,
570 m_hMainWnd,
571 NULL);
572
573 DestroyMenu(hMenu);
574 break;
575 }
576
577 case IDC_DEVBYTYPE:
578 {
579 RefreshView(DevicesByType);
580 break;
581 }
582
583 case IDC_DEVBYCONN:
584 {
585 RefreshView(DevicesByConnection);
586 break;
587 }
588
589 case IDC_SHOWHIDDEN:
590 {
591 // Get the current state
592 UINT CurCheckState = GetMenuState(m_hMenu, IDC_SHOWHIDDEN, MF_BYCOMMAND);
593 if (CurCheckState == MF_CHECKED)
594 {
595 m_DeviceView->SetHiddenDevices(false);
596 CheckMenuItem(m_hMenu, IDC_SHOWHIDDEN, MF_BYCOMMAND | MF_UNCHECKED);
597 }
598 else if (CurCheckState == MF_UNCHECKED)
599 {
600 m_DeviceView->SetHiddenDevices(true);
601 CheckMenuItem(m_hMenu, IDC_SHOWHIDDEN, MF_BYCOMMAND | MF_CHECKED);
602 }
603 // Refresh the device view
604 m_DeviceView->Refresh(m_DeviceView->GetCurrentView(),
605 false,
606 true,
607 NULL);
608 break;
609 }
610
611 case IDC_ABOUT:
612 {
613 // Apportion blame
614 MessageBoxW(m_hMainWnd,
615 L"ReactOS Device Manager\r\nCopyright Ged Murphy 2015",
616 L"About",
617 MB_OK | MB_APPLMODAL);
618
619 // Set focus back to the treeview
620 m_DeviceView->SetFocus();
621 break;
622 }
623
624 case IDC_EXIT:
625 {
626 // Post a close message to the window
627 PostMessageW(m_hMainWnd,
628 WM_CLOSE,
629 0,
630 0);
631 break;
632 }
633
634 default:
635 // We didn't handle it
636 RetCode = -1;
637 break;
638 }
639
640 return RetCode;
641 }
642
643 LRESULT
644 CMainWindow::OnDestroy()
645 {
646 // Uninitialize the device view
647 m_DeviceView->Uninitialize();
648
649 // Kill the object
650 delete m_DeviceView;
651 m_DeviceView = NULL;
652
653 // Clear the user data pointer
654 SetWindowLongPtr(m_hMainWnd, GWLP_USERDATA, 0);
655
656 // Break the message loop
657 PostQuitMessage(0);
658
659 return 0;
660 }
661
662 LRESULT CALLBACK
663 CMainWindow::MainWndProc(HWND hwnd,
664 UINT msg,
665 WPARAM wParam,
666 LPARAM lParam)
667 {
668 CMainWindow *This;
669 LRESULT RetCode = 0;
670
671 // Get the object pointer from window context
672 This = (CMainWindow *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
673 if (This == NULL)
674 {
675 // Check that this isn't a create message
676 if (msg != WM_CREATE)
677 {
678 // Don't handle null info pointer
679 goto HandleDefaultMessage;
680 }
681 }
682
683 switch(msg)
684 {
685 case WM_CREATE:
686 {
687 // Get the object pointer from the create param
688 This = (CMainWindow *)((LPCREATESTRUCT)lParam)->lpCreateParams;
689
690 // Store the pointer in the window's global user data
691 SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)This);
692
693 // Call the create handler
694 RetCode = This->OnCreate(hwnd);
695 break;
696 }
697
698 case WM_SIZE:
699 {
700 RetCode = This->OnSize();
701 break;
702 }
703
704 case WM_NOTIFY:
705 {
706 RetCode = This->OnNotify(lParam);
707 break;
708 }
709
710 case WM_CONTEXTMENU:
711 {
712 RetCode = This->OnContext(lParam);
713 break;
714 }
715
716 case WM_MENUSELECT:
717 {
718 if (This->m_hStatusBar != NULL)
719 {
720 if (!This->MainWndMenuHint(LOWORD(wParam),
721 MainMenuHintTable,
722 sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
723 IDS_HINT_BLANK))
724 {
725 This->MainWndMenuHint(LOWORD(wParam),
726 SystemMenuHintTable,
727 sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
728 IDS_HINT_BLANK);
729 }
730 }
731
732 break;
733 }
734
735 case WM_COMMAND:
736 {
737 // Handle the command message
738 RetCode = This->OnCommand(wParam, lParam);
739 if (RetCode == -1)
740 {
741 // Hand it off to the default message handler
742 goto HandleDefaultMessage;
743 }
744 break;
745 }
746
747 case WM_ENTERMENULOOP:
748 {
749 This->UpdateStatusBar(true);
750 break;
751 }
752
753 case WM_EXITMENULOOP:
754 {
755 This->UpdateStatusBar(false);
756 break;
757 }
758
759 case WM_CLOSE:
760 {
761 // Destroy the main window
762 DestroyWindow(hwnd);
763 break;
764 }
765
766
767 case WM_DESTROY:
768 {
769 // Call the destroy handler
770 RetCode = This->OnDestroy();
771 break;
772 }
773
774 default:
775 {
776 HandleDefaultMessage:
777 RetCode = DefWindowProc(hwnd, msg, wParam, lParam);
778 break;
779 }
780 }
781
782 return RetCode;
783 }
784
785
786 //////// MOVE ME ////////////////
787
788 HINSTANCE g_hInstance = NULL;
789 HANDLE ProcessHeap = NULL;
790
791
792 BOOL
793 WINAPI
794 DeviceManager_ExecuteW(HWND /*hWndParent*/,
795 HINSTANCE hInst,
796 LPCWSTR /*lpMachineName*/,
797 int nCmdShow)
798 {
799 CMainWindow MainWindow;
800 INITCOMMONCONTROLSEX icex;
801 CAtlStringW szAppName;
802 int Ret = 1;
803
804 // Store the global values
805 g_hInstance = hInst;
806 ProcessHeap = GetProcessHeap();
807
808 // Initialize common controls
809 icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
810 icex.dwICC = ICC_BAR_CLASSES | ICC_COOL_CLASSES;
811 InitCommonControlsEx(&icex);
812
813 //__debugbreak();
814 g_hInstance = GetModuleHandle(L"devmgr.dll");
815
816 // Load the application name
817 if (szAppName.LoadStringW(g_hInstance, IDS_APPNAME))
818 {
819 // Initialize the main window
820 if (MainWindow.Initialize(szAppName, nCmdShow))
821 {
822 // Run the application
823 Ret = MainWindow.Run();
824
825 // Uninitialize the main window
826 MainWindow.Uninitialize();
827 }
828 }
829
830 return Ret;
831 }