windows-server-2003/sdktools/debuggers/windbg/dualwin.cpp

/*++

Copyright (c) 1992-2002  Microsoft Corporation

Module Name:

    dualwin.cpp

Abstract:

    Header for new window architecture functions.

--*/


#include "precomp.hxx"
#pragma hdrstop

#define NAME_BUFFER 1024

BOOL g_UseTextMode = FALSE;

//
// DUALLISTWIN_DATA methods
//
DUALLISTWIN_DATA::DUALLISTWIN_DATA(ULONG ChangeBy)
    : SINGLE_CHILDWIN_DATA(ChangeBy)
{
    m_wFlags = DL_EDIT_SECONDPANE;
    m_hwndEditControl = NULL;
    m_nItem_LastSelected = -1;
    m_nSubItem_LastSelected = 0;
    m_nItem_CurrentlyEditing = -1;
    m_nSubItem_CurrentlyEditing = -1;
}

void
DUALLISTWIN_DATA::Validate()
{
    SINGLE_CHILDWIN_DATA::Validate();
}

void
DUALLISTWIN_DATA::SetFont(ULONG FontIndex)
{
    SINGLE_CHILDWIN_DATA::SetFont(FontIndex);

    SendMessage(m_hwndEditControl, WM_SETFONT,
                (WPARAM)m_Font->Font, TRUE);
}

BOOL
DUALLISTWIN_DATA::OnCreate(void)
{
    m_hwndChild = CreateWindowEx(
                      WS_EX_CLIENTEDGE,                           // Extended style
                      WC_LISTVIEW,                                // class name
                      NULL,                                       // title
                      WS_CHILD | WS_VISIBLE
                      | WS_MAXIMIZE
                      | WS_HSCROLL | WS_VSCROLL
                      | LVS_SHOWSELALWAYS
                      | LVS_REPORT | LVS_SINGLESEL
                      | ((m_enumType != CPU_WINDOW)
                         ? LVS_OWNERDRAWFIXED : 0),            // style
                      0,                                          // x
                      0,                                          // y
                      CW_USEDEFAULT,                              // width
                      CW_USEDEFAULT,                              // height
                      m_Win,                                      // parent
                      0,                                          // control id
                      g_hInst,                                    // hInstance
                      NULL                                        // user defined data
                      );

    if (m_hwndChild == NULL)
    {
        return FALSE;
    }

    m_hwndEditControl = CreateWindowEx(
                            0,                                          // Extended style
                            RICHEDIT_CLASS,                             // class name
                            NULL,                                       // title
                            WS_CHILD,
                            0,                                          // x
                            0,                                          // y
                            CW_USEDEFAULT,                              // width
                            CW_USEDEFAULT,                              // height
                            m_Win,                                      // parent
                            0,                                          // control id
                            g_hInst,                                    // hInstance
                            NULL                                        // user defined data
                            );

    if (m_hwndEditControl == NULL)
    {
        DestroyWindow(m_hwndChild);
        return FALSE;
    }

    SetFont(FONT_FIXED);

    SendMessage(m_hwndEditControl,
        EM_SETEVENTMASK,
        0,
        (LPARAM) ENM_KEYEVENTS | ENM_MOUSEEVENTS
        );

    ListView_SetBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
    ListView_SetTextBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
    ListView_SetTextColor(m_hwndChild, g_Colors[COL_PLAIN_TEXT].Color);

    return TRUE;
}

LRESULT
DUALLISTWIN_DATA::OnCommand(
    WPARAM wParam,
    LPARAM lParam
    )
{
    WORD wCode = HIWORD(wParam);
    WORD wId = LOWORD(wParam);
    HWND hwnd = (HWND) lParam;

    if (hwnd != m_hwndEditControl)
    {
        return 1; // Not handled
    }

    switch (wCode)
    {
    default:
        return 1; // not handled

    case EN_KILLFOCUS:
        //
        // Duplicate code in OnNotify : EN_MSGFILTER
        //
        if (-1 != m_nItem_CurrentlyEditing)
        {
            if (!SetItemFromEdit(m_nItem_CurrentlyEditing,
                                 m_nSubItem_CurrentlyEditing))
            {
                break;
            }

            ShowWindow(hwnd, SW_HIDE);
            SetFocus(m_hwndChild);

            InvalidateItem(m_nItem_CurrentlyEditing);

            m_nItem_CurrentlyEditing = -1;
            m_nSubItem_CurrentlyEditing = -1;
        }
        break;
    }

    return 0;
}

LRESULT
DUALLISTWIN_DATA::OnNotify(
    WPARAM wParam,
    LPARAM lParam
    )
{
    // Branch depending on the specific notification message.
    switch (((LPNMHDR) lParam)->code)
    {
    case LVN_ITEMCHANGED:
        InvalidateItem( ((LPNMLISTVIEW) lParam)->iItem);
        break;

    case NM_CLICK:
    case NM_DBLCLK:
        // Figure out whether an item or a sub-item was clicked
        OnClick((LPNMLISTVIEW) lParam);
        break;
    case NM_CUSTOMDRAW:
        return OnCustomDraw((LPNMLVCUSTOMDRAW)lParam);

    case EN_MSGFILTER:
        //
        // Duplicate code in OnCommand : EN_KILLFOCUS
        //
        if (WM_KEYDOWN == ((MSGFILTER *)lParam)->msg)
        {
            MSGFILTER * pMsgFilter = (MSGFILTER *) lParam;

            switch (pMsgFilter->wParam)
            {
            case VK_RETURN:
                // Ignore this message so the richedit
                // doesn't beep.
                return 1;
            }
        }
        else if (WM_CHAR == ((MSGFILTER *)lParam)->msg)
        {
            MSGFILTER * pMsgFilter = (MSGFILTER *) lParam;

            switch (pMsgFilter->wParam)
            {
            case VK_RETURN:
                if (!SetItemFromEdit(m_nItem_CurrentlyEditing,
                                     m_nSubItem_CurrentlyEditing))
                {
                    break;
                }
                // fall through...

            case VK_ESCAPE:
                InvalidateItem(m_nItem_CurrentlyEditing);

                //
                // Invalidate these before changing focus, so that Itemchanged
                // doesn't get called again on same item
                //
                m_nItem_CurrentlyEditing = -1;
                m_nSubItem_CurrentlyEditing = -1;

                //
                // Hide the edit box and set focus to the list view
                //
                ShowWindow(m_hwndEditControl, SW_HIDE);
                SetFocus(m_hwndChild);

                break;
            }
        }
        else if (WM_RBUTTONDOWN == ((MSGFILTER *)lParam)->msg ||
                 WM_RBUTTONDBLCLK == ((MSGFILTER *)lParam)->msg)
        {
            // process cpoy/passte selection
            if (CanCopy())
            {
                Copy();

                CHARRANGE Sel;
                SendMessage(m_hwndEditControl, EM_EXGETSEL, 0, (LPARAM)&Sel);
                Sel.cpMax = Sel.cpMin;
                SendMessage(m_hwndEditControl, EM_EXSETSEL, 0, (LPARAM)&Sel);
            }
            else if (SendMessage(m_hwndEditControl, EM_CANPASTE, CF_TEXT, 0))
            {
                SetFocus(m_hwndEditControl);
                Paste();
            }

            // Ignore right-button events.
            return 1;

        }
        return 0; // process this message
    case LVN_COLUMNCLICK:
//      LVN_COLUMNCLICK pnmv = (LPNMLISTVIEW) lParam;

        break;

    }

    return DefMDIChildProc(m_Win, WM_NOTIFY, wParam, lParam);
}


BOOL
DUALLISTWIN_DATA::ClearList(ULONG ClearFrom)
{
    if (!ClearFrom)
    {
        return ListView_DeleteAllItems(m_hwndChild);
    }
    else
    {
        ULONG nItems = ListView_GetItemCount(m_hwndChild);
        BOOL  res = TRUE;

        while (res && (ClearFrom < nItems))
        {
            res = ListView_DeleteItem(m_hwndChild, --nItems);
        }

        return res;
    }
}

void
DUALLISTWIN_DATA::InvalidateItem(
    int nItem
    )
{
    RECT rc = {0};

    if (-1 == nItem)
    {
        // Invalidate the entire window
        GetClientRect(m_hwndChild, &rc);
    }
    else
    {
        // Invalidate the item row
        if (!ListView_GetItemRect(m_hwndChild,nItem,&rc,LVIR_BOUNDS))
        {
            // Invalidate the entire window
            GetClientRect(m_hwndChild, &rc);
        }
    }
    InvalidateRect(m_hwndChild, &rc, TRUE);
}

void
DUALLISTWIN_DATA::ItemChanged(
    int Item,
    PCSTR Text
    )
{
    // Do-nothing placeholder.
}

LRESULT
DUALLISTWIN_DATA::OnCustomDraw(LPNMLVCUSTOMDRAW Custom)
{
    static int s_SelectedItem = -1;
    static ULONG s_SubItem;

    if (Custom->nmcd.hdr.hwndFrom != m_hwndChild)
    {
        return CDRF_DODEFAULT;
    }

    switch (Custom->nmcd.dwDrawStage)
    {
    case CDDS_PREPAINT:
        s_SelectedItem = ListView_GetNextItem(m_hwndChild, -1, LVNI_SELECTED);
        if (m_wFlags & DL_CUSTOM_ITEMS)
        {
            return CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT;
        }
        else
        {
            return CDRF_NOTIFYPOSTPAINT;
        }

    case CDDS_ITEMPREPAINT:
        s_SubItem = 0;
        return CDRF_NOTIFYSUBITEMDRAW;
    case CDDS_ITEMPREPAINT | CDDS_SUBITEM:
        return OnCustomItem(s_SubItem++, Custom);

    case CDDS_POSTPAINT:
        if (-1 != s_SelectedItem)
        {
            RECT rc;

            // If we ask for subitem 0, then we get the rectangle for the
            // entire item, so we ask for item 1, and do the math

            Dbg( ListView_GetSubItemRect(m_hwndChild,
                                         s_SelectedItem,
                                         1,
                                         LVIR_BOUNDS,
                                         &rc));

            if (0 == m_nSubItem_LastSelected)
            {
                rc.right = rc.left - 1;
                rc.left = 0;
            }

            InvertRect(Custom->nmcd.hdc, &rc);
        }

        return CDRF_NOTIFYPOSTPAINT;

    default:
        return 0;
    }
}

LRESULT
DUALLISTWIN_DATA::OnCustomItem(ULONG SubItem, LPNMLVCUSTOMDRAW Custom)
{
    return CDRF_DODEFAULT;
}

void
DUALLISTWIN_DATA::OnClick(
    LPNMLISTVIEW Notify
    )
{
    LVHITTESTINFO lvHTInfo = {0};

    lvHTInfo.pt = Notify->ptAction;

    if (-1 != ListView_SubItemHitTest(m_hwndChild, &lvHTInfo) )
    {
        // success

        //
        // If the user click on a different item than the one currently selected
        // then the LVN_ITEMCHANGED message will take care of updating the screen.
        //
        // If the user clicked on the currently slected item then we need to
        // check whether he wants to edit the contents or select a different subitem.
        //
        if (m_nItem_CurrentlyEditing == lvHTInfo.iItem
            && m_nSubItem_CurrentlyEditing == lvHTInfo.iSubItem)
        {
            ShowWindow(m_hwndEditControl, SW_SHOW);

            SetFocus(m_hwndEditControl);
        } else if (m_nItem_LastSelected == lvHTInfo.iItem
            && m_nSubItem_LastSelected == lvHTInfo.iSubItem)
        {
            // If we clicked on the currently selected item & subitem
            // then the user wants to edit the text.
            //
            // Is editing allowed
            if ( ( (0 == m_nSubItem_LastSelected) &&
                (m_wFlags & DL_EDIT_LEFTPANE) )       ||
                ( (1 == m_nSubItem_LastSelected) &&
                (m_wFlags & DL_EDIT_SECONDPANE) )      ||
                ( (2 == m_nSubItem_LastSelected) &&
                (m_wFlags & DL_EDIT_THIRDPANE) ) )
            {
                m_nItem_CurrentlyEditing = m_nItem_LastSelected;
                m_nSubItem_CurrentlyEditing = m_nSubItem_LastSelected;

                EditText();
            }
        }
        else
        {
            // User wants to select a different subitem
            m_nItem_LastSelected = lvHTInfo.iItem;
            m_nSubItem_LastSelected = lvHTInfo.iSubItem;
            InvalidateItem(lvHTInfo.iItem);
        }
    }
}

void
DUALLISTWIN_DATA::EditText()
{
    RECT rc;
    TCHAR sz[NAME_BUFFER * 10], *psz;

    // Get the item's text
    ListView_GetItemText(m_hwndChild,
        m_nItem_CurrentlyEditing,
        m_nSubItem_CurrentlyEditing,
        sz,
        _tsizeof(sz)
        );

    // If we ask for subitem 0, then we get the rectangle for the
    // entire item, so we ask for item m_nItem_CurrentlyEditing, and do the math
    // if we need subitem 0
    Dbg( ListView_GetSubItemRect(m_hwndChild,
        m_nItem_CurrentlyEditing,
        (m_nSubItem_CurrentlyEditing ? m_nSubItem_CurrentlyEditing : 1),
        LVIR_BOUNDS,
        &rc));

    psz = &sz[0];
    if (0 == m_nSubItem_CurrentlyEditing)
    {
        rc.right = rc.left - 1;
        rc.left = 0;

        while (*psz && (*psz == ' ')) {
            ++psz;
        }
    }

    SetWindowText(m_hwndEditControl, psz);

    CHARRANGE charRange={0};

    charRange.cpMax = strlen(psz);
    charRange.cpMin = 0;
    SendMessage(m_hwndEditControl, EM_EXSETSEL, (WPARAM) 0, (LPARAM) &charRange);
    SendMessage(m_hwndEditControl, EM_SETSEL, (WPARAM) 0, (LPARAM) -1);


    POINT ChildBase = {0, 0};
    MapWindowPoints(m_hwndChild, m_Win, &ChildBase, 1);

    MoveWindow(m_hwndEditControl,
        rc.left + ChildBase.x,
        rc.top + ChildBase.y,
        rc.right - rc.left,
        rc.bottom - rc.top,
        FALSE);

    ShowWindow(m_hwndEditControl, SW_SHOW);

    SetFocus(m_hwndEditControl);
}


BOOL
DUALLISTWIN_DATA::CanCopy()
{
    HWND hwnd = (m_nItem_CurrentlyEditing == -1) ? m_hwndChild : m_hwndEditControl;
    CHARRANGE chrg;

    SendMessage(hwnd, EM_EXGETSEL, 0, (LPARAM) (CHARRANGE *) &chrg);

    return chrg.cpMin != chrg.cpMax;
}

BOOL
DUALLISTWIN_DATA::CanCut()
{
    return(m_nItem_CurrentlyEditing != -1)  && CanCopy();
}

BOOL
DUALLISTWIN_DATA::CanPaste()
{
    return(m_nItem_CurrentlyEditing != -1)
        && SendMessage(m_hwndEditControl,
                       EM_CANPASTE,
                       CF_TEXT,
                       0
                       );
}

CHAR ListCopy[500];

void
DUALLISTWIN_DATA::Copy()
{
    if ((m_nItem_CurrentlyEditing == -1) &&
        (m_nItem_LastSelected != -1))
    {
        PCHAR sz = &ListCopy[0];

        ZeroMemory(sz, sizeof(ListCopy));
        if (!GlobalLock( (HGLOBAL) sz))
        {
            return;
        }
        ListView_GetItemText(m_hwndChild, m_nItem_LastSelected, m_nSubItem_LastSelected,
                             sz, sizeof(ListCopy));

        CopyToClipboard(sz, FALSE);
    }
    else
    {
        SendMessage(m_hwndEditControl, WM_COPY, 0, 0);
    }

}

void
DUALLISTWIN_DATA::Cut()
{
    SendMessage(m_hwndEditControl, WM_CUT, 0, 0);
}

void
DUALLISTWIN_DATA::Paste()
{
    SendMessage(m_hwndEditControl, WM_PASTE, 0, 0);
}

void
DUALLISTWIN_DATA::UpdateColors(void)
{
    // Update the general colors and force a repaint to
    // get the text updated.  Specific colors will be
    // applied by custom drawing.
    ListView_SetBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
    ListView_SetTextBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
    ListView_SetTextColor(m_hwndChild, g_Colors[COL_PLAIN_TEXT].Color);
    InvalidateRect(m_hwndChild, NULL, FALSE);
}

ULONG
DUALLISTWIN_DATA::GetItemFlags(ULONG Item)
{
    LVITEM LvItem;

    LvItem.mask = LVIF_PARAM;
    LvItem.iItem = Item;
    LvItem.iSubItem = 0;
    if (ListView_GetItem(m_hwndChild, &LvItem))
    {
        return (ULONG)LvItem.lParam;
    }
    else
    {
        return 0;
    }
}

void
DUALLISTWIN_DATA::SetItemFlags(ULONG Item, ULONG Flags)
{
    LVITEM LvItem;

    LvItem.mask = LVIF_PARAM;
    LvItem.iItem = Item;
    LvItem.iSubItem = 0;
    LvItem.lParam = (LPARAM)Flags;
    ListView_SetItem(m_hwndChild, &LvItem);
}

BOOL
DUALLISTWIN_DATA::SetItemFromEdit(ULONG Item, ULONG SubItem)
{
    //
    // Save the text from the edit box to list item.
    //
    int nLen = GetWindowTextLength(m_hwndEditControl) + 1;
    PTSTR psz = (PTSTR)calloc( nLen, sizeof(TCHAR) );
    if (psz == NULL)
    {
        return FALSE;
    }

    GetWindowText(m_hwndEditControl, psz, nLen);

    ListView_SetItemText(m_hwndChild, Item, SubItem, psz);
    SetItemFlags(Item, GetItemFlags(Item) | ITEM_CHANGED);

    ItemChanged(Item, psz);

    free(psz);
    return TRUE;
}

//
// SYMWIN_DATA methods
//

HMENU SYMWIN_DATA::s_ContextMenu;

SYMWIN_DATA::SYMWIN_DATA(IDebugSymbolGroup **pDbgSymbolGroup)
    : DUALLISTWIN_DATA(2048)
{
    m_pWinSyms = NULL;
    m_nWinSyms = 0;
    m_pDbgSymbolGroup = pDbgSymbolGroup;
    m_NumSymsDisplayed = 0;
    m_DisplayTypes = FALSE;
    m_DisplayOffsets = FALSE;
    m_RefreshItem = 0;
    m_UpdateItem = -1;
    m_SplitWindowAtItem = 0;
    m_MaxNameWidth = 0;
    m_NumCols = 0;
    m_RefreshValues = TRUE;
    SetMaxSyms(1);
    // Use text for Accessibility readers
    SystemParametersInfo(SPI_GETSCREENREADER, 0, &g_UseTextMode, 0);

}

#define VALUE_COLM  1
#define TYPE_COLM   2
#define OFFSET_COLM (m_DisplayTypes ? 3 : 2)

SYMWIN_DATA::~SYMWIN_DATA()
{
    if (m_pWinSyms)
    {
        free (m_pWinSyms);
    }
    return;
}


void
SYMWIN_DATA::Validate()
{
    DUALLISTWIN_DATA::Validate();
}

#define SYMWIN_CONTEXT_ID_BASE 0x100

#define SYMWIN_TBB_TYPECAST 0
#define SYMWIN_TBB_OFFSETS  1

TBBUTTON g_SymWinTbButtons[] =
{
    TEXT_TB_BTN(SYMWIN_TBB_TYPECAST, "Typecast", BTNS_CHECK),
    TEXT_TB_BTN(SYMWIN_TBB_OFFSETS, "Offsets", BTNS_CHECK),
    SEP_TB_BTN(),
    TEXT_TB_BTN(ID_SHOW_TOOLBAR, "Toolbar", 0),
};

#define NUM_SYMWIN_MENU_BUTTONS \
    (sizeof(g_SymWinTbButtons) / sizeof(g_SymWinTbButtons[0]))
#define NUM_SYMWIN_TB_BUTTONS \
    (NUM_SYMWIN_MENU_BUTTONS - 2)

#define IsAParent(Sym) ((Sym)->SubElements)
#define SYM_LEVEL(sym) ((sym)->Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK)
#define IsRootSym(Sym) !SYM_LEVEL(Sym)

HMENU
SYMWIN_DATA::GetContextMenu(void)
{
    //
    // We only keep one menu around for all call windows
    // so apply the menu check state for this particular
    // window.
    //

    CheckMenuItem(s_ContextMenu, SYMWIN_TBB_TYPECAST + SYMWIN_CONTEXT_ID_BASE,
                  MF_BYCOMMAND | (m_DisplayTypes ? MF_CHECKED : 0));
    CheckMenuItem(s_ContextMenu, SYMWIN_TBB_OFFSETS + SYMWIN_CONTEXT_ID_BASE,
                  MF_BYCOMMAND | (m_DisplayOffsets ? MF_CHECKED : 0));
    CheckMenuItem(s_ContextMenu, ID_SHOW_TOOLBAR + SYMWIN_CONTEXT_ID_BASE,
                  MF_BYCOMMAND | (m_ShowToolbar ? MF_CHECKED : 0));

    return s_ContextMenu;
}

void
SYMWIN_DATA::OnContextMenuSelection(UINT Item)
{
    ULONG Changed = 0;

    Item -= SYMWIN_CONTEXT_ID_BASE;

    switch(Item)
    {
    case SYMWIN_TBB_TYPECAST:
        SetDisplayTypes(Item, !m_DisplayTypes);
        Changed = 1 << SYMWIN_TBB_TYPECAST;
        break;
    case SYMWIN_TBB_OFFSETS:
        SetDisplayTypes(Item, !m_DisplayOffsets);
        Changed = 1 << SYMWIN_TBB_OFFSETS;
        break;
    case ID_SHOW_TOOLBAR:
        SetShowToolbar(!m_ShowToolbar);
        break;
    }
    SyncUiWithFlags(Changed);
}

BOOL
SYMWIN_DATA::OnCreate(void)
{
    if (s_ContextMenu == NULL)
    {
        s_ContextMenu = CreateContextMenuFromToolbarButtons
            (NUM_SYMWIN_MENU_BUTTONS, g_SymWinTbButtons,
             SYMWIN_CONTEXT_ID_BASE);
        if (s_ContextMenu == NULL)
        {
            return FALSE;
        }
    }

    if (!DUALLISTWIN_DATA::OnCreate())
    {
        return FALSE;
    }

    m_Toolbar = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
                    WS_CHILD | WS_VISIBLE |
                    TBSTYLE_WRAPABLE | TBSTYLE_LIST | CCS_TOP,
                    0, 0, m_Size.cx, 0, m_Win, (HMENU)ID_TOOLBAR,
                    g_hInst, NULL);
    if (m_Toolbar == NULL)
    {
        return FALSE;
    }
    SendMessage(m_Toolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
    SendMessage(m_Toolbar, TB_ADDBUTTONS, NUM_SYMWIN_TB_BUTTONS,
        (LPARAM)&g_SymWinTbButtons);
    SendMessage(m_Toolbar, TB_AUTOSIZE, 0, 0);

    RECT Rect;
    GetClientRect(m_Toolbar, &Rect);
    m_ToolbarHeight = Rect.bottom - Rect.top + GetSystemMetrics(SM_CYEDGE);
    m_ShowToolbar = TRUE;

    SendMessage(m_hwndChild, WM_SETREDRAW, FALSE, 0);

    RECT        rc;
    LV_COLUMN   lvc = {0};

    GetClientRect(m_hwndChild, &rc);
    rc.right -= rc.left + GetSystemMetrics(SM_CXVSCROLL);

    //initialize the columns
    lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM | LVCF_TEXT;
    lvc.fmt = LVCFMT_LEFT;
    lvc.iSubItem = 0;

    lvc.cx = m_Font->Metrics.tmAveCharWidth * 20;
    if (lvc.cx > rc.right / 2)
    {
        lvc.cx = rc.right / 2;
    }
    lvc.pszText = _T("Name");
    Dbg( (0 == ListView_InsertColumn(m_hwndChild, 0, &lvc)) );

    // Give the rest of the space to the value.
    lvc.cx = rc.right - lvc.cx;
    lvc.pszText = _T("Value");
    Dbg( (1 == ListView_InsertColumn(m_hwndChild, 1, &lvc)) );
    m_NumCols = 2;

    ListView_SetExtendedListViewStyle(m_hwndChild,
        LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT
        );
    SendMessage(m_hwndChild, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(m_hwndChild, NULL, TRUE);


    return TRUE;
}

void
SYMWIN_DATA::OnSize(void)
{
    DUALLISTWIN_DATA::OnSize();

//    ListView_SetColumnWidth(m_hwndChild, 0 , m_MaxNameWidth);
}


LRESULT
SYMWIN_DATA::OnNotify(
    WPARAM              wParam,
    LPARAM              lParam
    )
{
    if (((LPNMHDR) lParam)->code == LVN_KEYDOWN)
    {
        if (m_nItem_LastSelected != -1 &&
            m_nItem_CurrentlyEditing == -1 &&
            g_ExecStatus == DEBUG_STATUS_BREAK)
        {
            NMLVKEYDOWN * pNmKeyDown = (NMLVKEYDOWN *) lParam;

            switch (pNmKeyDown->wVKey)
            {
            case VK_LEFT:
                if (m_nSubItem_LastSelected == 0)
                {
                    ExpandSymbol(m_nItem_LastSelected, FALSE);
                    return TRUE;
                }
                break;
            case VK_RIGHT:
                if (m_nSubItem_LastSelected == 0)
                {
                    ExpandSymbol(m_nItem_LastSelected, TRUE);
                    return TRUE;
                }
                break;
            case VK_RETURN:
                switch (m_nSubItem_LastSelected) {
                case 0:
                    if (IsRootSym(&m_pWinSyms[m_nItem_LastSelected]) && (m_enumType == WATCH_WINDOW))
                    {
                        m_nItem_CurrentlyEditing   = m_nItem_LastSelected;
                        m_nSubItem_CurrentlyEditing=0;
                        EditText();
                    }
                    break;
                case 1:
                    if (!(m_pWinSyms[m_nItem_LastSelected].Flags & DEBUG_SYMBOL_READ_ONLY))
                    {
                        m_nItem_CurrentlyEditing   = m_nItem_LastSelected;
                        m_nSubItem_CurrentlyEditing=1;
                        EditText();
                    }
                    break;
                case 2:
                    m_nItem_CurrentlyEditing   = m_nItem_LastSelected;
                    m_nSubItem_CurrentlyEditing=2;
                    EditText();
                    break;
                default:
                    break;
                }
                break;
            default:
                break;
            }

        }
    }
    else if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED)
    {
        LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;

        if (pnmv->uNewState & LVIS_SELECTED)
        {
            m_nItem_LastSelected = pnmv->iItem;
            m_nSubItem_LastSelected = pnmv->iSubItem;
        }
    }
    return DUALLISTWIN_DATA::OnNotify(wParam, lParam);
}

void
SYMWIN_DATA::OnUpdate(
    UpdateType Type
    )
{
    if (Type == UPDATE_EXEC)
    {
        // Disallow editing when the debuggee is running.
        if (g_ExecStatus == DEBUG_STATUS_BREAK)
        {
            if (m_enumType != LOCALS_WINDOW)
            {
                m_wFlags |= DL_EDIT_LEFTPANE;
            }
            else
            {
                m_wFlags &= ~DL_EDIT_LEFTPANE;
            }
            ListView_SetTextBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
        }
        else
        {
            m_wFlags = 0;
            ListView_SetTextBkColor(m_hwndChild,
                                    g_Colors[COL_DISABLED_WINDOW].Color);
        }
        InvalidateRect(m_hwndChild, NULL, FALSE);
        return;
    }
    else if (Type != UPDATE_BUFFER)
    {
        return;
    }
    SendMessage(m_hwndChild, WM_SETREDRAW, FALSE, 0);

    UpdateNames();

    SendMessage(m_hwndChild, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(m_hwndChild, NULL, TRUE);
}

void
SYMWIN_DATA::ExpandSymbol(
    ULONG Index,
    BOOL Expand
    )
{
    //
    // Expand the Item
    //
    UIC_SYMBOL_WIN_DATA* WatchItem;

    WatchItem = StartStructCommand(UIC_SYMBOL_WIN);
    if (WatchItem != NULL)
    {

        WatchItem->Type = EXPAND_SYMBOL;
        WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
        WatchItem->u.ExpandSymbol.Index = Index;
        WatchItem->u.ExpandSymbol.Expand = Expand;
        FinishCommand();
        UiRequestRead();
    }

}

ULONG
SYMWIN_DATA::GetWorkspaceSize(void)
{
    return DUALLISTWIN_DATA::GetWorkspaceSize() + 2*sizeof(BOOL);
}

PUCHAR
SYMWIN_DATA::SetWorkspace(PUCHAR Data)
{
    Data = DUALLISTWIN_DATA::SetWorkspace(Data);
    *(PBOOL)Data = m_DisplayTypes;
    Data += sizeof(BOOL);
    *(PBOOL)Data = m_DisplayOffsets;
    Data += sizeof(BOOL);

    return Data;
}

PUCHAR
SYMWIN_DATA::ApplyWorkspace1(PUCHAR Data, PUCHAR End)
{
    UIC_SYMBOL_WIN_DATA* WatchItem;

    Data = DUALLISTWIN_DATA::ApplyWorkspace1(Data, End);

    // Clear the window
    WatchItem = StartStructCommand(UIC_SYMBOL_WIN);
    if (WatchItem != NULL)
    {
        WatchItem->Type = DEL_SYMBOL_WIN_ALL;
        WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
        FinishCommand();
    }

    ULONG Changed = 0;

    if (End - Data >= sizeof(BOOL))
    {
        SetDisplayTypes(SYMWIN_TBB_TYPECAST, *(PBOOL)Data);
        Changed |= 1 << SYMWIN_TBB_TYPECAST;
        Data += sizeof(BOOL);
    }
    if (End - Data >= sizeof(BOOL))
    {
        SetDisplayTypes(SYMWIN_TBB_OFFSETS, *(PBOOL)Data);
        Changed |= 1 << SYMWIN_TBB_OFFSETS;
        Data += sizeof(BOOL);
    }
    SyncUiWithFlags(Changed);

    return Data;
}

BOOL
SYMWIN_DATA::AddListItem(
    ULONG iItem,
    PSTR ItemText,
    ULONG Level,
    BOOL  HasChildren,
    BOOL  Expanded)
{
    LVITEM LvItem = {0};
    CHAR Name[NAME_BUFFER], OldName[NAME_BUFFER];
    ULONG i;

    LvItem.mask = LVIF_TEXT | LVIF_INDENT;
    Name[0] = 0;

    ULONG NameUsed = strlen(Name);

    // HACK - Column autosize doesn't take indent into account
    // while autosizing the column, so padd with spaces in front to make it work
    i = 0;
    while (i <= (Level + 2) && i < sizeof(Name) - 1)
    {
        Name[i++] = ' ';
    }
    Name[i] = 0;

    CatString(Name, ItemText, DIMA(Name));

    LvItem.pszText = Name;
    LvItem.iItem = iItem;
    LvItem.iIndent = Level + 1;
    if ((ULONG)ListView_GetItemCount(m_hwndChild) <= iItem)
    {
        ListView_InsertItem(m_hwndChild, &LvItem);
        return TRUE;
    }
    else
    {
        ListView_GetItemText(m_hwndChild, iItem, 0, OldName, sizeof(OldName));
        ListView_SetItem(m_hwndChild, &LvItem);
        return (strcmp(Name, OldName) != 0);
    }
}

void
SYMWIN_DATA::UpdateNames()
{
    ULONG   Sym, Items;
    PSTR    Buf;
    PDEBUG_SYMBOL_PARAMETERS SymParams = GetSymParam();
    BOOL    NameChanged;
    HDC     hDC = GetDC(m_hwndChild);
    TEXTMETRIC tm = {0};

    Items = ListView_GetItemCount(m_hwndChild);
    GetTextMetrics(hDC, &tm);
    ReleaseDC(m_hwndChild, hDC);

    if (UiLockForRead() == S_OK)
    {
        Buf = (PSTR)GetDataBuffer();

        ULONG Len;
        CHAR  Name[NAME_BUFFER], Value[NAME_BUFFER], Type[NAME_BUFFER], Offset[20];
        ULONG LastArgSym=-1, LastParent=0;

        Items = 0;

        if (m_UpdateItem < m_SplitWindowAtItem)
        {
            LastArgSym = m_UpdateItem;
            m_SplitWindowAtItem = 0;
        }

        for (Sym = m_UpdateItem; Sym < m_NumSymsDisplayed; Sym++)
        {
            PSTR EndTag;
            PSTR NameSt, NameEn;

            if (Buf == NULL)
            {
                strcpy(Name, _T("Unknown"));
                strcpy(Value, _T(""));
            }
            else
            {
#if DBG_SYM_WIN
                DebugPrint("SYM_WIN: Buffer left %s\n", Buf);
#endif

                Name[0] = 0;
                EndTag = strstr(Buf, DEBUG_OUTPUT_NAME_END);
                if (!EndTag)
                {
                    break;
                }

                NameSt = Buf;
                NameEn = EndTag;

                Buf = EndTag + strlen(DEBUG_OUTPUT_NAME_END);
                EndTag = strstr(Buf, DEBUG_OUTPUT_VALUE_END);
                if (!EndTag)
                {
                    break;
                }

                Len = (ULONG) (EndTag - Buf);
                if (Len >= sizeof(Value))
                {
                    Len = sizeof(Value) - 1;
                }
                memcpy(Value, Buf, Len);
                Value[Len] = 0;

                Buf = EndTag + strlen(DEBUG_OUTPUT_VALUE_END);

                if (m_DisplayOffsets)
                {
                    EndTag = strstr(Buf, DEBUG_OUTPUT_OFFSET_END);
                    if (!EndTag)
                    {
                        EndTag = Buf;
                    }

                    Len = (ULONG) (EndTag - Buf);
                    if (Len >= sizeof(Offset))
                    {
                        Len = sizeof(Offset) - 1;
                    }
                    memcpy(Offset, Buf, Len);
                    Offset[Len] = 0;

                    Buf = EndTag + strlen(DEBUG_OUTPUT_OFFSET_END);
                }

                Len = (ULONG) (NameEn - NameSt);
                if (Len >= sizeof(Name) - 10)
                {
                    Len = sizeof(Name) - 11;
                }
                strncat(Name, NameSt, Len);
                Name[DIMA(Name) - 1] = 0;

                if (m_DisplayTypes)
                {
                    EndTag = strstr(Buf, DEBUG_OUTPUT_TYPE_END);
                    if (!EndTag)
                    {
                        EndTag = Buf;
                    }

                    Len = (ULONG) (EndTag - Buf);
                    if (Len >= sizeof(Type))
                    {
                        Len = sizeof(Type) - 1;
                    }
                    memcpy(Type, Buf, Len);
                    Type[Len] = 0;

                    Buf = EndTag + strlen(DEBUG_OUTPUT_TYPE_END);
                }
            }

            if (GetMaxSyms() > Sym)
            {
                NameChanged =
                    AddListItem(Sym, Name, SYM_LEVEL((SymParams + Sym)),
                                SymParams[Sym].SubElements,
                                SymParams[Sym].Flags & DEBUG_SYMBOL_EXPANDED);
            }
            else
            {
                break;
            }

            if (!(SymParams[Sym].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK))
            {
                LastParent = Sym;

                if ((SymParams[Sym].Flags & DEBUG_SYMBOL_IS_ARGUMENT) &&
                    (m_enumType == LOCALS_WINDOW))
                {
                    LastArgSym = Sym;
                }

                if ((LastParent > LastArgSym) && !m_SplitWindowAtItem)
                {
                    m_SplitWindowAtItem = Sym;
                }
            }

            if (!NameChanged)
            {
                // Check if the value changed
                PCHAR OldValue = &Name[0];
                ListView_GetItemText(m_hwndChild, Sym, VALUE_COLM,
                                     OldValue, sizeof(Name));

                if (strcmp(OldValue, Value))
                {
                    // Value changed
                    SymParams[Sym].Flags |= ITEM_VALUE_CHANGED;
                }
                else
                {
                    SymParams[Sym].Flags &= ~ITEM_VALUE_CHANGED;
                }
            }

            ListView_SetItemText(m_hwndChild, Sym, VALUE_COLM, Value);

            if (m_DisplayOffsets)
            {
                ListView_SetItemText(m_hwndChild, Sym, OFFSET_COLM, Offset);
            }
            if (m_DisplayTypes)
            {
                ListView_SetItemText(m_hwndChild, Sym, TYPE_COLM, Type);
            }

            if (Sym < sizeof(m_ListItemLines))
            {
                m_ListItemLines[Sym] = 2;
            }
        }

        UnlockStateBuffer(this);
    }

    ClearList(m_NumSymsDisplayed);

    if (Items == 0 && (m_enumType == WATCH_WINDOW))
    {
        //
        // add a dummy to enable adding new items
        //
        LVITEM LvItem = {0};
        LvItem.mask = LVIF_TEXT | LVIF_INDENT;
        LvItem.pszText = "";
        LvItem.iItem = m_NumSymsDisplayed;
        ListView_InsertItem(m_hwndChild, &LvItem);
        // ListView_SetItemText(m_hwndChild, m_NumSymsDisplayed, 1, "Dummy");
    }

    m_MaxNameWidth = 0;
    m_UpdateItem = -1;
}

#define ALLOCATE_CHUNK 0x100
HRESULT
SYMWIN_DATA::SetMaxSyms(
    ULONG nSyms
    )
{
    if (m_nWinSyms < nSyms)
    {
        DEBUG_SYMBOL_PARAMETERS *TempSyms = m_pWinSyms;

        m_nWinSyms = ALLOCATE_CHUNK * ((nSyms + ALLOCATE_CHUNK - 1 )/ ALLOCATE_CHUNK);
        TempSyms = (DEBUG_SYMBOL_PARAMETERS *) realloc(m_pWinSyms, m_nWinSyms*sizeof(DEBUG_SYMBOL_PARAMETERS));

        if (!TempSyms)
        {
            // malloc failed, free old allocations and bail with error below
            if (m_pWinSyms)
            {
                free ( m_pWinSyms );
                m_pWinSyms = NULL;
            }
            m_nWinSyms = 0;
            return E_OUTOFMEMORY;
        }
        // move ptr to new memory address
        m_pWinSyms = TempSyms;
    }

    return S_OK;
}

LRESULT
SYMWIN_DATA::OnCommand(
    WPARAM wParam,
    LPARAM lParam
    )
{
    if ((HWND) lParam == m_Toolbar)
    {
        OnContextMenuSelection(LOWORD(wParam) + SYMWIN_CONTEXT_ID_BASE);
        return 0;
    }

    return DUALLISTWIN_DATA::OnCommand(wParam, lParam);
}


void
SYMWIN_DATA::OnClick(
    LPNMLISTVIEW Notify
    )
{

    LVHITTESTINFO lvHTInfo = {0};
    RECT          itemRect;
    ULONG         item;

    lvHTInfo.pt = Notify->ptAction;

    if (-1 != ListView_SubItemHitTest(m_hwndChild, &lvHTInfo) &&
        (m_NumSymsDisplayed > (ULONG) lvHTInfo.iItem) &&
        (g_ExecStatus == DEBUG_STATUS_BREAK))
    {
        PDEBUG_SYMBOL_PARAMETERS SymParams = GetSymParam();

            item = lvHTInfo.iItem;
            if (ListView_GetItemRect(m_hwndChild, lvHTInfo.iItem, &itemRect, LVIR_BOUNDS))
            {
                if (((int) SYM_LEVEL(&SymParams[item]) * m_IndentWidth < Notify->ptAction.x)  &&
                     (Notify->ptAction.x < (int) (itemRect.left + m_IndentWidth * (2+SYM_LEVEL(&SymParams[item])))) &&
                    (lvHTInfo.iSubItem == 0) &&
                    (SymParams[item].SubElements))
                {
                    BOOL Expand = TRUE;
                    if (SymParams[item].SubElements)
                    {
                        if ((m_NumSymsDisplayed > item + 1)  &&
                            (SymParams[item+1].ParentSymbol == item) &&
                            ((SymParams[item+1].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK) ==
                             (SymParams[item].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK) + 1))
                         {
                            //
                            // Already expanded
                            //
                            Expand = FALSE;
                        }

                        ExpandSymbol(item, Expand);
                    }
                    m_RefreshItem = item;

                    m_nItem_LastSelected = lvHTInfo.iItem;
                    m_nSubItem_LastSelected = lvHTInfo.iSubItem;

                    return;
                }
            }

            //
            // Check if ok to edit right pane
            //
            if (SymParams[lvHTInfo.iItem].Flags & DEBUG_SYMBOL_READ_ONLY)
            {
                m_wFlags &= ~DL_EDIT_SECONDPANE;
            }
            else
            {
                m_wFlags |= DL_EDIT_SECONDPANE;
            }
            //
            // Check if ok to edit left pane
            //
            if ((SymParams[lvHTInfo.iItem].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK) ||
                (m_enumType != WATCH_WINDOW))
            {
                m_wFlags &= ~DL_EDIT_LEFTPANE;
            }
            else
            {
                m_wFlags |= DL_EDIT_LEFTPANE;
            }

            if (m_DisplayTypes)
            {
                m_wFlags |= DL_EDIT_THIRDPANE;
            }
            else
            {
                m_wFlags &= ~DL_EDIT_THIRDPANE;
            }
    }
    else if ((m_enumType == WATCH_WINDOW) &&
             (g_ExecStatus == DEBUG_STATUS_BREAK) &&
             (m_NumSymsDisplayed == (ULONG) lvHTInfo.iItem))
    {
        m_wFlags |= DL_EDIT_LEFTPANE;
    }

    //
    // Default processing
    //
    DUALLISTWIN_DATA::OnClick(Notify);
}

HRESULT
SYMWIN_DATA::ReadState(void)
{
    HRESULT Status;
    ULONG   getSyms;

    if (m_pDbgSymbolGroup == NULL ||
        *m_pDbgSymbolGroup == NULL)
    {
        return E_UNEXPECTED;
    }

    (*m_pDbgSymbolGroup)->GetNumberSymbols(&m_NumSymsDisplayed);
    if (m_NumSymsDisplayed < m_RefreshItem)
    {
        // numsyms changed since last click - might happen for locals

        m_RefreshItem = 0;
    }
    getSyms = m_NumSymsDisplayed - m_RefreshItem;
    if (m_NumSymsDisplayed > GetMaxSyms())
    {
        if ((Status = SetMaxSyms(m_NumSymsDisplayed)) != S_OK)
        {
            m_NumSymsDisplayed = 0;
            return Status;
        }
    }

    (*m_pDbgSymbolGroup)->GetSymbolParameters(m_RefreshItem, getSyms, GetSymParam() + m_RefreshItem);
    Empty();

    g_OutStateBuf.SetBuffer(this);
    if ((Status = g_OutStateBuf.Start(TRUE)) != S_OK)
    {
        return Status;
    }
    (*m_pDbgSymbolGroup)->OutputSymbols(DEBUG_OUTCTL_THIS_CLIENT |
        DEBUG_OUTCTL_OVERRIDE_MASK |
        DEBUG_OUTCTL_NOT_LOGGED,
        (m_DisplayOffsets ? 0 : DEBUG_OUTPUT_SYMBOLS_NO_OFFSETS) |
        (m_DisplayTypes ? 0 : DEBUG_OUTPUT_SYMBOLS_NO_TYPES),
        m_RefreshItem,
        m_NumSymsDisplayed - m_RefreshItem);

    Status = g_OutStateBuf.End(FALSE);
    m_UpdateItem = m_RefreshItem;
    m_RefreshItem = 0;
    return Status;
}

void
SYMWIN_DATA::ItemChanged(int Item, PCSTR Text)
{
    UIC_SYMBOL_WIN_DATA* WatchItem;

    if (m_nItem_CurrentlyEditing == -1)
    {
        return;
    }

    if (m_nSubItem_CurrentlyEditing == 0)
    {
        //
        // First delete, then add the item
        //

        if (Item < (int) GetMaxSyms() && Item < (int) m_NumSymsDisplayed)
        {
            //
            // See if this item can be changed or not - only root and dummy can be chnged
            //
            if ((GetSymParam())[Item].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK)
            {
                UiRequestRead();
                return;
            }
        }

        WatchItem = StartStructCommand(UIC_SYMBOL_WIN);
        if (WatchItem != NULL)
        {

            WatchItem->Type = DEL_SYMBOL_WIN_INDEX;

            WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
            WatchItem->u.DelIndex = Item;
            FinishCommand();
        }
        else
        {
            // XXX drewb - Failure?
        }

        WatchItem = StartStructCommand(UIC_SYMBOL_WIN);
        if (WatchItem != NULL)
        {
            WatchItem->Type = ADD_SYMBOL_WIN;
            WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
            CopyString(m_ChangedName, Text, DIMA(m_ChangedName));
            WatchItem->u.Add.Name = m_ChangedName;
            WatchItem->u.Add.Index = Item;
            FinishCommand();
        }

        if (g_Workspace != NULL)
        {
            g_Workspace->AddDirty(WSPF_DIRTY_WINDOWS);
        }
    }
    else if (m_nSubItem_CurrentlyEditing == 1)
    {
        WatchItem = StartStructCommand(UIC_SYMBOL_WIN);

        if (WatchItem != NULL)
        {
            CopyString(m_ChangedName, Text, DIMA(m_ChangedName));
            WatchItem->Type = EDIT_SYMBOL;
            WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
            WatchItem->u.WriteSymbol.Index = m_nItem_CurrentlyEditing;
            WatchItem->u.WriteSymbol.Value = m_ChangedName;
            FinishCommand();
        }
    }
    else if (m_nSubItem_CurrentlyEditing == 2)
    {
        WatchItem = StartStructCommand(UIC_SYMBOL_WIN);

        if (WatchItem != NULL)
        {
            CopyString(m_ChangedName, Text, DIMA(m_ChangedName));
            WatchItem->Type = EDIT_TYPE;
            WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
            WatchItem->u.OutputAsType.Index = m_nItem_CurrentlyEditing;
            WatchItem->u.OutputAsType.Type = m_ChangedName;
            FinishCommand();
        }
    }
    UiRequestRead();
}

void
SYMWIN_DATA::SetDisplayTypes(LONG Id, BOOL Set)
{
    if (Id == g_SymWinTbButtons[0].idCommand ||
        Id == g_SymWinTbButtons[1].idCommand)
    {
        //
        // Add / remove a column
        //
        if (Id == g_SymWinTbButtons[0].idCommand)
        {
            m_wFlags |= DL_EDIT_THIRDPANE;

            if (Set == m_DisplayTypes)
            {
                return;
            }

            m_DisplayTypes = Set;
        }
        else
        {
            if (Set == m_DisplayOffsets)
            {
                return;
            }

            m_DisplayOffsets = Set;
        }

        if (g_Workspace != NULL)
        {
            g_Workspace->AddDirty(WSPF_DIRTY_WINDOWS);
        }
        if (Id == g_SymWinTbButtons[1].idCommand)
        {
            //UiRequestRead();
            //return;
        }

        if (Set)
        {
            LV_COLUMN   lvc = {0};
            int         Col1Width;

            Col1Width = ListView_GetColumnWidth(m_hwndChild, VALUE_COLM);

            lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM | LVCF_TEXT;
            lvc.fmt = LVCFMT_LEFT;
            lvc.iSubItem = 0;

            if (Col1Width >= (m_Font->Metrics.tmAveCharWidth * 20))
            {
                lvc.cx = max(Col1Width / 4,
                             m_Font->Metrics.tmAveCharWidth * 10);
                Col1Width -= lvc.cx;
            } else
            {
                lvc.cx = Col1Width >> 1;
                Col1Width -= lvc.cx;
            }
            ListView_SetColumnWidth(m_hwndChild, VALUE_COLM, Col1Width);


            lvc.pszText = _T((Id == g_SymWinTbButtons[0].idCommand) ? "Type" : "Offset");
            ListView_InsertColumn(
                m_hwndChild,
                ((Id == g_SymWinTbButtons[0].idCommand) ? TYPE_COLM : OFFSET_COLM),
                &lvc);
            m_NumCols++;
        }
        else
        {
            if (Id == g_SymWinTbButtons[0].idCommand)
            {
                m_wFlags &= ~DL_EDIT_THIRDPANE;
            }

            int         Col2Width;
            int         Col1Width;
            int         ColToDel = ((Id == g_SymWinTbButtons[0].idCommand) ? TYPE_COLM : OFFSET_COLM);


            Col1Width = ListView_GetColumnWidth(m_hwndChild, VALUE_COLM);
            Col2Width = ListView_GetColumnWidth(m_hwndChild, ColToDel);

            ListView_DeleteColumn(m_hwndChild, ColToDel);
            ListView_SetColumnWidth(m_hwndChild, VALUE_COLM, Col1Width + Col2Width);
            m_NumCols--;
        }
        UiRequestRead();
    }
}


//the basic rutine making the ... thing
LPTSTR MakeShortString(HDC hDC, LPTSTR lpszLong, LONG nColumnLen,
                       LONG nOffset, PULONG pActualLen )
{
    static const _TCHAR szThreeDots[]=_T("...");
    SIZE strSz;

    int nStringLen = lstrlen(lpszLong);

    if (nStringLen==0 ||
        (GetTextExtentPoint(hDC, lpszLong,nStringLen,
                            &strSz), strSz.cx + nOffset < nColumnLen))
    {
        *pActualLen = nStringLen ? strSz.cx : 0;
        return(lpszLong);
    }
    *pActualLen = strSz.cx;

    static _TCHAR szShort[1024];

    if (nStringLen < sizeof(szShort) - 4)
    {
        lstrcpy(szShort, lpszLong);
    }
    else
    {
        nStringLen = sizeof(szShort) - 4;
        strncpy(szShort, lpszLong, nStringLen);
        szShort[nStringLen] = 0;
    }
    GetTextExtentPoint(hDC, szThreeDots, sizeof(szThreeDots), &strSz);
    int nAddLen = strSz.cx;

    for (int i = nStringLen - 1; i > 0; i--)
    {
        szShort[i] = 0;
        GetTextExtentPoint(hDC, szShort, i, &strSz);

        if(strSz.cx + nOffset + nAddLen < nColumnLen)
        {
            break;
        }
    }
    lstrcat(szShort, szThreeDots);
    return szShort;
}

void DrawRectangle(HDC hDc, POINT pt, ULONG width)
{
    POINT corners[5];

    corners[0] = pt;
    corners[1].x = pt.x; corners[1].y = pt.y + width;
    corners[2].x = pt.x + width; corners[2].y = pt.y + width;
    corners[3].x = pt.x + width; corners[3].y = pt.y;
    corners[4] = pt;

    Polyline(hDc, &corners[0], 5);
}

void DrawHorizLine(HDC hDc, POINT start, ULONG length, ULONG thick)
{
    POINT curr, pt = start;

    while (thick)
    {
        MoveToEx(hDc, pt.x, pt.y, &curr);
        LineTo(hDc, pt.x + length, pt.y);

        --thick;
        ++pt.y;
    }
}

void DrawPlus(HDC hDc, POINT topLeft, ULONG width)
{
    if (g_UseTextMode)
    {
        TextOut(hDc, topLeft.x, topLeft.y - width/2, "+", 1);
        return;
    }
    POINT curr, pt = topLeft;
        DrawRectangle(hDc, pt, width);

    MoveToEx(hDc, pt.x, pt.y + width/2, &curr);
        LineTo(hDc, pt.x + width, pt.y + width/2);

    MoveToEx(hDc, pt.x + width/2, pt.y, &curr);
        LineTo(hDc, pt.x + width/2, pt.y + width);
}


void DrawMinus(HDC hDc, POINT topLeft, ULONG width)
{
    if (g_UseTextMode)
    {
        TextOut(hDc, topLeft.x, topLeft.y - width/2, "-", 1);
        return;
    }

    POINT curr, pt = topLeft;
        DrawRectangle(hDc, pt, width);

    MoveToEx(hDc, pt.x, pt.y + width/2, &curr);
        LineTo(hDc, pt.x + width, pt.y + width/2);
}



void DrawIndentLevel(HDC hDc, ULONG Indent, RECT leftRect)
{
    POINT curr, pt;
    ULONG i;
    INT   width, height;

    pt.x = leftRect.left;
    pt.y = leftRect.top;

    width = leftRect.right - leftRect.left;
    height = leftRect.bottom - leftRect.top;

    for (i=0;i<Indent; i++,pt.x+=width)
    {
        if (g_UseTextMode)
        {
            TextOut(hDc, pt.x, pt.y, "|",1);
            continue;
        }
        MoveToEx(hDc, pt.x + width/2, pt.y, &curr);
        LineTo(hDc, pt.x + width/2, pt.y + height);
        if (i+1==Indent)
        {
            MoveToEx(hDc, pt.x + width/2, pt.y + height/2, &curr);
            LineTo(hDc, pt.x + width - 1, pt.y + height/2);
        }
    }
}

#define NAME_LEFT_PAD 6

void
SYMWIN_DATA::DrawTreeItem(HDC hDC, ULONG itemID, RECT ItemRect, PULONG pIndentOffset)
{
    ULONG RectWidth;
    ULONG level;
    TEXTMETRIC tm;

    if (itemID >= m_NumSymsDisplayed)
    {
        return;
    }

    // derive the Width of +/- from tm
    GetTextMetrics(hDC, &tm);
    RectWidth = (tm.tmHeight * 2) / 3;

    level = m_pWinSyms[itemID].Flags & DEBUG_SYMBOL_EXPANSION_LEVEL_MASK;

    // Rectangle for One indent level
    RECT IndentRc;
    IndentRc = ItemRect;
    IndentRc.left  = ItemRect.left + 2;
    IndentRc.right = IndentRc.left + RectWidth + 1;
    DrawIndentLevel(hDC, level, IndentRc);

    *pIndentOffset = level * (RectWidth+1) + NAME_LEFT_PAD;
    POINT pt;
    pt.x = ItemRect.left + *pIndentOffset - 4;
    pt.y = (ItemRect.top + ItemRect.bottom - RectWidth) / 2;

    if (m_pWinSyms[itemID].Flags & DEBUG_SYMBOL_EXPANDED)
    {
        DrawMinus(hDC, pt, RectWidth);
    } else if (m_pWinSyms[itemID].SubElements)
    {
        DrawPlus(hDC, pt, RectWidth);
    }

    m_IndentWidth   = RectWidth+1;
    *pIndentOffset += RectWidth+1;
}

LRESULT
SYMWIN_DATA::OnOwnerDraw(UINT uMsg, WPARAM wParam, LPARAM lParam)
{

    LPDRAWITEMSTRUCT lpdis;
    TEXTMETRIC tm;
    ULONG IndentOffset = 0, ActualWidth;


    if (uMsg == WM_MEASUREITEM)
    {
        MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT * ) lParam;
        HDC hDC = GetDC(m_hwndChild);
        GetTextMetrics(hDC, &tm);
        lpmis->CtlType = ODT_LISTVIEW;
        lpmis->itemHeight = tm.tmHeight;
        lpmis->itemWidth  = m_MaxNameWidth;
        ReleaseDC(m_hwndChild, hDC);

        return TRUE;
    }
    else
    {
        // Assert (uMsg == WM_DRAWITEM);
    }

    lpdis = (LPDRAWITEMSTRUCT) lParam;

    int y;
    TCHAR Buffer[NAME_BUFFER];
    int Col;
    LPTSTR pszText=&Buffer[0];


    // If there are no list box items, skip this message.
    if (lpdis->itemID == -1)
    {
        return FALSE;
    }

    switch (lpdis->itemAction)
    {
    case ODA_SELECT:
    case ODA_DRAWENTIRE:
    {
        HBRUSH hBrush;
        DWORD  dwOldTextColor, dwOldBkColor, TextColor;

        if (g_ExecStatus != DEBUG_STATUS_BREAK)
        {
            dwOldTextColor = ListView_GetTextColor(m_hwndChild);
            dwOldBkColor =   ListView_GetBkColor(m_hwndChild);

            hBrush = g_Colors[COL_DISABLED_WINDOW].Brush;

            TextColor = dwOldTextColor =
                SetTextColor(lpdis->hDC, dwOldTextColor);
            dwOldBkColor = SetBkColor(lpdis->hDC,
                                      g_Colors[COL_DISABLED_WINDOW].Color);
        }
        else if (lpdis->itemState & ODS_SELECTED)
        {
            hBrush = g_Colors[COL_CURRENT_LINE].Brush;
            TextColor = g_Colors[COL_CURRENT_LINE_TEXT].Color;

            dwOldTextColor = SetTextColor(lpdis->hDC, TextColor);
            dwOldBkColor = SetBkColor(lpdis->hDC,
                                      g_Colors[COL_CURRENT_LINE].Color);
        }
        else // item not selected
        {
            hBrush = g_Colors[COL_PLAIN].Brush;
            TextColor = g_Colors[COL_PLAIN_TEXT].Color;

            dwOldTextColor = SetTextColor(lpdis->hDC, TextColor);
            dwOldBkColor = SetBkColor(lpdis->hDC,
                                      g_Colors[COL_PLAIN].Color);
        }

        if (hBrush != NULL)
        {
            FillRect(lpdis->hDC, (LPRECT)&lpdis->rcItem, hBrush);
        }

        // Display the text associated with the item.

        ListView_GetItemText(m_hwndChild, lpdis->itemID,
                             0, Buffer, sizeof(Buffer));

        GetTextMetrics(lpdis->hDC, &tm);

        y = (lpdis->rcItem.bottom + lpdis->rcItem.top -
             tm.tmHeight) / 2;

        RECT rc = lpdis->rcItem;

        if (m_SplitWindowAtItem && (lpdis->itemID == m_SplitWindowAtItem))
        {
            POINT pt = {rc.left, rc.top-1};

            DrawHorizLine(lpdis->hDC, pt, rc.right - rc.left, 2);

            rc.top++;
        }

        LV_COLUMN lvc;
        lvc.mask = LVCF_FMT | LVCF_WIDTH;

        RECT rc2;
        ListView_GetSubItemRect(m_hwndChild, lpdis->itemID,
                                1, LVIR_BOUNDS,
                                &rc2);

        rc.right = rc2.left;

        DrawTreeItem(lpdis->hDC, lpdis->itemID, rc, &IndentOffset);

        while (*pszText && *pszText == ' ')
        {
            ++pszText;
        }
        pszText = MakeShortString(lpdis->hDC, pszText, rc.right-rc.left,
                                  2 + IndentOffset, &ActualWidth);
        TextOut(lpdis->hDC, rc.left + IndentOffset, y,
                pszText, strlen(pszText));

        if (m_MaxNameWidth < (2 + IndentOffset*3/2 + ActualWidth))
        {
            m_MaxNameWidth = 2 + IndentOffset*3/2 + ActualWidth;
        }

        for (Col = 1;
             //ListView_GetColumn(m_hwndChild, Col, &lvc);
             Col < (int) m_NumCols;
             Col++)
        {
            if (!ListView_GetSubItemRect(m_hwndChild,
                                         lpdis->itemID,
                                         Col,
                                         LVIR_BOUNDS,
                                         &rc))
            {
                // invalid coulmn
                break;
            }

            ListView_GetItemText(m_hwndChild, lpdis->itemID,
                                 Col, Buffer, sizeof(Buffer));
            int nRetLen = strlen(Buffer);

            if (nRetLen == 0)
            {
                pszText = "";
            }
            else
            {
                pszText = MakeShortString(lpdis->hDC, Buffer,
                                          rc.right - rc.left, 2, &ActualWidth);
            }

            if ((Col == 1) &&
                (m_NumSymsDisplayed > lpdis->itemID))
            {
                if (m_pWinSyms[lpdis->itemID].Flags & ITEM_VALUE_CHANGED)
                {
                    SetTextColor(lpdis->hDC,
                                 g_Colors[COL_CHANGED_DATA_TEXT].Color);
                }
            }

            TextOut(lpdis->hDC, rc.left + 2, y, pszText, strlen(pszText));

            if (m_pWinSyms[lpdis->itemID].Flags & ITEM_VALUE_CHANGED)
            {
                SetTextColor(lpdis->hDC, TextColor);
            }
        }

        // restore text and back ground color of list box's selection
        SetTextColor(lpdis->hDC, dwOldTextColor);
        SetBkColor(lpdis->hDC, dwOldBkColor);

        return TRUE;
    }

    case ODA_FOCUS:
        // Do not process focus changes. The focus caret
        // (outline rectangle) indicates the selection.
        break;
    }

    return DefMDIChildProc(m_Win, WM_DRAWITEM, wParam, lParam);
}

void
SYMWIN_DATA::SyncUiWithFlags(ULONG Changed)
{
    if (Changed & (1 << SYMWIN_TBB_TYPECAST))
    {
        SendMessage(m_Toolbar, TB_SETSTATE, SYMWIN_TBB_TYPECAST,
                    TBSTATE_ENABLED |
                    (m_DisplayTypes ? TBSTATE_CHECKED : 0));
    }
    if (Changed & (1 << SYMWIN_TBB_OFFSETS))
    {
        SendMessage(m_Toolbar, TB_SETSTATE, SYMWIN_TBB_OFFSETS,
                    TBSTATE_ENABLED |
                    (m_DisplayOffsets ? TBSTATE_CHECKED : 0));
    }
}

//
// WATCHWIN_DATA methods
//

extern IDebugSymbolGroup * g_pDbgWatchSymbolGroup;
WATCHWIN_DATA::WATCHWIN_DATA()
    : SYMWIN_DATA(&g_pDbgWatchSymbolGroup)
{
    m_wFlags   = DL_EDIT_LEFTPANE;
    m_enumType = WATCH_WINDOW;
}

void
WATCHWIN_DATA::Validate()
{
    SYMWIN_DATA::Validate();

    Assert(WATCH_WINDOW == m_enumType);
}

HRESULT
WATCHWIN_DATA::ReadState(void)
{
    m_pDbgSymbolGroup = &g_pDbgWatchSymbolGroup;
    return SYMWIN_DATA::ReadState();
}

#define WATCH_WRKSPC_TAG          0x40404040
//
// Workspace
//     0                4        8
//     WATCH_WRKSPC_TAG NUM syms [Null terminated names]
//
ULONG
WATCHWIN_DATA::GetWorkspaceSize(void)
{
    ULONG i;
    ULONG Size = 2*sizeof(ULONG);
    PDEBUG_SYMBOL_PARAMETERS SymParam;

    for (SymParam = GetSymParam(), i = 0;
         i < m_NumSymsDisplayed;
         SymParam++, i++)
    {
        if (IsRootSym(SymParam))
        {
            CHAR Text[500] = {0};

            ListView_GetItemText(m_hwndChild, i, 0, Text, sizeof(Text));

            Size += strlen(Text) + 1;
        }
    }
    return SYMWIN_DATA::GetWorkspaceSize() + Size;
}

PUCHAR
WATCHWIN_DATA::SetWorkspace(PUCHAR Data)
{
    Data = SYMWIN_DATA::SetWorkspace(Data);
    PULONG pNumSyms, watchWrkspc = (PULONG) Data;

    *watchWrkspc  = WATCH_WRKSPC_TAG;
    pNumSyms = (PULONG) (Data + sizeof(ULONG));
    *pNumSyms = 0;
    Data += 2 * sizeof(ULONG);

    ULONG i;
    PDEBUG_SYMBOL_PARAMETERS SymParam;

    for (SymParam = GetSymParam(), i = 0;
         i < m_NumSymsDisplayed;
         SymParam++, i++)
    {
        if (IsRootSym(SymParam))
        {
            CHAR Text[500] = {0}, *pName = &Text[0];

            ListView_GetItemText(m_hwndChild, i, 0, Text, sizeof(Text));
            strcpy((PCHAR) Data, pName);
            Data += strlen(pName) + 1;
            *pNumSyms = *pNumSyms + 1;
        }
    }

    return Data;
}

PUCHAR
WATCHWIN_DATA::ApplyWorkspace1(PUCHAR Data, PUCHAR End)
{
    Data = SYMWIN_DATA::ApplyWorkspace1(Data, End);

    if (*((PULONG) Data) == WATCH_WRKSPC_TAG &&
        End >= Data + 2 * sizeof(ULONG))
    {
        Data += sizeof(ULONG);

        ULONG NumSyms = *((PULONG) Data);
        ULONG i = 0;
        Data += sizeof(ULONG);

        PCHAR Name = (PCHAR) Data, pCopyName = &m_ChangedName[0];

        while ((Data < End) && (i<NumSyms))
        {
            UIC_SYMBOL_WIN_DATA* WatchItem;

            while (*Name == ' ')
            {
                // eat out space in begining
                ++Name;
            }
            if (pCopyName + strlen(Name) >=
                &m_ChangedName[sizeof(m_ChangedName) - 1])
            {
                Data = End;
                break;
            }
            strcpy(pCopyName, Name);
            WatchItem = StartStructCommand(UIC_SYMBOL_WIN);
            if (WatchItem != NULL)
            {
                WatchItem->Type = ADD_SYMBOL_WIN;
                WatchItem->pSymbolGroup = m_pDbgSymbolGroup;
                WatchItem->u.Add.Name = pCopyName;
                WatchItem->u.Add.Index = i;
                FinishCommand();
            }
            ++i;
            pCopyName += strlen(pCopyName) + 1;
            while (*Data != 0)
            {
                ++Data;
            }
            ++Data;
            Name = (PCHAR) Data;
        }
    }
    return Data;
}

//
// LOCALSWIN_DATA methods
//
extern IDebugSymbolGroup * g_pDbgLocalSymbolGroup;
LOCALSWIN_DATA::LOCALSWIN_DATA()
    : SYMWIN_DATA(&g_pDbgLocalSymbolGroup)
{
    m_enumType = LOCALS_WINDOW;
}

void
LOCALSWIN_DATA::Validate()
{
    DUALLISTWIN_DATA::Validate();

    Assert(LOCALS_WINDOW == m_enumType);
}

LOCALSWIN_DATA::~LOCALSWIN_DATA()
{
}

BOOL
LOCALSWIN_DATA::OnCreate(void)
{

    if (!SYMWIN_DATA::OnCreate())
    {
        return FALSE;
    }

    return TRUE;

}

HRESULT
LOCALSWIN_DATA::ReadState(void)
{
    HRESULT Hr;
    IDebugSymbolGroup *pLocalSymbolGroup;

    if (g_ScopeChanged)
    {
        //
        // Get the new locals
        //
        if ((Hr = g_pDbgSymbols->GetScopeSymbolGroup(DEBUG_SCOPE_GROUP_LOCALS,
                                                    g_pDbgLocalSymbolGroup,
                                                    &pLocalSymbolGroup)) == E_NOTIMPL)
        {
            // Older engine version
            Hr = g_pDbgSymbols->GetScopeSymbolGroup(DEBUG_SCOPE_GROUP_ALL,
                                                    g_pDbgLocalSymbolGroup,
                                                    &pLocalSymbolGroup);
        }
        if (Hr == S_OK)
        {
            g_pDbgLocalSymbolGroup = pLocalSymbolGroup;
            m_pDbgSymbolGroup = &g_pDbgLocalSymbolGroup;
            g_ScopeChanged = FALSE;
        }
        else
        {
            //
            // Keep the old values
            //
            return E_PENDING;
        }
    }

    return SYMWIN_DATA::ReadState();
}

//
// CPUWIN_DATA methods
//

HMENU CPUWIN_DATA::s_ContextMenu;

CPUWIN_DATA::CPUWIN_DATA()
    : DUALLISTWIN_DATA(1024)
{
    m_wFlags |= DL_CUSTOM_ITEMS;
    m_enumType = CPU_WINDOW;
    m_ProcType = IMAGE_FILE_MACHINE_UNKNOWN;
    m_NamesProcType = IMAGE_FILE_MACHINE_UNKNOWN;
    m_NumRegisters = 0;
    m_CheckChanged = FALSE;
}

void
CPUWIN_DATA::Validate()
{
    DUALLISTWIN_DATA::Validate();

    Assert(CPU_WINDOW == m_enumType);
}

HRESULT
CPUWIN_DATA::ReadState(void)
{
    HRESULT Status;
    PDEBUG_VALUE OldVals;
    ULONG NumOld, NumReg;
    PDEBUG_VALUE Vals;
    PDEBUG_VALUE Coerced;
    PULONG Types;
    PBOOL Changed;
    ULONG ProcType;
    BOOL ProcChanged;

    NumOld = m_NumRegisters;

    if ((Status = g_pDbgRegisters->
         GetNumberRegisters(&NumReg)) != S_OK ||
        (Status = g_pDbgControl->
         GetEffectiveProcessorType(&ProcType)) != S_OK)
    {
        return Status;
    }

    ProcChanged = ProcType != m_ProcType;

    Empty();

    //
    // Retrieve all register values and diff them.
    // Also keep space for a coercion type map and
    // temporary coerced values.
    //

    OldVals = (PDEBUG_VALUE)
        AddData(NumReg * (3 * sizeof(DEBUG_VALUE) + sizeof(ULONG) +
                          sizeof(BOOL)));
    if (OldVals == NULL)
    {
        return E_OUTOFMEMORY;
    }
    Changed = (PBOOL)(OldVals + NumReg);
    Coerced = (PDEBUG_VALUE)(Changed + NumReg);
    Vals = Coerced + NumReg;
    Types = (PULONG)(Vals + NumReg);

    Status = g_pDbgRegisters->GetValues(NumReg, NULL, 0, Vals);
    if (Status != S_OK)
    {
        return Status;
    }

    ULONG i;

    // Coerce values into known types.
    // If it's an integer value coerce it to 64-bit.
    // If it's a float value coerce to 64-bit also,
    // which loses precision but has CRT support for
    // formatting.
    for (i = 0; i < NumReg; i++)
    {
        if (Vals[i].Type >= DEBUG_VALUE_INT8 &&
            Vals[i].Type <= DEBUG_VALUE_INT64)
        {
            Types[i] = DEBUG_VALUE_INT64;
        }
        else if (Vals[i].Type >= DEBUG_VALUE_FLOAT32 &&
                 Vals[i].Type <= DEBUG_VALUE_FLOAT128)
        {
            Types[i] = DEBUG_VALUE_FLOAT64;
        }
        else if (Vals[i].Type == DEBUG_VALUE_VECTOR64 ||
                 Vals[i].Type == DEBUG_VALUE_VECTOR128)
        {
            Types[i] = Vals[i].Type;
        }
        else
        {
            // Unknown type.
            return E_INVALIDARG;
        }
    }

    if ((Status = g_pDbgControl->
        CoerceValues(NumReg, Vals, Types, Coerced)) != S_OK)
    {
        return Status;
    }

    // Diff new values against the old.
    for (i = 0; i < NumReg; i++)
    {
        // Ignore differences if the processor has changed.
        if (!ProcChanged && i < NumOld)
        {
            switch(Types[i])
            {
            case DEBUG_VALUE_INT64:
                Changed[i] = Coerced[i].I64 != OldVals[i].I64;
                break;
            case DEBUG_VALUE_FLOAT64:
                Changed[i] = Coerced[i].F64 != OldVals[i].F64;
                break;
            case DEBUG_VALUE_VECTOR64:
                Changed[i] = memcmp(Coerced[i].RawBytes, OldVals[i].RawBytes,
                                    8);
                break;
            case DEBUG_VALUE_VECTOR128:
                Changed[i] = memcmp(Coerced[i].RawBytes, OldVals[i].RawBytes,
                                    16);
                break;
            }
        }
        else
        {
            Changed[i] = FALSE;
        }
    }

    // Copy new values into permanent storage area.
    memmove(OldVals, Coerced, NumReg * sizeof(*Vals));

    // Trim off temporary information.
    RemoveTail(NumReg * (2 * sizeof(DEBUG_VALUE) + sizeof(ULONG)));

    m_NumRegisters = NumReg;
    m_ProcType = ProcType;
    if (ProcChanged)
    {
        UpdateBufferWindows(1 << CPU_WINDOW, UPDATE_REG_NAMES);
    }

    return Status;
}

#define CPU_CONTEXT_ID_BASE 0x100

TBBUTTON g_CpuTbButtons[] =
{
    TEXT_TB_BTN(ID_CUSTOMIZE, "Customize...", 0),
    SEP_TB_BTN(),
    TEXT_TB_BTN(ID_SHOW_TOOLBAR, "Toolbar", 0),
};

#define NUM_CPU_MENU_BUTTONS \
    (sizeof(g_CpuTbButtons) / sizeof(g_CpuTbButtons[0]))
#define NUM_CPU_TB_BUTTONS \
    (NUM_CPU_MENU_BUTTONS - 2)

HMENU
CPUWIN_DATA::GetContextMenu(void)
{
    //
    // We only keep one menu around for all CPU windows
    // so apply the menu check state for this particular
    // window.
    // In reality there's only one CPU window anyway,
    // but this is a good example of how to handle
    // multi-instance windows.
    //

    CheckMenuItem(s_ContextMenu, ID_SHOW_TOOLBAR + CPU_CONTEXT_ID_BASE,
                  MF_BYCOMMAND | (m_ShowToolbar ? MF_CHECKED : 0));

    return s_ContextMenu;
}

void
CPUWIN_DATA::OnContextMenuSelection(UINT Item)
{
    StateBuffer* NameBuf;

    Item -= CPU_CONTEXT_ID_BASE;

    switch(Item)
    {
    case ID_CUSTOMIZE:
        NameBuf = GetRegisterNames(m_ProcType);
        if (!NameBuf ||
            (NameBuf->UiLockForRead() != S_OK))
        {
            ErrorBox(NULL, 0, ERR_No_Register_Names);
        }
        else
        {
            int Res =
                StartDialog(IDD_DLG_REG_CUSTOMIZE, DlgProc_RegCustomize,
                            (LPARAM)NameBuf);
            UnlockStateBuffer(NameBuf);
            if (Res == IDOK)
            {
                UpdateNames(TRUE);
                OnUpdate(UPDATE_BUFFER);
            }
        }
        break;
    case ID_SHOW_TOOLBAR:
        SetShowToolbar(!m_ShowToolbar);
        break;
    }
}

BOOL
CPUWIN_DATA::OnCreate(void)
{
    if (s_ContextMenu == NULL)
    {
        s_ContextMenu = CreateContextMenuFromToolbarButtons
            (NUM_CPU_MENU_BUTTONS, g_CpuTbButtons, CPU_CONTEXT_ID_BASE);
        if (s_ContextMenu == NULL)
        {
            return FALSE;
        }
    }

    if (!DUALLISTWIN_DATA::OnCreate())
    {
        return FALSE;
    }

    m_Toolbar = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
                    WS_CHILD | WS_VISIBLE |
                    TBSTYLE_WRAPABLE | TBSTYLE_LIST | CCS_TOP,
                    0, 0, m_Size.cx, 0, m_Win, (HMENU)ID_TOOLBAR,
                    g_hInst, NULL);
    if (m_Toolbar == NULL)
    {
        return FALSE;
    }
    SendMessage(m_Toolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
    SendMessage(m_Toolbar, TB_ADDBUTTONS, NUM_CPU_TB_BUTTONS,
        (LPARAM)&g_CpuTbButtons);
    SendMessage(m_Toolbar, TB_AUTOSIZE, 0, 0);

    RECT Rect;
    GetClientRect(m_Toolbar, &Rect);
    m_ToolbarHeight = Rect.bottom - Rect.top + GetSystemMetrics(SM_CYEDGE);
    m_ShowToolbar = TRUE;

    SendMessage(m_hwndChild, WM_SETREDRAW, FALSE, 0);

    RECT        rc;
    LV_COLUMN   lvc = {0};

    GetClientRect(m_hwndChild, &rc);
    rc.right -= rc.left + GetSystemMetrics(SM_CXVSCROLL);

    //initialize the columns
    lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM | LVCF_TEXT;
    lvc.fmt = LVCFMT_LEFT;
    lvc.iSubItem = 0;

    // Keep the register name column narrow since most names are short.
    lvc.cx = m_Font->Metrics.tmAveCharWidth * 7;
    if (lvc.cx > rc.right / 2)
    {
        lvc.cx = rc.right / 2;
    }
    lvc.pszText = _T("Reg");
    Dbg( (0 == ListView_InsertColumn(m_hwndChild, 0, &lvc)) );

    // Give the rest of the space to the value.
    lvc.cx = rc.right - lvc.cx;
    lvc.pszText = _T("Value");
    Dbg( (1 == ListView_InsertColumn(m_hwndChild, 1, &lvc)) );

    ListView_SetExtendedListViewStyle(m_hwndChild,
        LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT
        );

    UpdateNames(FALSE);

    SendMessage(m_hwndChild, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(m_hwndChild, NULL, TRUE);

    return TRUE;
}

LRESULT
CPUWIN_DATA::OnCommand(
    WPARAM wParam,
    LPARAM lParam
    )
{
    if ((HWND)lParam == m_Toolbar)
    {
        OnContextMenuSelection(LOWORD(wParam) + CPU_CONTEXT_ID_BASE);
        return 0;
    }

    return DUALLISTWIN_DATA::OnCommand(wParam, lParam);
}

void
CPUWIN_DATA::OnSize(void)
{
    DUALLISTWIN_DATA::OnSize();

    // The register label column stays fixed in size so
    // resize the value column to fit the remaining space.
    ListView_SetColumnWidth(m_hwndChild, 1, LVSCW_AUTOSIZE_USEHEADER);
}

void
CPUWIN_DATA::OnUpdate(UpdateType Type)
{
    if (Type == UPDATE_EXEC)
    {
        // Disallow editing when the debuggee is running.
        if (g_ExecStatus == DEBUG_STATUS_BREAK)
        {
            m_wFlags |= DL_EDIT_SECONDPANE;
            ListView_SetTextBkColor(m_hwndChild, g_Colors[COL_PLAIN].Color);
        }
        else
        {
            m_wFlags &= ~DL_EDIT_SECONDPANE;
            ListView_SetTextBkColor(m_hwndChild,
                                    g_Colors[COL_DISABLED_WINDOW].Color);
        }
        InvalidateRect(m_hwndChild, NULL, FALSE);
        return;
    }
    else if (Type == UPDATE_START_SESSION ||
             Type == UPDATE_END_SESSION)
    {
        m_ProcType = IMAGE_FILE_MACHINE_UNKNOWN;
        m_NumRegisters = 0;
        m_CheckChanged = Type != UPDATE_START_SESSION;
        return;
    }
    else if (Type == UPDATE_REG_NAMES)
    {
        UpdateNames(FALSE);
        return;
    }
    else if (Type != UPDATE_BUFFER)
    {
        return;
    }

    PDEBUG_VALUE Vals = NULL;
    PBOOL Changed = NULL;
    HRESULT Status;
    RegisterNamesStateBuffer* NameBuf = GetRegisterNames(m_ProcType);
    PTSTR RegNames = NULL;
    PULONG RegTypes = NULL;

    SendMessage(m_hwndChild, WM_SETREDRAW, FALSE, 0);

    Status = UiLockForRead();
    if (Status == S_OK)
    {
        Vals = (PDEBUG_VALUE)m_Data;
        Changed = (PBOOL)(Vals + m_NumRegisters);
    }

    if (NameBuf &&
        NameBuf->UiLockForRead() == S_OK)
    {
        RegTypes = (PULONG)NameBuf->GetDataBuffer();
        RegNames = (PTSTR)NameBuf->GetDataBuffer() +
            NameBuf->m_NamesOffset;
    }
    
    if (NameBuf &&
        (NameBuf->m_Flags & REGCUST_CHANGED_FIRST))
    {
        ULONG Idx = 0;

        // Set the changed values first.
        Idx = SetRegVals(Status, Vals, Changed, NameBuf, RegTypes,
                         RegNames, Idx, TRUE, TRUE);
        // Set the remainder.
        Idx = SetRegVals(Status, Vals, Changed, NameBuf, RegTypes,
                         RegNames, Idx, TRUE, FALSE);
    }
    else
    {
        SetRegVals(Status, Vals, Changed, NameBuf, RegTypes,
                   NULL, 0, FALSE, FALSE);
    }

    if (RegTypes)
    {
        UnlockStateBuffer(NameBuf);
    }

    if (Status == S_OK)
    {
        UnlockStateBuffer(this);
    }

    SendMessage(m_hwndChild, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(m_hwndChild, NULL, TRUE);
    m_CheckChanged = TRUE;
}

ULONG
CPUWIN_DATA::SetRegVals(HRESULT LockStatus,
                        PDEBUG_VALUE Vals,
                        PBOOL Changed,
                        RegisterNamesStateBuffer* NameBuf,
                        PULONG RegTypes,
                        PTSTR RegNames,
                        ULONG EntryIdx,
                        BOOL MatchChanged,
                        BOOL MatchChangedVal)
{
    ULONG i;
    PDEBUG_VALUE Val;
    TCHAR TextBuf[256];
    PTSTR Str;
    BOOL ChangeFlag;
    USHORT EngReg;
    ULONG RegType;
    
    for (i = 0; i < m_NumRegisters; i++)
    {
        ChangeFlag = FALSE;
        EngReg = 0xffff;
        RegType = DEBUG_VALUE_INT64;

        if (LockStatus == S_FALSE)
        {
            _tcscpy(TextBuf, _T("Retrieving"));
        }
        else if (FAILED(LockStatus) || !Vals || !NameBuf)
        {
            _tcscpy(TextBuf, _T("Error"));
        }
        else
        {
            EngReg = NameBuf->MapUserToEngine(i);

            RegType = RegTypes[EngReg * 2];
            if ((NameBuf->m_Flags & REGCUST_NO_SUBREG) &&
                (RegTypes[EngReg * 2 + 1] & DEBUG_REGISTER_SUB_REGISTER))
            {
                continue;
            }
            
            Val = Vals + EngReg;
            // If this is a new session consider everything
            // unchanged since comparisons may be against
            // values from the previous session.
            if (m_CheckChanged)
            {
                ChangeFlag = Changed[EngReg];
            }

            if (MatchChanged && ChangeFlag != MatchChangedVal)
            {
                continue;
            }
            
            // Buffer values are coerced into known types.
            switch(Val->Type)
            {
            case DEBUG_VALUE_INT64:
                CPFormatMemory(TextBuf, _tsizeof(TextBuf),
                               (LPBYTE)&Val->I64, 64, fmtUInt, g_NumberRadix);
                break;
            case DEBUG_VALUE_FLOAT64:
                CPFormatMemory(TextBuf, _tsizeof(TextBuf),
                               (LPBYTE)&Val->F64, 64, fmtFloat, 10);
                break;
            case DEBUG_VALUE_VECTOR64:
                // Assume they want it as v4i16.
                Str = TextBuf;
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VI16[3], 16, fmtUInt,
                               g_NumberRadix);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VI16[2], 16, fmtUInt,
                               g_NumberRadix);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VI16[1], 16, fmtUInt,
                               g_NumberRadix);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VI16[0], 16, fmtUInt,
                               g_NumberRadix);
                break;
            case DEBUG_VALUE_VECTOR128:
                // Assume they want it as v4f32.
                Str = TextBuf;
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VF32[3], 32, fmtFloat, 10);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VF32[2], 32, fmtFloat, 10);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VF32[1], 32, fmtFloat, 10);
                Str += strlen(Str);
                *Str++ = ':';
                CPFormatMemory(Str, _tsizeof(TextBuf) - (ULONG)(Str - TextBuf),
                               (LPBYTE)&Val->VF32[0], 32, fmtFloat, 10);
                break;
            default:
                Assert(FALSE);
                break;
            }
        }

        ULONG ItemFlags = GetItemFlags(EntryIdx);

        ItemFlags &= ~ITEM_USER_FLAGS;
        ItemFlags |= RegToFlags(EngReg);
        
        if (RegType >= DEBUG_VALUE_FLOAT32 &&
            RegType <= DEBUG_VALUE_FLOAT128)
        {
            ItemFlags |= ITEM_FLOATING_POINT;
        }
        else
        {
            ItemFlags &= ~ITEM_FLOATING_POINT;
        }

        if (ChangeFlag)
        {
            ItemFlags |= ITEM_CHANGED;
        }
        else
        {
            ItemFlags &= ~ITEM_CHANGED;
        }

        SetItemFlags(EntryIdx, ItemFlags);

        if (RegNames)
        {
            PTSTR Name = RegNames;
            while (EngReg-- > 0)
            {
                Name += strlen(Name) + 1;
            }

            ListView_SetItemText(m_hwndChild, EntryIdx, 0, Name);
        }
        
        ListView_SetItemText(m_hwndChild, EntryIdx, 1, TextBuf);

        EntryIdx++;
    }

    return EntryIdx;
}

void
CPUWIN_DATA::ItemChanged(int Item, PCSTR Text)
{
    UIC_SET_REG_DATA* SetRegData;
    ULONG ItemFlags = GetItemFlags(Item);
    
    USHORT Reg = FlagsToReg(ItemFlags);
    if (Reg == 0xffff)
    {
        // Invalid register.
        return;
    }

    SetRegData = StartStructCommand(UIC_SET_REG);
    if (SetRegData != NULL)
    {
        SetRegData->Reg = Reg;

        // Default the guess about the value type based
        // on whether the value includes a decimal point
        // or not.  If we can access the stored register
        // description information we'll use that to
        // override.
        BOOL IsFloat = strchr(Text, '.') != NULL;

        if (ItemFlags & ITEM_FLOATING_POINT)
        {
            IsFloat = TRUE;
        }

        if (IsFloat)
        {
            SetRegData->Val.Type = DEBUG_VALUE_FLOAT64;
            if (sscanf(Text, "%lf", &SetRegData->Val.F64) != 1)
            {
                SetRegData->Val.F64 = 0.0;
            }
        }
        else
        {
            SetRegData->Val.Type = DEBUG_VALUE_INT64;
            switch(g_NumberRadix)
            {
            case 10:
                if (sscanf(Text, "%I64d", &SetRegData->Val.I64) != 1)
                {
                    SetRegData->Val.I64 = 0;
                }
                break;
            default:
                if (sscanf(Text, "%I64x", &SetRegData->Val.I64) != 1)
                {
                    SetRegData->Val.I64 = 0;
                }
                break;
            }
            // XXX drewb - What about IA64 NAT bits?
            SetRegData->Val.Nat = FALSE;
        }

        FinishCommand();
    }
}

LRESULT
CPUWIN_DATA::OnCustomItem(ULONG SubItem, LPNMLVCUSTOMDRAW Custom)
{
    if (SubItem == 1)
    {
        // Check changed flag stored in lParam.
        if (Custom->nmcd.lItemlParam & ITEM_CHANGED)
        {
            Custom->clrText = g_Colors[COL_CHANGED_DATA_TEXT].Color;
        }
    }
    return CDRF_NOTIFYSUBITEMDRAW;
}

void
CPUWIN_DATA::UpdateNames(BOOL FullUpdate)
{
    ULONG i;
    ULONG EntryIdx = 0;
    PSTR Name;
    LVITEM LvItem = {0};
    RegisterNamesStateBuffer* NameBuf;
    PULONG RegTypes = NULL;
    PSTR RegNames = NULL;
    ULONG ProcType = m_ProcType;
    BOOL NameChange = FullUpdate || ProcType != m_NamesProcType;

    //
    // This routine has two primary functions: to set
    // up the register window properly for a register set
    // and also to set the register names properly.
    // In the first case the register window must be cleared
    // and all items recreated for the given processor type.
    // During this operation the register names for the given
    // processor type may not have been retrieved yet, so
    // all of the register names will be set as unknown.  The
    // important part of the operation is then just creating
    // the proper number of items.  A later update will come
    // through when the names are retrieved and at that point
    // a simple name-label-only update will occur.
    //

    NameBuf = GetRegisterNames(ProcType);
    if (NameBuf)
    {
        // If the entries are being sorted by change the
        // names will get updated there and we do not
        // want to do it here.
        if (!NameChange && (NameBuf->m_Flags & REGCUST_CHANGED_FIRST))
        {
            return;
        }

        if (NameBuf->UiLockForRead() == S_OK)
        {
            RegTypes = (PULONG)NameBuf->GetDataBuffer();
            RegNames = (PSTR)NameBuf->GetDataBuffer() +
                NameBuf->m_NamesOffset;
        }
    }

    SendMessage(m_hwndChild, WM_SETREDRAW, FALSE, 0);

    if (NameChange)
    {
        ListView_DeleteAllItems(m_hwndChild);
    }

    LvItem.mask = LVIF_TEXT;

    for (i = 0; i < m_NumRegisters; i++)
    {
        if (RegNames == NULL)
        {
            Name = _T("Unknown");
        }
        else
        {
            ULONG NameIdx = NameBuf->MapUserToEngine(i);

            if ((NameBuf->m_Flags & REGCUST_NO_SUBREG) &&
                (RegTypes[NameIdx * 2 + 1] & DEBUG_REGISTER_SUB_REGISTER))
            {
                continue;
            }
            
            Name = RegNames;
            while (NameIdx-- > 0)
            {
                Name += strlen(Name) + 1;
            }
        }

        LvItem.pszText = Name;
        LvItem.iItem = EntryIdx;
        if (NameChange)
        {
            ListView_InsertItem(m_hwndChild, &LvItem);
            SetItemFlags(EntryIdx, RegToFlags(0xffff));
        }
        else
        {
            ListView_SetItemText(m_hwndChild, EntryIdx, 0, Name);
        }

        EntryIdx++;
    }

    if (NameBuf && RegNames)
    {
        UnlockStateBuffer(NameBuf);
    }

    SendMessage(m_hwndChild, WM_SETREDRAW, TRUE, 0);
    m_NamesProcType = ProcType;
}