CDeviceManager Class Reference

#include <MainWindow.h>

Collaboration diagram for CDeviceManager:

Public Member Functions
	CDeviceManager (void)
	~CDeviceManager (void)
bool	Create (_In_ HWND hWndParent, _In_ HINSTANCE hInst, _In_opt_z_ LPCWSTR lpMachineName, _In_ int nCmdShow)

Private Member Functions
bool	Initialize (_In_z_ LPCTSTR lpCaption, _In_ int nCmdShow)
int	Run ()
void	Uninitialize (void)
LRESULT	OnCreate (_In_ HWND hwnd)
LRESULT	OnDestroy (void)
LRESULT	OnSize (void)
LRESULT	OnNotify (_In_ LPARAM lParam)
LRESULT	OnContext (_In_ LPARAM lParam)
LRESULT	OnCommand (_In_ WPARAM wParam, LPARAM lParam)
void	OnActivate (void)
bool	CreateToolBar (void)
bool	CreateStatusBar (void)
void	UpdateToolbar (void)
bool	StatusBarLoadString (_In_ HWND hStatusBar, _In_ INT PartId, _In_ HINSTANCE hInstance, _In_ UINT uID)
void	UpdateStatusBar (_In_ bool InMenuLoop)
bool	MainWndMenuHint (_In_ WORD CmdId, _In_ const MENU_HINT *HintArray, _In_ DWORD HintsCount, _In_ UINT DefHintId)
bool	RefreshView (_In_ ViewType Type, _In_ bool ScanForChanges)

Static Private Member Functions
static LRESULT CALLBACK	MainWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

Private Attributes
CAtlStringW	m_szMainWndClass
CDeviceView *	m_DeviceView
HWND	m_hMainWnd
HWND	m_hStatusBar
HWND	m_hToolBar
HMENU	m_hMenu
int	m_CmdShow
BOOL	m_RefreshPending
bool	m_ClosePending

Detailed Description

Definition at line 10 of file MainWindow.h.

Constructor & Destructor Documentation

CDeviceManager()

CDeviceManager::CDeviceManager

(

void

)

Definition at line 80 of file MainWindow.cpp.

                                   :
    m_hMainWnd(NULL),
    m_hStatusBar(NULL),
    m_hToolBar(NULL),
    m_CmdShow(0),
    m_RefreshPending(false),
    m_ClosePending(false)
{
    m_szMainWndClass = L"DevMgmtWndClass";
}

~CDeviceManager()

CDeviceManager::~CDeviceManager

(

void

)

Definition at line 91 of file MainWindow.cpp.

{
}

Member Function Documentation

Create()

bool CDeviceManager::Create	(	_In_ HWND	hWndParent,
		_In_ HINSTANCE	hInst,
		_In_opt_z_ LPCWSTR	lpMachineName,
		_In_ int	nCmdShow
	)

Definition at line 96 of file MainWindow.cpp.

{
    CDeviceManager MainWindow;
    INITCOMMONCONTROLSEX icex;
    CAtlStringW szAppName;
    int Ret = 1;
 
    // Store the instances
    g_hParentInstance = hInst;
    g_hThisInstance = GetModuleHandleW(L"devmgr.dll");
 
    // Initialize common controls
    icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icex.dwICC = ICC_BAR_CLASSES | ICC_COOL_CLASSES;
    InitCommonControlsEx(&icex);
 
    // Load the application name
    if (szAppName.LoadStringW(g_hThisInstance, IDS_APPNAME))
    {
        // Initialize the main window
        if (MainWindow.Initialize(szAppName, nCmdShow))
        {
            // Run the application
            Ret = MainWindow.Run();
 
            // Uninitialize the main window
            MainWindow.Uninitialize();
        }
    }
 
    return (Ret == 0);
}

Referenced by DeviceManager_ExecuteW().

CreateStatusBar()

bool CDeviceManager::CreateStatusBar ( void  )

private

Definition at line 338 of file MainWindow.cpp.

{
    int StatWidths[] = {110, -1}; // widths of status bar
    bool bRet = FALSE;
 
    // Create the status bar
    m_hStatusBar = CreateWindowExW(0,
                                   STATUSCLASSNAME,
                                   NULL,
                                   WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
                                   0, 0, 0, 0,
                                   m_hMainWnd,
                                   (HMENU)IDC_STATUSBAR,
                                   g_hThisInstance,
                                   NULL);
    if (m_hStatusBar)
    {
        // Set the width
        bRet = (SendMessageW(m_hStatusBar,
                             SB_SETPARTS,
                             sizeof(StatWidths) / sizeof(int),
                             (LPARAM)StatWidths) != 0);
    }
 
    return bRet;
}

Referenced by OnCreate().

CreateToolBar()

bool CDeviceManager::CreateToolBar ( void  )

private

Definition at line 288 of file MainWindow.cpp.

{
    TBADDBITMAP TbAddBitmap;
 
    DWORD dwStyles = WS_CHILDWINDOW | TBSTYLE_FLAT | TBSTYLE_WRAPABLE | TBSTYLE_TOOLTIPS | CCS_NODIVIDER;
    DWORD dwExStyles = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR;
 
    // Create the toolbar window
    m_hToolBar = CreateWindowExW(dwExStyles,
                                 TOOLBARCLASSNAME,
                                 NULL,
                                 dwStyles,
                                 0, 0, 0, 0,
                                 m_hMainWnd,
                                 (HMENU)IDC_TOOLBAR,
                                 g_hThisInstance,
                                 NULL);
    if (m_hToolBar == NULL)
        return FALSE;
 
    // Don't show clipped buttons
    SendMessageW(m_hToolBar,
                 TB_SETEXTENDEDSTYLE,
                 0,
                 TBSTYLE_EX_HIDECLIPPEDBUTTONS);
 
    SendMessageW(m_hToolBar, TB_SETBITMAPSIZE, 0, MAKELONG(16, 16));
 
    // Set the struct size, the toobar needs this...
    SendMessageW(m_hToolBar,
                 TB_BUTTONSTRUCTSIZE,
                 sizeof(TBBUTTON),
                 0);
 
    TbAddBitmap.hInst = g_hThisInstance;
    TbAddBitmap.nID = IDB_TOOLBAR;
    SendMessageW(m_hToolBar, TB_ADDBITMAP, _countof(TbButtons), (LPARAM)&TbAddBitmap);
 
    SendMessageW(m_hToolBar, TB_ADDBUTTONSW, _countof(TbButtons), (LPARAM)TbButtons);
    SendMessageW(m_hToolBar, TB_AUTOSIZE, 0, 0);
 
    if (TRUE)
    {
        ShowWindow(m_hToolBar, SW_SHOW);
    }
 
    return TRUE;
}

Referenced by OnCreate().

Initialize()

bool CDeviceManager::Initialize ( _In_z_ LPCTSTR  lpCaption, _In_ int  nCmdShow  )

private

Definition at line 136 of file MainWindow.cpp.

{
    CAtlStringW szCaption;
    WNDCLASSEXW wc = {0};
 
    // Store the show window value
    m_CmdShow = nCmdShow;
 
    // Setup the window class struct
    wc.cbSize = sizeof(WNDCLASSEXW);
    wc.lpfnWndProc = MainWndProc;
    wc.hInstance = g_hThisInstance;
    wc.hIcon = LoadIcon(g_hThisInstance, MAKEINTRESOURCEW(IDI_MAIN_ICON));
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wc.lpszMenuName = MAKEINTRESOURCEW(IDM_MAINMENU);
    wc.lpszClassName = m_szMainWndClass;
    wc.hIconSm = (HICON)LoadImage(g_hThisInstance,
                                  MAKEINTRESOURCE(IDI_MAIN_ICON),
                                  IMAGE_ICON,
                                  GetSystemMetrics(SM_CXSMICON),
                                  GetSystemMetrics(SM_CYSMICON),
                                  0);
 
    // Register the window
    if (RegisterClassExW(&wc))
    {
        // Create the main window and store the object pointer
        m_hMainWnd = CreateWindowExW(WS_EX_WINDOWEDGE,
                                     m_szMainWndClass,
                                     lpCaption,
                                     WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                                     CW_USEDEFAULT,
                                     CW_USEDEFAULT,
                                     550,
                                     500,
                                     NULL,
                                     NULL,
                                     g_hThisInstance,
                                     this);
    }
 
    // Return creation result
    return !!(m_hMainWnd);
}

Referenced by Create().

MainWndMenuHint()

bool CDeviceManager::MainWndMenuHint ( _In_ WORD  CmdId, _In_ const MENU_HINT *  HintArray, _In_ DWORD  HintsCount, _In_ UINT  DefHintId  )

private

Definition at line 206 of file MainWindow.cpp.

{
    bool Found = false;
    const MENU_HINT *LastHint;
    UINT HintId = DefHintId;
 
    LastHint = HintArray + HintsCount;
    while (HintArray != LastHint)
    {
        if (HintArray->CmdId == CmdId)
        {
            HintId = HintArray->HintId;
            Found = true;
            break;
        }
        HintArray++;
    }
 
    StatusBarLoadString(m_hStatusBar,
                        SB_SIMPLEID,
                        g_hThisInstance,
                        HintId);
 
    return Found;
}

MainWndProc()

LRESULT CALLBACK CDeviceManager::MainWndProc ( HWND  hwnd, UINT  msg, WPARAM  wParam, LPARAM  lParam  )

staticprivate

Definition at line 721 of file MainWindow.cpp.

{
    CDeviceManager *This;
    LRESULT RetCode = 0;
 
    // Get the object pointer from window context
    This = (CDeviceManager *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (This == NULL)
    {
        // Check that this isn't a create message
        if (msg != WM_CREATE)
        {
            // Don't handle null info pointer
            goto HandleDefaultMessage;
        }
    }
 
    switch(msg)
    {
        case WM_CREATE:
        {
            // Get the object pointer from the create param
            This = (CDeviceManager *)((LPCREATESTRUCT)lParam)->lpCreateParams;
 
            // Store the pointer in the window's global user data
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)This);
 
            // Call the create handler
            RetCode = This->OnCreate(hwnd);
            break;
        }
 
        case WM_SIZE:
        {
            RetCode = This->OnSize();
            break;
        }
 
        case WM_NOTIFY:
        {
            RetCode = This->OnNotify(lParam);
            break;
        }
 
        case WM_CONTEXTMENU:
        {
            RetCode = This->OnContext(lParam);
            break;
        }
 
        case WM_MENUSELECT:
        {
            if (This->m_hStatusBar != NULL)
            {
                if (!This->MainWndMenuHint(LOWORD(wParam),
                                           MainMenuHintTable,
                                           sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
                                           IDS_HINT_BLANK))
                {
                    This->MainWndMenuHint(LOWORD(wParam),
                                          SystemMenuHintTable,
                                          sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
                                          IDS_HINT_BLANK);
                }
            }
 
            break;
        }
 
        case WM_COMMAND:
        {
            // Handle the command message
            RetCode = This->OnCommand(wParam, lParam);
            if (RetCode == -1)
            {
                // Hand it off to the default message handler
                goto HandleDefaultMessage;
            }
            break;
        }
 
        case WM_DEVICECHANGE:
        {
            if (wParam == DBT_DEVNODES_CHANGED)
            {
                //
                // The OS can send multiple change messages in quick succession. To avoid
                // refreshing multiple times (and to avoid waiting in the message thread)
                // we set a timer to run in 500ms, which should leave enough time for all
                // the messages to come through. Wrap so we don't set multiple timers
                //
                if (InterlockedCompareExchange((LONG *)&This->m_RefreshPending, TRUE, FALSE) == FALSE)
                {
                    SetTimer(hwnd, REFRESH_TIMER, 500, NULL);
                }
            }
            break;
        }
 
        case WM_TIMER:
        {
            if (wParam == REFRESH_TIMER)
            {
                // Schedule a refresh (this just creates a thread and returns)
                This->RefreshView(This->m_DeviceView->GetCurrentView(), true);
 
                // Cleanup the timer
                KillTimer(hwnd, REFRESH_TIMER);
 
                // Allow more change notifications
                InterlockedExchange((LONG *)&This->m_RefreshPending, FALSE);
            }
            break;
        }
 
        case WM_REFRESH_COMPLETE:
        {
            This->m_DeviceView->OnRefreshComplete();
 
            if (This->m_ClosePending && !This->m_DeviceView->IsRefreshing())
                DestroyWindow(hwnd);
            break;
        }
 
        case WM_ENTERMENULOOP:
        {
            This->UpdateStatusBar(true);
            break;
        }
 
        case WM_EXITMENULOOP:
        {
            This->UpdateStatusBar(false);
            break;
        }
 
        case WM_CLOSE:
        {
            // The refresh thread still uses the device view, so close once it posts back
            if (This->m_DeviceView->IsRefreshing())
            {
                This->m_ClosePending = true;
                break;
            }
 
            // Destroy the main window
            DestroyWindow(hwnd);
            break;
        }
 
        case WM_ACTIVATE:
        {
            if (LOWORD(hwnd))
                This->OnActivate();
            break;
        }
 
        case WM_DESTROY:
        {
            // Call the destroy handler
            RetCode = This->OnDestroy();
            break;
        }
 
        default:
        {
HandleDefaultMessage:
            RetCode = DefWindowProc(hwnd, msg, wParam, lParam);
            break;
        }
    }
 
    return RetCode;
}

Referenced by Initialize().

OnActivate()

void CDeviceManager::OnActivate ( void  )

private

Definition at line 696 of file MainWindow.cpp.

{
    m_DeviceView->SetFocus();
}

OnCommand()

LRESULT CDeviceManager::OnCommand ( _In_ WPARAM  wParam, LPARAM  lParam  )

private

Definition at line 576 of file MainWindow.cpp.

{
    LRESULT RetCode = 0;
    WORD Msg;
 
    // Get the message
    Msg = LOWORD(wParam);
 
    switch (Msg)
    {
        case IDM_PROPERTIES:
        case IDM_SCAN_HARDWARE:
        case IDM_ENABLE_DRV:
        case IDM_DISABLE_DRV:
        case IDM_UPDATE_DRV:
        case IDM_UNINSTALL_DRV:
        case IDM_ADD_HARDWARE:
        {
            m_DeviceView->OnAction(Msg);
            break;
        }
 
        case IDM_ACTIONMENU:
        {
            // Create a popup menu with all the actions for the selected node
            HMENU hMenu = CreatePopupMenu();
            m_DeviceView->CreateActionMenu(hMenu, true);
 
            // Calculate where to put the menu
            RECT rc;
            GetMenuItemRect(m_hMainWnd, m_hMenu, 1, &rc);
            LONG Height = rc.bottom - rc.top;
 
            // Display the menu
            TrackPopupMenuEx(hMenu,
                             TPM_RIGHTBUTTON,
                             rc.left,
                             rc.top + Height,
                             m_hMainWnd,
                             NULL);
 
            DestroyMenu(hMenu);
            break;
        }
 
        case IDM_DEVBYTYPE:
        {
            RefreshView(DevicesByType, false);
            break;
        }
 
        case IDM_DEVBYCONN:
        {
            RefreshView(DevicesByConnection, false);
            break;
        }
 
        case IDM_RESBYTYPE:
        {
            RefreshView(ResourcesByType, false);
            break;
        }
 
        case IDM_SHOWHIDDEN:
        {
            // Get the current state
            UINT CurCheckState = GetMenuState(m_hMenu, IDM_SHOWHIDDEN, MF_BYCOMMAND);
            if (CurCheckState == MF_CHECKED)
            {
                m_DeviceView->SetHiddenDevices(false);
                CheckMenuItem(m_hMenu, IDM_SHOWHIDDEN, MF_BYCOMMAND | MF_UNCHECKED);
            }
            else if (CurCheckState == MF_UNCHECKED)
            {
                m_DeviceView->SetHiddenDevices(true);
                CheckMenuItem(m_hMenu, IDM_SHOWHIDDEN, MF_BYCOMMAND | MF_CHECKED);
            }
            // Refresh the device view
            RefreshView(m_DeviceView->GetCurrentView(), false);
            break;
        }
 
        case IDM_ABOUT:
        {
            CAtlStringW szAppName;
            CAtlStringW szAppAuthors;
 
            if (!szAppName.LoadStringW(g_hThisInstance, IDS_APPNAME))
                szAppName = L"ReactOS Device Manager";
            if (!szAppAuthors.LoadStringW(g_hThisInstance, IDS_APP_AUTHORS))
                szAppAuthors = L"";
            ShellAboutW(m_hMainWnd, szAppName, szAppAuthors,
                        LoadIconW(g_hThisInstance, MAKEINTRESOURCEW(IDI_MAIN_ICON)));
 
            // Set focus back to the treeview
            m_DeviceView->SetFocus();
            break;
        }
 
        case IDM_EXIT:
        {
            // Post a close message to the window
            PostMessageW(m_hMainWnd,
                         WM_CLOSE,
                         0,
                         0);
            break;
        }
 
        default:
            // We didn't handle it
            RetCode = -1;
            break;
    }
 
    return RetCode;
}

OnContext()

LRESULT CDeviceManager::OnContext ( _In_ LPARAM  lParam )

private

Definition at line 570 of file MainWindow.cpp.

{
    return m_DeviceView->OnContextMenu(lParam);
}

OnCreate()

LRESULT CDeviceManager::OnCreate ( _In_ HWND  hwnd )

private

Definition at line 433 of file MainWindow.cpp.

{
    LRESULT RetCode;
 
    RetCode = -1;
    m_hMainWnd = hwnd;
 
    // Store a handle to the main menu
    m_hMenu = GetMenu(m_hMainWnd);
 
    // Create the toolbar and statusbar
    if (CreateToolBar() && CreateStatusBar())
    {
        // Create the device view object
        m_DeviceView = new CDeviceView(m_hMainWnd);
        if (m_DeviceView->Initialize())
        {
            // Do the initial scan
            RefreshView(m_DeviceView->GetCurrentView(), true);
 
            // Display the window according to the user request
            ShowWindow(hwnd, m_CmdShow);
            RetCode = 0;
        }
    }
 
    return RetCode;
}

OnDestroy()

LRESULT CDeviceManager::OnDestroy ( void  )

private

Definition at line 702 of file MainWindow.cpp.

{
    // Uninitialize the device view
    m_DeviceView->Uninitialize();
 
    // Kill the object
    delete m_DeviceView;
    m_DeviceView = NULL;
 
    // Clear the user data pointer
    SetWindowLongPtr(m_hMainWnd, GWLP_USERDATA, 0);
 
    // Break the message loop
    PostQuitMessage(0);
 
    return 0;
}

OnNotify()

LRESULT CDeviceManager::OnNotify ( _In_ LPARAM  lParam )

private

Definition at line 498 of file MainWindow.cpp.

{
    LPNMHDR NmHdr = (LPNMHDR)lParam;
    LRESULT Ret = 0;
 
    switch (NmHdr->code)
    {
        case TVN_SELCHANGED:
        {
            HMENU hMenu = GetSubMenu(m_hMenu, 1);
            for (INT i = GetMenuItemCount(hMenu) - 1; i >= 0; i--)
            {
                DeleteMenu(hMenu, i, MF_BYPOSITION);
            }
            m_DeviceView->CreateActionMenu(hMenu, true);
            UpdateToolbar();
            break;
        }
 
        case NM_DBLCLK:
        {
            Ret = m_DeviceView->OnDoubleClick(NmHdr);
            break;
        }
 
        case NM_RCLICK:
        {
            Ret = m_DeviceView->OnRightClick(NmHdr);
            break;
        }
 
        case NM_RETURN:
        {
            m_DeviceView->DisplayPropertySheet();
            break;
        }
 
        case TTN_GETDISPINFO:
        {
             LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT)lParam;
             lpttt->hinst = g_hThisInstance;
 
            UINT_PTR idButton = lpttt->hdr.idFrom;
            switch (idButton)
            {
                case IDM_PROPERTIES:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_PROPERTIES);
                    break;
                case IDM_SCAN_HARDWARE:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_SCAN);
                    break;
                case IDM_ENABLE_DRV:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_ENABLE);
                    break;
                case IDM_DISABLE_DRV:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_DISABLE);
                    break;
                case IDM_UPDATE_DRV:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_UPDATE);
                    break;
                case IDM_UNINSTALL_DRV:
                    lpttt->lpszText = MAKEINTRESOURCEW(IDS_TOOLTIP_UNINSTALL);
                    break;
            }
            break;
        }
    }
 
    return Ret;
}

OnSize()

LRESULT CDeviceManager::OnSize ( void  )

private

Definition at line 463 of file MainWindow.cpp.

{
    RECT rcClient, rcTool, rcStatus;
    INT lvHeight, iToolHeight, iStatusHeight;
 
    // Autosize the toolbar
    SendMessage(m_hToolBar, TB_AUTOSIZE, 0, 0);
 
    // Get the toolbar rect and save the height
    GetWindowRect(m_hToolBar, &rcTool);
    iToolHeight = rcTool.bottom - rcTool.top;
 
    // Resize the status bar
    SendMessage(m_hStatusBar, WM_SIZE, 0, 0);
 
    // Get the statusbar rect and save the height
    GetWindowRect(m_hStatusBar, &rcStatus);
    iStatusHeight = rcStatus.bottom - rcStatus.top;
 
    // Get the full client rect
    GetClientRect(m_hMainWnd, &rcClient);
 
    // Calculate the remaining height for the treeview
    lvHeight = rcClient.bottom - iToolHeight - iStatusHeight;
 
    // Resize the device view
    m_DeviceView->OnSize(0,
                         iToolHeight,
                         rcClient.right,
                         lvHeight);
 
    return 0;
}

RefreshView()

bool CDeviceManager::RefreshView ( _In_ ViewType  Type, _In_ bool  ScanForChanges  )

private

Definition at line 245 of file MainWindow.cpp.

{
    UINT CheckId = 0;
 
    // Refreshed the cached view
    m_DeviceView->Refresh(Type, ScanForChanges, true);
 
    // Get the menu item id
    switch (Type)
    {
        case DevicesByType:
            CheckId = IDM_DEVBYTYPE;
            break;
 
        case DevicesByConnection:
            CheckId = IDM_DEVBYCONN;
            break;
 
        case ResourcesByType:
            CheckId = IDM_RESBYTYPE;
            break;
 
        case ResourcesByConnection:
            CheckId = IDM_RESBYCONN;
            break;
 
        default:
            ATLASSERT(FALSE);
            break;
    }
 
    // Set the new check item
    CheckMenuRadioItem(m_hMenu,
                       IDM_DEVBYTYPE,
                       IDM_RESBYCONN,
                       CheckId,
                       MF_BYCOMMAND);
 
    return true;
}

Referenced by OnCommand(), and OnCreate().

Run()

int CDeviceManager::Run ( void  )

private

Definition at line 191 of file MainWindow.cpp.

{
    MSG Msg;
 
    // Pump the message queue
    while (GetMessageW(&Msg, NULL, 0, 0 ) != 0)
    {
        TranslateMessage(&Msg);
        DispatchMessageW(&Msg);
    }
 
    return 0;
}

Referenced by Create().

StatusBarLoadString()

bool CDeviceManager::StatusBarLoadString ( _In_ HWND  hStatusBar, _In_ INT  PartId, _In_ HINSTANCE  hInstance, _In_ UINT  uID  )

private

Definition at line 411 of file MainWindow.cpp.

{
    CAtlStringW szMessage;
    bool bRet = false;
 
    // Load the string
    if (szMessage.LoadStringW(hInstance, uID))
    {
        // Show the string on the status bar
        bRet = (SendMessageW(hStatusBar,
                             SB_SETTEXT,
                             (WPARAM)PartId,
                             (LPARAM)szMessage.GetBuffer()) != 0);
    }
 
    return bRet;
}

Referenced by MainWndMenuHint().

Uninitialize()

void CDeviceManager::Uninitialize ( void  )

private

Definition at line 184 of file MainWindow.cpp.

{
    // Unregister the window class
    UnregisterClassW(m_szMainWndClass, g_hThisInstance);
}

Referenced by Create().

UpdateStatusBar()

void CDeviceManager::UpdateStatusBar ( _In_ bool  InMenuLoop )

private

Definition at line 236 of file MainWindow.cpp.

{
    SendMessageW(m_hStatusBar,
                 SB_SIMPLE,
                 (WPARAM)InMenuLoop,
                 0);
}

UpdateToolbar()

void CDeviceManager::UpdateToolbar ( void  )

private

Definition at line 365 of file MainWindow.cpp.

{
    WORD State;
 
    CNode *Node = m_DeviceView->GetSelectedNode();
 
    // properties button
    if (Node->HasProperties())
    {
        State = TBSTATE_ENABLED;
    }
    else
    {
        State = TBSTATE_HIDDEN;
    }
    SendMessageW(m_hToolBar, TB_SETSTATE, IDM_PROPERTIES, MAKELPARAM(State, 0));
    SendMessageW(m_hToolBar, TB_SETSTATE, IDM_UPDATE_DRV, MAKELPARAM(State, 0)); //hack
    SendMessageW(m_hToolBar, TB_SETSTATE, IDM_UNINSTALL_DRV, MAKELPARAM(State, 0)); // hack
 
    // enable driver button
    if (Node->GetNodeType() == DeviceNode &&
        dynamic_cast<CDeviceNode *>(Node)->IsDisabled())
    {
        State = TBSTATE_ENABLED;
    }
    else
    {
        State = TBSTATE_HIDDEN;
    }
    SendMessageW(m_hToolBar, TB_SETSTATE, IDM_ENABLE_DRV, MAKELPARAM(State, 0));
 
    // disable driver button
    if (Node->GetNodeType() == DeviceNode &&
        dynamic_cast<CDeviceNode *>(Node)->CanDisable() &&
        !dynamic_cast<CDeviceNode *>(Node)->IsDisabled())
    {
        State = TBSTATE_ENABLED;
    }
    else
    {
        State = TBSTATE_HIDDEN;
    }
    SendMessageW(m_hToolBar, TB_SETSTATE, IDM_DISABLE_DRV, MAKELPARAM(State, 0));
}

Referenced by OnNotify().

Member Data Documentation

m_ClosePending

bool CDeviceManager::m_ClosePending

private

Definition at line 20 of file MainWindow.h.

m_CmdShow

int CDeviceManager::m_CmdShow

private

Definition at line 18 of file MainWindow.h.

Referenced by Initialize(), and OnCreate().

m_DeviceView

CDeviceView* CDeviceManager::m_DeviceView

private

Definition at line 13 of file MainWindow.h.

Referenced by OnActivate(), OnCommand(), OnContext(), OnCreate(), OnDestroy(), OnNotify(), OnSize(), RefreshView(), and UpdateToolbar().

m_hMainWnd

HWND CDeviceManager::m_hMainWnd

private

Definition at line 14 of file MainWindow.h.

Referenced by CreateStatusBar(), CreateToolBar(), Initialize(), OnCommand(), OnCreate(), OnDestroy(), and OnSize().

m_hMenu

HMENU CDeviceManager::m_hMenu

private

Definition at line 17 of file MainWindow.h.

Referenced by OnCommand(), OnCreate(), OnNotify(), and RefreshView().

m_hStatusBar

HWND CDeviceManager::m_hStatusBar

private

Definition at line 15 of file MainWindow.h.

Referenced by CreateStatusBar(), MainWndMenuHint(), OnSize(), and UpdateStatusBar().

m_hToolBar

HWND CDeviceManager::m_hToolBar

private

Definition at line 16 of file MainWindow.h.

Referenced by CreateToolBar(), OnSize(), and UpdateToolbar().

m_RefreshPending

BOOL CDeviceManager::m_RefreshPending

private

Definition at line 19 of file MainWindow.h.

m_szMainWndClass

CAtlStringW CDeviceManager::m_szMainWndClass

private

Definition at line 12 of file MainWindow.h.

Referenced by CDeviceManager(), Initialize(), and Uninitialize().

---

The documentation for this class was generated from the following files:

• dll/win32/devmgr/devmgmt/MainWindow.h
• dll/win32/devmgr/devmgmt/MainWindow.cpp