//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1997 - 1999
//
//  File:       hotplug.c
//
//--------------------------------------------------------------------------

#include "HotPlug.h"

TCHAR szUnknown[64];

TCHAR szHotPlugFlags[]=TEXT("HotPlugFlags");
TCHAR HOTPLUG_NOTIFY_CLASS_NAME[] = TEXT("HotPlugNotifyClass");


typedef int
(*PDEVICEPROPERTIES)(
                    HWND hwndParent,
                    LPTSTR MachineName,
                    LPTSTR DeviceID,
                    BOOL ShowDeviceTree
                    );


//
// colors used to highlight removal relationships for selected device
//
COLORREF RemovalImageBkColor;
COLORREF NormalImageBkColor;
COLORREF RemovalTextColor;

HWND g_hwndNotify = NULL;
HMODULE hDevMgr=NULL;
PDEVICEPROPERTIES pDeviceProperties = NULL;

#define IDH_DISABLEHELP         ((DWORD)(-1))
#define IDH_hwwizard_devices_list       15301   //  (SysTreeView32)
#define idh_hwwizard_stop               15305   // "&Stop" (Button)
#define idh_hwwizard_display_components 15307   //  "&Display device components" (Button)
#define idh_hwwizard_properties         15311   //  "&Properties" (Button)
#define idh_hwwizard_close              15309   //  "&Close" (Button)

DWORD UnplugtHelpIDs[] = {
    IDC_STOPDEVICE,    idh_hwwizard_stop,               // "&Stop" (Button)
    IDC_PROPERTIES,    idh_hwwizard_properties,         //  "&Properties" (Button)
    IDC_VIEWOPTION,    idh_hwwizard_display_components, //  "&Display device components" (Button)
    IDC_DEVICETREE,    IDH_hwwizard_devices_list,       // "" (SysTreeView32)
    IDCLOSE,           idh_hwwizard_close,
    IDC_MACHINENAME,   NO_HELP,
    IDC_HDWDEVICES,    NO_HELP,
    IDC_NOHELP1,       NO_HELP,
    IDC_NOHELP2,       NO_HELP,
    IDC_NOHELP3,       NO_HELP,
    IDC_DEVICEDESC,    NO_HELP,
    0,0
};

void
OnRemoveDevice(
              HWND hDlg,
              PDEVICETREE DeviceTree,
              BOOL Eject
              )
{
    DEVINST DeviceInstance;
    CONFIGRET ConfigRet;
    HTREEITEM hTreeItem;
    PDEVTREENODE DeviceTreeNode;
    PTCHAR DeviceName;

    DeviceTreeNode = DeviceTree->ChildRemovalList;

    if (!DeviceTreeNode) {

        return;
    }

    //
    // Confirm with the user that they really want
    // to remove this device and all of its attached devices.
    // The dialog returns standard IDOK, IDCANCEL etc. for results.
    // if anything besides IDOK  don't do anything.
    //

    DialogBoxParam(hHotPlug,
                   MAKEINTRESOURCE(DLG_CONFIRMREMOVE),
                   hDlg,
                   (DLGPROC)RemoveConfirmDlgProc,
                   (LPARAM)DeviceTree
                  );

    return;
}




void
OnTvnSelChanged(
               PDEVICETREE DeviceTree,
               NM_TREEVIEW *nmTreeView
               )
{
    PDEVTREENODE DeviceTreeNode = (PDEVTREENODE)(nmTreeView->itemNew.lParam);
    PTCHAR DeviceName, ProblemText;
    ULONG DevNodeStatus, Problem;
    CONFIGRET ConfigRet;
    TCHAR Buffer[MAX_PATH*2];

    if (DeviceTree->RedrawWait) {

        return;
    }


    //
    // Clear Removal list for previously selected Node
    //
    ClearRemovalList(DeviceTree);


    //
    // Save the selected treenode.
    //
    DeviceTree->SelectedTreeNode = DeviceTreeNode;

    //
    // No device is selected
    //
    if (!DeviceTreeNode) {

        EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_STOPDEVICE), FALSE);
        EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_PROPERTIES), FALSE);
        SetDlgItemText(DeviceTree->hDlg, IDC_DEVICEDESC, TEXT(""));
        return;
    }

    //
    // reset the text for the selected item
    //
    DeviceName = FetchDeviceName(DeviceTreeNode);

    if (!DeviceName) {

        DeviceName = szUnknown;
    }

    wsprintf(Buffer,
             TEXT("%s %s"),
             DeviceName,
             DeviceTreeNode->Location  ? DeviceTreeNode->Location : TEXT("")
            );

    SetDlgItemText(DeviceTree->hDlg, IDC_DEVICEDESC, Buffer);

    //
    // Turn on the stop\eject button, and set text accordingly.
    //
    ConfigRet = CM_Get_DevNode_Status_Ex(&DevNodeStatus,
                                         &Problem,
                                         DeviceTreeNode->DevInst,
                                         0,
                                         DeviceTree->hMachine
                                        );
    if (ConfigRet != CR_SUCCESS) {

        DevNodeStatus = 0;
        Problem = 0;
    }

    //
    // Any removable (but not surprise removable) device is OK, except
    // if the user already removed it.
    //
    if (Problem != CM_PROB_HELD_FOR_EJECT) {

        EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_STOPDEVICE), TRUE);

    } else {

        EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_STOPDEVICE), FALSE);
    }

    EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_PROPERTIES), TRUE);

    //
    // reset the overlay icons if device state has changed
    //
    if (DeviceTreeNode->Problem != Problem || DeviceTreeNode->DevNodeStatus != DevNodeStatus) {

        TV_ITEM tv;

        tv.mask = TVIF_STATE;
        tv.stateMask = TVIS_OVERLAYMASK;
        tv.hItem = DeviceTreeNode->hTreeItem;

        if (DeviceTreeNode->Problem == CM_PROB_DISABLED) {

            tv.state = INDEXTOOVERLAYMASK(IDI_DISABLED_OVL - IDI_CLASSICON_OVERLAYFIRST + 1);

        } else if (DeviceTreeNode->Problem) {

            tv.state = INDEXTOOVERLAYMASK(IDI_PROBLEM_OVL - IDI_CLASSICON_OVERLAYFIRST + 1);

        } else {

            tv.state = INDEXTOOVERLAYMASK(0);
        }

        TreeView_SetItem(DeviceTree->hwndTree, &tv);
    }


    //
    // Starting from the TopLevel removal node, build up the removal lists
    //
    DeviceTreeNode = TopLevelRemovalNode(DeviceTree, DeviceTreeNode);

    //
    // Add devices to ChildRemoval list
    //
    DeviceTree->ChildRemovalList = DeviceTreeNode;
    DeviceTreeNode->NextChildRemoval = DeviceTreeNode;
    InvalidateTreeItemRect(DeviceTree->hwndTree, DeviceTreeNode->hTreeItem);
    AddChildRemoval(DeviceTree, &DeviceTreeNode->ChildSiblingList);

    //
    // Add eject amd removal relations
    //
    AddEjectToRemoval(DeviceTree);
}




int
OnCustomDraw(
            HWND hDlg,
            PDEVICETREE DeviceTree,
            LPNMTVCUSTOMDRAW nmtvCustomDraw
            )
{
    PDEVTREENODE DeviceTreeNode = (PDEVTREENODE)(nmtvCustomDraw->nmcd.lItemlParam);

    if (nmtvCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT) {
        return CDRF_NOTIFYITEMDRAW;
    }

    //
    // If this node is in the Removal list, then do special
    // highlighting.
    //

    if (DeviceTreeNode->NextChildRemoval) {

        //
        // set text color if its not the selected item
        //

        if (DeviceTree->SelectedTreeNode != DeviceTreeNode) {
            nmtvCustomDraw->clrText = RemovalTextColor;
        }

        //
        // Highlight the image-icon background
        //

        ImageList_SetBkColor(DeviceTree->ClassImageList.ImageList,
                             RemovalImageBkColor
                            );
    } else {

        //
        // Normal image-icon background
        //

        ImageList_SetBkColor(DeviceTree->ClassImageList.ImageList,
                             NormalImageBkColor
                            );
    }

    return CDRF_DODEFAULT;
}



void
OnSysColorChange(
                HWND hDlg,
                PDEVICETREE DeviceTree
                )
{
    COLORREF ColorWindow, ColorHighlight;
    BYTE Red, Green, Blue;

    //
    // Fetch the colors used for removal highlighting
    //

    ColorWindow = GetSysColor(COLOR_WINDOW);
    ColorHighlight = GetSysColor(COLOR_HIGHLIGHT);

    Red = (BYTE)(((WORD)GetRValue(ColorWindow) + (WORD)GetRValue(ColorHighlight)) >> 1);
    Green = (BYTE)(((WORD)GetGValue(ColorWindow) + (WORD)GetGValue(ColorHighlight)) >> 1);
    Blue = (BYTE)(((WORD)GetBValue(ColorWindow) + (WORD)GetBValue(ColorHighlight)) >> 1);

    RemovalImageBkColor = RGB(Red, Green, Blue);
    RemovalTextColor = ColorHighlight;
    NormalImageBkColor = ColorWindow;


    // Update the ImageList Background color
    if (DeviceTree->ClassImageList.cbSize) {
        ImageList_SetBkColor(DeviceTree->ClassImageList.ImageList,
                             ColorWindow
                            );
    }
}


void
OnTvnItemExpanding(
                  HWND hDlg,
                  PDEVICETREE DeviceTree,
                  NM_TREEVIEW *nmTreeView

                  )
{
    PDEVTREENODE DeviceTreeNode = (PDEVTREENODE)(nmTreeView->itemNew.lParam);

    //
    // don't allow collapse of root items with children
    //

    if (!DeviceTreeNode->ParentNode &&
        (nmTreeView->action == TVE_COLLAPSE ||
         nmTreeView->action == TVE_COLLAPSERESET ||
         (nmTreeView->action == TVE_TOGGLE &&
          (nmTreeView->itemNew.state & TVIS_EXPANDED))) ) {
        SetDlgMsgResult(hDlg, WM_NOTIFY, TRUE);
    } else {
        SetDlgMsgResult(hDlg, WM_NOTIFY, FALSE);
    }
}




void
OnContextMenu(
             HWND hDlg,
             PDEVICETREE DeviceTree
             )
{
    int IdCmd;
    CONFIGRET ConfigRet;
    POINT ptPopup;
    RECT rect;
    HMENU hMenu;
    PDEVTREENODE DeviceTreeNode;
    TCHAR Buffer[MAX_PATH];

    DeviceTreeNode = DeviceTree->SelectedTreeNode;
    if (!DeviceTreeNode) {
        return;
    }

    TreeView_GetItemRect(DeviceTree->hwndTree,
                         DeviceTreeNode->hTreeItem,
                         &rect,
                         TRUE
                        );

    ptPopup.x = (rect.left+rect.right)/2;
    ptPopup.y = (rect.top+rect.bottom)/2;
    ClientToScreen(DeviceTree->hwndTree, &ptPopup);

    hMenu = CreatePopupMenu();
    if (!hMenu) {
        return;
    }

    //
    // if device is running add stop item
    //
    if (DeviceTreeNode->DevNodeStatus & DN_STARTED) {

        LoadString(hHotPlug,
                   IDS_STOP,
                   Buffer,
                   SIZECHARS(Buffer)
                  );

        AppendMenu(hMenu, MF_STRING, IDC_STOPDEVICE, Buffer);
    }

    //
    // add Properties item (link to device mgr).
    //
    LoadString(hHotPlug,
               IDS_PROPERTIES,
               Buffer,
               SIZECHARS(Buffer)
              );

    AppendMenu(hMenu, MF_STRING, IDC_PROPERTIES, Buffer);

    IdCmd = TrackPopupMenu(hMenu,
                           TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN | TPM_NONOTIFY,
                           ptPopup.x,
                           ptPopup.y,
                           0,
                           hDlg,
                           NULL
                          );

    DestroyMenu(hMenu);

    if (!IdCmd) {

        return;
    }

    switch (IdCmd) {
    case IDC_STOPDEVICE:
        OnRemoveDevice(hDlg, DeviceTree, FALSE);
        break;

    case IDC_PROPERTIES: {
            if (pDeviceProperties) {
                (*pDeviceProperties)(
                                    hDlg,
                                    DeviceTree->hMachine ? DeviceTree->MachineName : NULL,
                                    DeviceTreeNode->InstanceId,
                                    FALSE
                                    );
            }
        }
        break;
    }

    return;
}

void
OnRightClick(
            HWND hDlg,
            PDEVICETREE DeviceTree,
            NMHDR * nmhdr
            )
{
    DWORD dwPos;
    TV_ITEM tvi;
    TV_HITTESTINFO tvht;
    PDEVTREENODE DeviceTreeNode;

    if (nmhdr->hwndFrom != DeviceTree->hwndTree) {
        return;
    }

    dwPos = GetMessagePos();

    tvht.pt.x = LOWORD(dwPos);
    tvht.pt.y = HIWORD(dwPos);

    ScreenToClient(DeviceTree->hwndTree, &tvht.pt);
    tvi.hItem = TreeView_HitTest(DeviceTree->hwndTree, &tvht);
    if (!tvi.hItem) {
        return;
    }


    tvi.mask = TVIF_PARAM;
    if (!TreeView_GetItem(DeviceTree->hwndTree, &tvi)) {
        return;
    }


    DeviceTreeNode = (PDEVTREENODE)tvi.lParam;
    if (!DeviceTreeNode) {
        return;
    }

    //
    // Make the current right click item, the selected item
    //
    if (DeviceTreeNode != DeviceTree->SelectedTreeNode) {
        TreeView_SelectItem(DeviceTree->hwndTree, DeviceTreeNode->hTreeItem);
    }

}

void
OnViewOptionClicked(
                   HWND hDlg,
                   PDEVICETREE DeviceTree
                   )
{
    BOOL bChecked;
    DWORD HotPlugFlags, NewFlags;
    HKEY hKey = NULL;
    PDEVTREENODE DeviceTreeNode;
    DEVINST DeviceInstance;
    HTREEITEM hTreeItem;
    TV_ITEM TvItem;

    //
    // checked means "show complex view"
    //
    bChecked = IsDlgButtonChecked(hDlg, IDC_VIEWOPTION);


    //
    // Update HotPlugs registry if needed.
    //
    NewFlags = HotPlugFlags = GetHotPlugFlags(&hKey);

    if (hKey) {

        if (bChecked) {

            NewFlags |= HOTPLUG_REGFLAG_VIEWALL;
        } else {

            NewFlags &= ~HOTPLUG_REGFLAG_VIEWALL;
        }

        if (NewFlags != HotPlugFlags) {

            RegSetValueEx(hKey,
                          szHotPlugFlags,
                          0,
                          REG_DWORD,
                          (LPBYTE)&NewFlags,
                          sizeof(NewFlags)
                         );
        }

        if (hKey) {

            RegCloseKey(hKey);
        }
    }

    if (!DeviceTree->ComplexView && bChecked) {

        DeviceTree->ComplexView = TRUE;
    } else if (DeviceTree->ComplexView && !bChecked) {

        DeviceTree->ComplexView = FALSE;
    } else {

        // we are in the correct state, nothing to do.
        return;
    }

    //
    // redraw the entire tree.
    //
    RefreshTree(DeviceTree);

    return;
}

LRESULT
hotplugNotifyWndProc(
                    HWND hWnd,
                    UINT uMsg,
                    WPARAM wParam,
                    LPARAM lParam
                    )
{
    HWND hMainWnd;
    hMainWnd = (HWND)GetWindowLongPtr(hWnd, GWLP_USERDATA);

    switch (uMsg) {
    case WM_CREATE:
        {
            hMainWnd =  (HWND)((CREATESTRUCT*)lParam)->lpCreateParams;
            SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)hMainWnd);
            break;
        }

    case WM_DEVICECHANGE:
        {
            if (DBT_DEVNODES_CHANGED == wParam) {
                // While we are in WM_DEVICECHANGE context,
                // no CM apis can be called because it would
                // deadlock. Here, we schedule a timer so that
                // we can handle the message later on.
                SetTimer(hMainWnd, TIMERID_DEVICECHANGE, 1000, NULL);
            }

            break;
        }

    default:
        break;
    }

    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

BOOL
CreateNotifyWindow(
                  HWND hWnd
                  )
{
    WNDCLASS wndClass;

    if (!GetClassInfo(hHotPlug, HOTPLUG_NOTIFY_CLASS_NAME, &wndClass)) {

        memset(&wndClass, 0, sizeof(wndClass));
        wndClass.lpfnWndProc = hotplugNotifyWndProc;
        wndClass.hInstance = hHotPlug;
        wndClass.lpszClassName = HOTPLUG_NOTIFY_CLASS_NAME;

        if (!RegisterClass(&wndClass)) {

            return FALSE;
        }
    }

    g_hwndNotify = CreateWindowEx(WS_EX_TOOLWINDOW,
                                  HOTPLUG_NOTIFY_CLASS_NAME,
                                  TEXT(""),
                                  WS_DLGFRAME | WS_BORDER | WS_DISABLED,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  0,
                                  0,
                                  NULL,
                                  NULL,
                                  hHotPlug,
                                  (void *)hWnd
                                 );

    return(NULL != g_hwndNotify);
}

BOOL
InitDevTreeDlgProc(
                  HWND hDlg,
                  PDEVICETREE DeviceTree
                  )
{
    CONFIGRET ConfigRet;
    HWND hwndTree;
    HTREEITEM hTreeItem;
    DEVINST DeviceInstance;
    DWORD HotPlugFlags;
    HICON hIcon;
    HWND hwndParent;

    DeviceTree->AllowRefresh = TRUE;

    CreateNotifyWindow(hDlg);

    hDevMgr = LoadLibrary(TEXT("devmgr.dll"));

    if (hDevMgr) {

        pDeviceProperties = (PDEVICEPROPERTIES)GetProcAddress(hDevMgr, "DevicePropertiesW");
    }

    hIcon = LoadIcon(hHotPlug,MAKEINTRESOURCE(IDI_HOTPLUGICON));
    if (hIcon) {

        SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
        SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
    }

    hwndParent = GetParent(hDlg);

    if (hwndParent) {

        SendMessage(hwndParent, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
        SendMessage(hwndParent, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
    }

    DeviceTree->hDlg     = hDlg;
    DeviceTree->hwndTree = hwndTree = GetDlgItem(hDlg, IDC_DEVICETREE);

    LoadString(hHotPlug,
               IDS_UNKNOWN,
               (PTCHAR)szUnknown,
               SIZECHARS(szUnknown)
              );

    if (DeviceTree->hMachine) {

        SetDlgItemText(hDlg, IDC_MACHINENAME, DeviceTree->MachineName);
    }

    //
    // Disable the Stop button, until an item is selected.
    //
    EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_STOPDEVICE), FALSE);

    EnableWindow(GetDlgItem(DeviceTree->hDlg, IDC_PROPERTIES), FALSE);

    // Get the Class Icon Image Lists
    DeviceTree->ClassImageList.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
    if (SetupDiGetClassImageList(&DeviceTree->ClassImageList)) {

        TreeView_SetImageList(hwndTree, DeviceTree->ClassImageList.ImageList, TVSIL_NORMAL);

    } else {

        DeviceTree->ClassImageList.cbSize = 0;
    }

    OnSysColorChange(hDlg, DeviceTree);

    HotPlugFlags = GetHotPlugFlags(NULL);
    if (HotPlugFlags & HOTPLUG_REGFLAG_VIEWALL) {

        DeviceTree->ComplexView = TRUE;
        CheckDlgButton(hDlg, IDC_VIEWOPTION, BST_CHECKED);

    } else {

        DeviceTree->ComplexView = FALSE;
        CheckDlgButton(hDlg, IDC_VIEWOPTION, BST_UNCHECKED);
    }

    //
    // Get the root devnode.
    //
    ConfigRet = CM_Locate_DevNode_Ex(&DeviceTree->DevInst,
                                     NULL,
                                     CM_LOCATE_DEVNODE_NORMAL,
                                     DeviceTree->hMachine
                                    );

    if (ConfigRet != CR_SUCCESS) {

        return FALSE;
    }

    RefreshTree(DeviceTree);


    if (DeviceTree->EjectDeviceInstanceId) {

        DEVINST EjectDevInst;
        PDEVTREENODE DeviceTreeNode;

        //
        // we are removing a specific device, find it
        // and post a message to trigger device removal.
        //
        ConfigRet = CM_Locate_DevNode_Ex(&EjectDevInst,
                                         DeviceTree->EjectDeviceInstanceId,
                                         CM_LOCATE_DEVNODE_NORMAL,
                                         DeviceTree->hMachine
                                        );


        if (ConfigRet != CR_SUCCESS) {

            return FALSE;
        }

        DeviceTreeNode = DevTreeNodeByDevInst(EjectDevInst,
                                              &DeviceTree->ChildSiblingList
                                             );

        if (!DeviceTreeNode) {

            return FALSE;
        }

        TreeView_SelectItem(hwndTree, DeviceTreeNode->hTreeItem);
        PostMessage(hDlg, WUM_EJECTDEVINST, 0, 0);

    } else {

        ShowWindow(hDlg, SW_SHOW);
    }

    return TRUE;
}

void
OnContextHelp(
             LPHELPINFO HelpInfo,
             PDWORD ContextHelpIDs
             )
{
    // Define an array of dword pairs,
    // where the first of each pair is the control ID,
    // and the second is the context ID for a help topic,
    // which is used in the help file.

    if (HelpInfo->iContextType == HELPINFO_WINDOW) {  // must be for a control

        WinHelp((HWND)HelpInfo->hItemHandle,
                TEXT("hardware.hlp"),
                HELP_WM_HELP,
                (DWORD_PTR)(void *)ContextHelpIDs
               );
    }

}

LRESULT CALLBACK DevTreeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    PDEVICETREE DeviceTree = NULL;
    BOOL Status = TRUE;

    if (message == WM_INITDIALOG) {
        DeviceTree = (PDEVICETREE)lParam;

        SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)DeviceTree);

        if (DeviceTree) {
            InitDevTreeDlgProc(hDlg, DeviceTree);
        }
        return TRUE;
    }

    // retrieve private data from window long (stored there during WM_INITDIALOG)
    DeviceTree = (PDEVICETREE)GetWindowLongPtr(hDlg, DWLP_USER);

    switch (message) {
    case WM_DESTROY:
        // Destroy the Notification Window
        if (g_hwndNotify && IsWindow(g_hwndNotify)) {
            DestroyWindow(g_hwndNotify);
            g_hwndNotify = NULL;
        }

        // Clear the DeviceTree
        TreeView_DeleteAllItems(DeviceTree->hwndTree);

        // clean up the class image list.
        if (DeviceTree->ClassImageList.cbSize) {
            SetupDiDestroyClassImageList(&DeviceTree->ClassImageList);
            DeviceTree->ClassImageList.cbSize = 0;
        }

        // Clean up the device tree
        ClearRemovalList(DeviceTree);
        RemoveChildSiblings(DeviceTree, &DeviceTree->ChildSiblingList);

        if (hDevMgr) {
            FreeLibrary(hDevMgr);
            hDevMgr = NULL;
            pDeviceProperties = NULL;
        }
        break;

    case WM_CLOSE:
        SendMessage(hDlg, WM_COMMAND, IDCANCEL, 0L);
        break;

    case WM_COMMAND:
        {
            UINT Control = GET_WM_COMMAND_ID(wParam, lParam);
            UINT Cmd = GET_WM_COMMAND_CMD(wParam, lParam);

            switch (Control) {
            case IDC_VIEWOPTION:
                if (Cmd == BN_CLICKED) {
                    OnViewOptionClicked(hDlg, DeviceTree);
                }
                break;

            case IDC_STOPDEVICE:
                OnRemoveDevice(hDlg, DeviceTree, FALSE);
                break;

            case IDOK:  // enter -> default  to expand\collapse the selected tree node
                if (DeviceTree->SelectedTreeNode) {
                    TreeView_Expand(DeviceTree->hwndTree,
                                    DeviceTree->SelectedTreeNode->hTreeItem, TVE_TOGGLE);
                }

                break;

            case IDC_PROPERTIES:
                if (DeviceTree->SelectedTreeNode && pDeviceProperties) {
                    (*pDeviceProperties)(hDlg,
                                         DeviceTree->hMachine ? DeviceTree->MachineName : NULL,
                                         DeviceTree->SelectedTreeNode->InstanceId, FALSE);
                }
                break;

            case IDCLOSE:
            case IDCANCEL:
                EndDialog(hDlg, IDCANCEL);
                break;
            }

        }
        break;

        // Listen for Tree notifications
    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code) {
        case TVN_SELCHANGED:
            OnTvnSelChanged(DeviceTree, (NM_TREEVIEW *)lParam);
            break;

        case TVN_ITEMEXPANDING:
            OnTvnItemExpanding(hDlg,DeviceTree,(NM_TREEVIEW *)lParam);
            break;

        case TVN_KEYDOWN:
            {
                TV_KEYDOWN *tvKeyDown = (TV_KEYDOWN *)lParam;

                if (tvKeyDown->wVKey == VK_DELETE) {
                    OnRemoveDevice(hDlg, DeviceTree, TRUE);
                }
            }
            break;

        case NM_CUSTOMDRAW:
            if (IDC_DEVICETREE == ((NMHDR *)lParam)->idFrom) {
                SetDlgMsgResult(hDlg, WM_NOTIFY, OnCustomDraw(hDlg, DeviceTree, (NMTVCUSTOMDRAW *)lParam));
            }
            break;

        case NM_RETURN:
            // we don't get this in a dialog, see IDOK
            break;

        case NM_DBLCLK:
            OnRemoveDevice(hDlg, DeviceTree, TRUE);
            SetDlgMsgResult(hDlg, WM_NOTIFY, TRUE);
            break;

        case NM_RCLICK:
            OnRightClick(hDlg,DeviceTree, (NMHDR *)lParam);
            break;

        default:
            return FALSE;
        }
        break;

    case WUM_EJECTDEVINST:
        OnRemoveDevice(hDlg, DeviceTree, TRUE);
        EndDialog(hDlg, IDCANCEL);
        break;

    case WM_SYSCOLORCHANGE:
        HotPlugPropagateMessage(hDlg, message, wParam, lParam);
        OnSysColorChange(hDlg,DeviceTree);
        break;

    case WM_TIMER:
        if (TIMERID_DEVICECHANGE == wParam) {
            KillTimer(hDlg, TIMERID_DEVICECHANGE);
            DeviceTree->RefreshEvent = TRUE;

            if (DeviceTree->AllowRefresh) {
                OnTimerDeviceChange(DeviceTree);
            }
        }
        break;

    case WM_SETCURSOR:
        if (DeviceTree->RedrawWait || DeviceTree->RefreshEvent) {
            SetCursor(LoadCursor(NULL, IDC_WAIT));
            SetWindowLongPtr(hDlg, DWLP_MSGRESULT, 1);
            break;
        }
        return FALSE;

    case WM_CONTEXTMENU:
        //
        // handle kbd- shift-F10, mouse rclick is invoked from NM_RCLICK
        //
        if ((HWND)wParam == DeviceTree->hwndTree) {
            OnContextMenu(hDlg, DeviceTree);
            break;
        } else {
            WinHelp((HWND)wParam, TEXT("hardware.hlp"), HELP_CONTEXTMENU,
                    (DWORD_PTR)(void *)(PDWORD)UnplugtHelpIDs);
        }
        return FALSE;

    case WM_HELP:
        OnContextHelp((LPHELPINFO)lParam, (PDWORD)UnplugtHelpIDs);
        break;

    default:
        return FALSE;
    }

    return TRUE;
}