CConsoleWnd.cpp

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Management Console
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     Single 'console' window
 * COPYRIGHT:   Copyright 2006-2007 Thomas Weidenmueller
 *              Copyright 2017 Mark Jansen (mark.jansen@reactos.org)
 *              Copyright 2026 Eric Kohl (eric.kohl@reactos.org)
 */
 
#include "precomp.h"
 
#define DEFAULT_COLUMN0_WIDTH 200
 
CConsoleWnd::CConsoleWnd(CMainWnd *MainWnd, CSnapin *RootNode, CSnapin *SelectedNode)
{
    m_MainWnd = MainWnd;
    m_ViewRootNode = RootNode;
    m_ViewSelectedNode = SelectedNode ? SelectedNode : RootNode;
    m_ListViewMode = ListView_Detail;
    m_ViewId = 0;
 
    m_iTreeViewWidth = 0;
    m_iActionsPaneWidth = 0;
    m_bStatusBarVisible = TRUE;
    m_bDescriptionBarVisible = FALSE;
    m_bTreeViewVisible = TRUE;
    m_bActionsPaneVisible = FALSE;
 
    m_pfnSuperWindowProc = DefMDIChildProc;
 
    m_hMenuTreeView = LoadMenu(_AtlBaseModule.GetModuleInstance(), MAKEINTRESOURCE(IDM_TREEVIEW_CONTEXT));
 
    if (!m_thunk.Init(NULL, NULL))
        return;
    _AtlWinModule.AddCreateWndData(&m_thunk.cd, this);
}
 
CConsoleWnd::~CConsoleWnd()
{
    DestroyMenu(m_hMenuTreeView);
}
 
LRESULT
CConsoleWnd::OnCreate(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    SetWindowLongPtr(0, (LONG_PTR)this);
 
    m_iSplitterWidth = 4;
    m_iSplitSide = SPLITTER_NONE;
 
    RECT Rect;
    GetClientRect(&Rect);
    if (m_iTreeViewWidth == 0)
        m_iTreeViewWidth = (Rect.right - Rect.left) / 4;
    if (m_iActionsPaneWidth == 0)
        m_iActionsPaneWidth = (Rect.right - Rect.left) / 4;
 
    m_StatusBar.Create(this->m_hWnd, NULL);
    m_StatusBar.GetClientRect(&Rect);
    m_iStatusBarHeight = Rect.bottom - Rect.top;
 
    Rect.right = 0;
    Rect.left = 0;
    Rect.top = 0;
    Rect.bottom = 0;
    m_DescriptionBar.Create(L"Static", this->m_hWnd, &Rect, L"Description",
                            WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SS_OWNERDRAW,
                            WS_EX_STATICEDGE);
    m_DescriptionBar.SetWindowText(L"Test");
 
    m_TreeView.Create(this->m_hWnd,
                        WS_CHILD | WS_VISIBLE | TVS_HASLINES | TVS_SHOWSELALWAYS | TVS_EDITLABELS);
 
    m_TreeView.SetImageList(m_MainWnd->SnapinImageList(), TVSIL_NORMAL);
 
    m_ListView.Create(this->m_hWnd, &Rect, NULL, WS_CHILD | WS_VISIBLE | ViewModeToStyle(m_ListViewMode), WS_EX_CLIENTEDGE);
 
    CAtlString Column0Name(MAKEINTRESOURCE(IDS_COLUMN0)); /* FIXME */
    m_ListView.InsertColumn(0, Column0Name.GetString(), LVCFMT_LEFT, DEFAULT_COLUMN0_WIDTH);
 
    Rect.right = 0;
    Rect.left = 0;
    Rect.top = 0;
    Rect.bottom = 0;
    m_ActionsPane.Create(this->m_hWnd, &Rect, L"Actions", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, WS_EX_CLIENTEDGE);
 
    m_MainWnd->RegisterView(this);
 
    UpdateTreeView();
 
    LPMDICREATESTRUCT mdicreate = reinterpret_cast<LPMDICREATESTRUCT>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams);
    if (mdicreate->lParam)
        PostMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
 
    m_MainWnd->UpdateViewMenu(m_ListViewMode);
 
    return 0;
}
 
LRESULT
CConsoleWnd::OnDestroy(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    m_MainWnd->UnregisterView(this);
    m_MainWnd->PostMessage(WM_USER_CLOSE_CHILD, 0, 0);
    return 0;
}
 
LRESULT
CConsoleWnd::OnSize(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    UpdateLayout();
    return DefMDIChildProc(this->m_hWnd, WM_SIZE, wParam, lParam);
}
 
LRESULT
CConsoleWnd::OnLButtonDown(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    RECT rect;
    int xPos = (INT)(WORD)LOWORD(lParam);
 
    GetClientRect(&rect);
    int iClientWidth = rect.right - rect.left;
 
    if ((m_bTreeViewVisible) && (xPos >= m_iTreeViewWidth) && (xPos <= m_iTreeViewWidth + m_iSplitterWidth))
    {
        m_iSplitOffset = xPos - m_iTreeViewWidth;
        m_iSplitSide = SPLITTER_LEFT;
    }
    else if ((m_bActionsPaneVisible) && (xPos >= (iClientWidth - m_iActionsPaneWidth - m_iSplitterWidth)) && (xPos <= (iClientWidth - m_iActionsPaneWidth)))
    {
        m_iSplitOffset = xPos - (iClientWidth - m_iActionsPaneWidth - m_iSplitterWidth);
        m_iSplitSide = SPLITTER_RIGHT;
    }
    else
    {
        m_iSplitSide = SPLITTER_NONE;
    }
    SetCapture();
    return 0;
}
 
LRESULT
CConsoleWnd::OnLButtonUp(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    m_iSplitSide = SPLITTER_NONE;
    ReleaseCapture();
    return 0;
}
 
LRESULT
CConsoleWnd::OnMouseMove(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    if ((GetCapture() == m_hWnd) && (m_iSplitSide != SPLITTER_NONE))
    {
        RECT rect;
 
        GetClientRect(&rect);
        int iClientWidth = rect.right - rect.left;
 
        if (m_iSplitSide == SPLITTER_LEFT)
        {
            m_iTreeViewWidth = (INT)(WORD)LOWORD(lParam) - m_iSplitOffset;
 
            m_TreeView.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            m_TreeView.MoveWindow(rect.left, rect.top, rect.left + m_iTreeViewWidth, rect.bottom - rect.top);
 
            m_ListView.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            int xWidth = iClientWidth - (m_iTreeViewWidth + m_iSplitterWidth);
            if (m_bActionsPaneVisible)
                xWidth -= (m_iActionsPaneWidth + m_iSplitterWidth);
 
            m_ListView.MoveWindow(m_iTreeViewWidth + m_iSplitterWidth, rect.top, xWidth, rect.bottom - rect.top);
 
            m_DescriptionBar.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            m_DescriptionBar.MoveWindow(m_iTreeViewWidth + m_iSplitterWidth, rect.top, xWidth, rect.bottom - rect.top);
        }
        else if (m_iSplitSide == SPLITTER_RIGHT)
        {
            int xPos = (INT)(WORD)LOWORD(lParam) - m_iSplitOffset;
            m_iActionsPaneWidth = iClientWidth - (xPos + m_iSplitterWidth);
 
            m_ListView.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            int xWidth = iClientWidth - (m_iActionsPaneWidth + m_iSplitterWidth);
            if (m_bTreeViewVisible)
                xWidth -= rect.left;
 
            m_ListView.MoveWindow(rect.left, rect.top, xWidth, rect.bottom - rect.top);
 
            m_DescriptionBar.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            m_DescriptionBar.MoveWindow(rect.left, rect.top, xWidth, rect.bottom - rect.top);
 
            m_ActionsPane.GetWindowRect(&rect);
            ::MapWindowPoints(HWND_DESKTOP, m_hWnd, (LPPOINT)&rect, sizeof(RECT) / sizeof(POINT));
 
            rect.left = iClientWidth - m_iActionsPaneWidth;
            m_ActionsPane.MoveWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
        }
    }
 
    return 0;
}
 
LRESULT
CConsoleWnd::OnContextMenu(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    POINT pt;
 
    if ((HWND)wParam == m_TreeView.m_hWnd)
    {
        TVHITTESTINFO hti;
        int nPos = 0;
 
        pt.x = (short) LOWORD(lParam);
        pt.y = (short) HIWORD(lParam);
 
        if (pt.x == -1 && pt.y == -1)
        {
            RECT rc;
            hti.hItem = m_TreeView.GetSelection();
            if (hti.hItem != NULL)
            {
                TreeView_GetItemRect(m_TreeView.m_hWnd, hti.hItem, &rc, TRUE);
                pt.x = rc.left + 8;
                pt.y = rc.top + 8;
                m_TreeView.ClientToScreen(&pt);
                hti.flags = TVHT_ONITEM;
            }
            else
            {
                hti.flags = 0;
            }
        }
        else
        {
            hti.pt.x = pt.x;
            hti.pt.y = pt.y;
            m_TreeView.ScreenToClient(&hti.pt);
            m_TreeView.HitTest(&hti);
 
            if (hti.hItem)
            {
                if (hti.hItem == m_TreeView.GetSelection())
                {
                    nPos = 1;
                }
            }
        }
 
        if (hti.flags & TVHT_ONITEM)
        {
            HMENU hContextMenu = GetSubMenu(m_hMenuTreeView, nPos);
            if (nPos == 1)
            {
                CheckMenuRadioItem(hContextMenu,
                                   IDM_VIEW_LARGE_ICONS,
                                   IDM_VIEW_DETAILS,
                                   ViewModeToCmdId(m_ListViewMode),
                                   MF_BYCOMMAND);
            }
            TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, this->m_hWnd, NULL);
        }
    }
    return 0;
}
 
LRESULT
CConsoleWnd::OnDrawItem(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    LPDRAWITEMSTRUCT lpDrawItem = (LPDRAWITEMSTRUCT)lParam;
    WCHAR WindowText[256];
 
    HBRUSH hBrush = GetSysColorBrush(COLOR_3DDKSHADOW);
    FillRect(lpDrawItem->hDC, &lpDrawItem->rcItem, hBrush);
 
    ::SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_3DHILIGHT));
 
    ::GetWindowTextW(lpDrawItem->hwndItem, WindowText, ARRAYSIZE(WindowText));
    ::SetBkMode(lpDrawItem->hDC, TRANSPARENT);
 
    lpDrawItem->rcItem.left += 4;
    DrawTextW(lpDrawItem->hDC, (LPCWSTR)WindowText, -1, &lpDrawItem->rcItem,
                DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_MODIFYSTRING | DT_END_ELLIPSIS | DT_NOPREFIX);
 
    return TRUE;
}
 
LRESULT
CConsoleWnd::OnNotify(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
 
    NMHDR *phdr = (NMHDR *)lParam;
    switch (phdr->code)
    {
        case TVN_BEGINLABELEDIT:
            return FALSE;
 
        case TVN_ENDLABELEDIT:
            {
                TV_DISPINFO *pNM = (TV_DISPINFO *)lParam;
                LPWSTR pszText = pNM->item.pszText;
                CSnapin *Snapin = (CSnapin *)pNM->item.lParam;
                Snapin->SetDisplayName(pszText);
                TreeView_SetItem(pNM->hdr.hwndFrom, &pNM->item);
                m_DescriptionBar.SetWindowText(Snapin->DisplayName());
            }
            return FALSE;
 
        case TVN_SELCHANGED:
            {
                LPNMTREEVIEW pNmTreeview = (LPNMTREEVIEW)lParam;
                CSnapin *OldSnapin = (CSnapin *)pNmTreeview->itemOld.lParam;
                CSnapin *NewSnapin = (CSnapin *)pNmTreeview->itemNew.lParam;
 
                m_DescriptionBar.SetWindowText(NewSnapin->DisplayName());
                m_MainWnd->UpdateAboutSnapinMenu((NewSnapin == m_MainWnd->GetRootSnapin()) ? NULL : NewSnapin);
                if ((OldSnapin == m_MainWnd->GetRootSnapin()) != (NewSnapin == m_MainWnd->GetRootSnapin()))
                    m_MainWnd->UpdateUpToolButton((NewSnapin == m_MainWnd->GetRootSnapin()) ? FALSE : TRUE);
            }
            return FALSE;
    }
 
    return 0;
}
 
LRESULT
CConsoleWnd::OnActivate(UINT nMessage, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    m_MainWnd->UpdateToolbuttons(m_bTreeViewVisible, m_bActionsPaneVisible);
    m_MainWnd->UpdateViewMenu(m_ListViewMode);
    return 0;
}
 
LRESULT
CConsoleWnd::OnActionNewWindow(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
    HTREEITEM hTreeItem = m_TreeView.GetSelection();
    if (!hTreeItem)
        return 0;
 
    CSnapin *Snapin = (CSnapin *)m_TreeView.GetItemData(hTreeItem);
    if (!Snapin)
        return 0;
 
    MDICREATESTRUCT mcs;
    HWND hChild;
 
    mcs.szTitle = Snapin->DisplayName();
    mcs.szClass = CConsoleWnd::GetWndClassName();
    mcs.hOwner = _AtlBaseModule.GetModuleInstance();
    mcs.x = mcs.cx = CW_USEDEFAULT;
    mcs.y = mcs.cy = CW_USEDEFAULT;
    mcs.style = MDIS_ALLCHILDSTYLES;
 
    CConsoleWnd* child = new CConsoleWnd(m_MainWnd, Snapin);
    BOOL bMaximized = FALSE;
    HWND hWndOld = (HWND)m_MainWnd->m_MDIClient.SendMessage(WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
    mcs.lParam = bMaximized || !hWndOld;
    hChild = (HWND)m_MainWnd->m_MDIClient.SendMessage(WM_MDICREATE, 0, (LONG_PTR)&mcs);
    if (!hChild)
    {
        delete child;
        return 0;
    }
 
    m_MainWnd->UpdateLayout();
    m_MainWnd->UpdateTitle();
    m_MainWnd->UpdateMenu();
    m_MainWnd->UpdateViewMenu(child->GetListViewMode());
 
    return 0;
}
 
LRESULT
CConsoleWnd::OnActionRename(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
    m_TreeView.EditLabel(m_TreeView.GetSelection());
    return 0;
}
 
LRESULT
CConsoleWnd::OnViewMode(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
    return m_MainWnd->OnViewMode(wNotifyCode, wID, hWndCtl, bHandled);
}
 
LRESULT
CConsoleWnd::OnViewCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
    return m_MainWnd->OnViewCustomize(wNotifyCode, wID, hWndCtl, bHandled);
}
 
VOID
CConsoleWnd::AddTreeViewItemRecursive(HTREEITEM hParentTreeItem, CSnapin *Node)
{
    HTREEITEM hTreeItem;
 
    hTreeItem = m_TreeView.AddItem(hParentTreeItem,
                                    (LPWSTR)Node->DisplayName().GetString(),
                                    Node->CacheEntry()->NormalImageIndex(),
                                    Node->CacheEntry()->OpenImageIndex(),
                                    (LPARAM)Node);
    if (hTreeItem)
    {
        POSITION pos = Node->m_SubNodes.GetHeadPosition();
        while (pos)
        {
            CSnapin *ChildNode = (CSnapin*)Node->m_SubNodes.GetNext(pos);
            if (ChildNode)
                AddTreeViewItemRecursive(hTreeItem, ChildNode);
        }
 
        m_TreeView.Expand(hTreeItem, TVE_EXPAND);
 
        if (Node == m_ViewSelectedNode)
            m_TreeView.SelectItem(hTreeItem);
    }
}
 
VOID
CConsoleWnd::UpdateTreeView()
{
    m_TreeView.DeleteItem(TVI_ROOT);
    AddTreeViewItemRecursive(TVI_ROOT, m_ViewRootNode);
}
 
BOOL
CConsoleWnd::IsTreeViewVisible()
{
    return m_bTreeViewVisible;
}
 
VOID
CConsoleWnd::SetTreeViewVisible(BOOL bVisible)
{
    m_bTreeViewVisible = bVisible;
    UpdateLayout();
}
 
BOOL
CConsoleWnd::IsStatusBarVisible()
{
    return m_bStatusBarVisible;
}
 
VOID
CConsoleWnd::SetStatusBarVisible(BOOL bVisible)
{
    m_bStatusBarVisible = bVisible;
    UpdateLayout();
}
 
BOOL
CConsoleWnd::IsDescriptionBarVisible()
{
    return m_bDescriptionBarVisible;
}
 
VOID
CConsoleWnd::SetDescriptionBarVisible(BOOL bVisible)
{
    m_bDescriptionBarVisible = bVisible;
    UpdateLayout();
}
 
BOOL
CConsoleWnd::IsActionsPaneVisible()
{
    return m_bActionsPaneVisible;
}
 
VOID
CConsoleWnd::SetActionsPaneVisible(BOOL bVisible)
{
    m_bActionsPaneVisible = bVisible;
    UpdateLayout();
}
 
VOID
CConsoleWnd::UpdateLayout()
{
    RECT Rect;
    int iTreeViewWidth, iTreeViewHeight;
    int iListViewPosX, iListViewPosY = 0;
    int iListViewWidth, iListViewHeight;
 
    GetClientRect(&Rect);
    int iClientHeight = Rect.bottom - Rect.top;
    int iClientWidth = Rect.right - Rect.left;
 
    int iStatusHeight = 0;
 
    int iDescriptionBarHeight = 0;
 
    if (m_bTreeViewVisible)
    {
        iTreeViewWidth = m_iTreeViewWidth;
        iListViewPosX = m_iTreeViewWidth + m_iSplitterWidth;
        iListViewWidth = iClientWidth - m_iTreeViewWidth - m_iSplitterWidth;
    }
    else
    {
        iTreeViewWidth = 0;
        iListViewPosX = 0;
        iListViewWidth = iClientWidth;
    }
 
    iTreeViewHeight = iClientHeight;
    iListViewHeight = iClientHeight;
 
    if (m_bStatusBarVisible)
    {
        iStatusHeight = m_iStatusBarHeight;
        iTreeViewHeight -= iStatusHeight;
        iListViewHeight -= iStatusHeight;
    }
 
    if (m_bDescriptionBarVisible)
    {
        iDescriptionBarHeight = 24;
        iListViewPosY += iDescriptionBarHeight;
        iListViewHeight -= iDescriptionBarHeight;
    }
 
    if (m_bActionsPaneVisible)
    {
        iListViewWidth -= (m_iActionsPaneWidth + m_iSplitterWidth);
    }
 
    /* Move the status bar */
    m_StatusBar.MoveWindow(0, iClientHeight - iStatusHeight, iClientWidth, iStatusHeight);
 
    /* Move the tree view */
    m_TreeView.MoveWindow(0, 0, iTreeViewWidth, iTreeViewHeight);
 
    /* Move the list view */
    m_ListView.MoveWindow(iListViewPosX, iListViewPosY, iListViewWidth, iListViewHeight);
 
    m_DescriptionBar.MoveWindow(iListViewPosX, 0, iListViewWidth, iDescriptionBarHeight);
 
    m_ActionsPane.MoveWindow(iClientWidth - m_iActionsPaneWidth, 0, m_iActionsPaneWidth, iClientHeight);
}
 
VOID
CConsoleWnd::UpdateView()
{
    UpdateTreeView();
}
 
VOID
CConsoleWnd::SetStatusBarText(LPWSTR pszStatusText)
{
     m_StatusBar.SetText(pszStatusText);
}
 
VOID
CConsoleWnd::SelectParent()
{
    HTREEITEM hItem = m_TreeView.GetSelection();
    if (hItem == NULL)
        return;
 
    if (hItem == m_TreeView.GetNextItem(hItem, TVGN_ROOT))
        return;
 
    HTREEITEM hParent = m_TreeView.GetNextItem(hItem, TVGN_PARENT);
    if (hParent)
        m_TreeView.SelectItem(hParent);
}
 
LISTVIEW_MODE
CConsoleWnd::GetListViewMode()
{
    return m_ListViewMode;
}
 
VOID
CConsoleWnd::SetListViewMode(LISTVIEW_MODE ListViewMode)
{
    m_ListViewMode = ListViewMode;
    ::SetWindowLong(m_ListView.m_hWnd, GWL_STYLE, (::GetWindowLong(m_ListView.m_hWnd, GWL_STYLE) & ~LVS_TYPEMASK) | ViewModeToStyle(m_ListViewMode));
}
 
VOID
CConsoleWnd::SaveView(MscFile *mscFile, IXMLDOMElement *pParentElement)
{
    IXMLDOMElement *pViewElement = NULL;
    IXMLDOMElement *pViewOptionsElement = NULL;
    IXMLDOMElement *pBookMarkElement = NULL;
    WCHAR szBuffer[32];
    HRESULT hr = S_OK;
 
    /* <View ID="1" ScopePaneWidth="292" ActionsPaneWidth="-1"> */
    CHK_HR(mscFile->CreateAndAddElementNode(L"View", pParentElement, &pViewElement));
    _swprintf(szBuffer, L"%u", m_ViewId);
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ID", szBuffer, pViewElement));
    _swprintf(szBuffer, L"%d", m_iTreeViewWidth);
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ScopePaneWidth", szBuffer, pViewElement));
    _swprintf(szBuffer, L"%d", m_iActionsPaneWidth);
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ActionsPaneWidth", szBuffer, pViewElement));
 
    /* Root Snap-in  <BookMark Name="RootNode" NodeID="1"/> */
    CHK_HR(mscFile->CreateAndAddElementNode(L"BookMark", pViewElement, &pBookMarkElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"Name", L"RootNode", pBookMarkElement));
    _swprintf(szBuffer, L"%u", m_ViewRootNode->GetNodeId());
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"NodeID", szBuffer, pBookMarkElement));
    SAFE_RELEASE(pBookMarkElement);
 
    /* Selected Snap-in <BookMark Name="SelectedNode" NodeID="1"/> */
    CHK_HR(mscFile->CreateAndAddElementNode(L"BookMark", pViewElement, &pBookMarkElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"Name", L"SelectedNode", pBookMarkElement));
    _swprintf(szBuffer, L"%u", m_ViewSelectedNode->GetNodeId());
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"NodeID", szBuffer, pBookMarkElement));
    SAFE_RELEASE(pBookMarkElement);
 
    mscFile->SaveWindowPlacement(this, pViewElement);
 
    /* <ViewOptions ViewMode="Report" ScopePaneVisible="true" ActionsPaneVisible="true" DescriptionBarVisible="false" DefaultColumn0Width="200" DefaultColumn1Width="0"/> */
    CHK_HR(mscFile->CreateAndAddElementNode(L"ViewOptions", pViewElement, &pViewOptionsElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ViewMode", ViewModeToString(m_ListViewMode), pViewOptionsElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ScopePaneVisible", IsTreeViewVisible() ? L"true" : L"false", pViewOptionsElement));
    if (!IsStatusBarVisible())
        CHK_HR(mscFile->CreateAndAddAttributeNode(L"NoStatusBar", L"true", pViewOptionsElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"ActionsPaneVisible", IsActionsPaneVisible() ? L"true" : L"false", pViewOptionsElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"DescriptionBarVisible", IsDescriptionBarVisible() ? L"true" : L"false", pViewOptionsElement));
    _swprintf(szBuffer, L"%d", m_ListView.GetColumnWidth(0));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"DefaultColumn0Width", szBuffer, pViewOptionsElement));
    CHK_HR(mscFile->CreateAndAddAttributeNode(L"DefaultColumn1Width", L"0", pViewOptionsElement)); /* FIXME */
    SAFE_RELEASE(pViewOptionsElement); /* </ViewOptions> */
 
CleanUp:
    SAFE_RELEASE(pViewElement); /* </View> */
}
 
HRESULT
CConsoleWnd::ParseViewAttributes(
    MscFile *mscFile,
    IXMLDOMElement *pViewElement,
    UINT *puViewID,
    INT *piScopePanelWidth,
    INT *piActionsPanelWidth)
{
    VARIANT ViewID, ScopePanel, ActionsPanel;
    PWSTR ptr = NULL;
    HRESULT hr = S_OK;
 
    VariantInit(&ViewID);
    VariantInit(&ScopePanel);
    VariantInit(&ActionsPanel);
 
    /* Attribut ID */
    hr = mscFile->GetAttribute(pViewElement, (LPWSTR)L"ID", &ViewID);
    if (hr == S_OK)
    {
        *puViewID = wcstoul(V_BSTR(&ViewID), &ptr, 10);
    }
 
    /* Attribute ScopePaneWidth */
    hr = mscFile->GetAttribute(pViewElement, (LPWSTR)L"ScopePaneWidth", &ScopePanel);
    if (hr == S_OK)
    {
        *piScopePanelWidth = wcstol(V_BSTR(&ScopePanel), &ptr, 10);
    }
 
    /* Attribute ActionsPaneWidth */
    hr = mscFile->GetAttribute(pViewElement, (LPWSTR)L"ActionsPaneWidth", &ActionsPanel);
    if (hr == S_OK)
    {
        *piActionsPanelWidth = wcstol(V_BSTR(&ActionsPanel), &ptr, 10);
    }
 
    VariantClear(&ViewID);
    VariantClear(&ScopePanel);
    VariantClear(&ActionsPanel);
 
    return hr;
}
 
HRESULT
CConsoleWnd::ParseView(
    CMainWnd *pMainWnd,
    MscFile *mscFile,
    IXMLDOMElement *pViewElement)
{
    IXMLDOMNodeList *pChildList = NULL;
    IXMLDOMNode *nextItem;
    DOMNodeType NodeType;
    BSTR NodeName = NULL;
    CSnapin *pRootSnapin = NULL, *pSelectedSnapin = NULL;
 
    MDICREATESTRUCT mcs;
    HWND hChild;
    HWND hWndOld;
    BOOL bMaximized;
    CConsoleWnd *pConsoleWnd = NULL;
 
    UINT uViewId = 0;
    INT iScopePanelWidth = 0;
    INT iActionsPanelWidth = 0;
    LISTVIEW_MODE ListViewMode = ListView_Detail;
    BOOL bScopePaneVisible = FALSE;
    BOOL bActionsPaneVisible = FALSE;
    BOOL bDescriptionBarVisible = FALSE;
    INT iColumn0Width = DEFAULT_COLUMN0_WIDTH;
    HRESULT hr = S_OK;
 
    ParseViewAttributes(mscFile, pViewElement, &uViewId, &iScopePanelWidth, &iActionsPanelWidth);
 
    hr = pViewElement->get_childNodes(&pChildList);
    if (FAILED(hr))
        goto done;
 
    for (;;)
    {
        hr = pChildList->nextNode(&nextItem);
        if (hr == S_FALSE)
        {
            hr = S_OK;
            break;
        }
 
        hr = nextItem->get_nodeType(&NodeType);
        if (hr == S_OK)
        {
            NodeName = NULL;
            hr = nextItem->get_baseName(&NodeName);
            if (hr == S_OK)
            {
                if (NodeType == NODE_ELEMENT)
                {
                    if (_wcsicmp(NodeName, L"BookMark") == 0)
                    {
                        VARIANT Name, NodeID;
 
                        VariantInit(&Name);
                        VariantInit(&NodeID);
 
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"Name", &Name);
                        if (hr == S_OK)
                        {
                            hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"NodeID", &NodeID);
                            if (hr == S_OK)
                            {
                                PWSTR ptr = NULL;
                                UINT uNodeId = wcstoul(V_BSTR(&NodeID), &ptr, 10);
                                if (uNodeId != 0)
                                {
                                    CSnapin *pSnapin = pMainWnd->m_TempNodeMap->Lookup(uNodeId);
                                    if (pSnapin)
                                    {
                                        if (_wcsicmp(V_BSTR(&Name), L"RootNode") == 0)
                                            pRootSnapin = pSnapin;
                                        else if (_wcsicmp(V_BSTR(&Name), L"SelectedNode") == 0)
                                            pRootSnapin = pSnapin;
                                    }
                                }
                            }
                        }
 
                        VariantClear(&Name);
                        VariantClear(&NodeID);
                    }
                    else if (_wcsicmp(NodeName, L"ViewOptions") == 0)
                    {
                        VARIANT ViewMode, ScopePane, ActionsPane;
                        VARIANT DescriptionBar, Column0Width;
 
                        VariantInit(&ViewMode);
                        VariantInit(&ScopePane);
                        VariantInit(&ActionsPane);
                        VariantInit(&DescriptionBar);
                        VariantInit(&Column0Width);
 
                        /* Attribut ViewMode="Report" */
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"ViewMode", &ViewMode);
                        if (hr == S_OK)
                        {
                            ListViewMode = StringToViewMode(V_BSTR(&ViewMode));
                        }
 
                        /* Attribut ScopePaneVisible="true" */
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"ScopePaneVisible", &ScopePane);
                        if (hr == S_OK)
                        {
                            bScopePaneVisible = StringToBool(V_BSTR(&ScopePane));
                        }
 
                        /* Attribut ActionsPaneVisible="true" */
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"ActionsPaneVisible", &ActionsPane);
                        if (hr == S_OK)
                        {
                            bActionsPaneVisible = StringToBool(V_BSTR(&ActionsPane));
                        }
 
                        /* Attribut DescriptionBarVisible="false" */
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"DescriptionBarVisible", &DescriptionBar);
                        if (hr == S_OK)
                        {
                            bDescriptionBarVisible = StringToBool(V_BSTR(&DescriptionBar));
                        }
 
                        /* Attribut DefaultColumn0Width="200" */
                        hr = mscFile->GetAttribute((IXMLDOMElement *)nextItem, (LPWSTR)L"DefaultColumn0Width", &Column0Width);
                        if (hr == S_OK)
                        {
                            iColumn0Width = _wtoi(V_BSTR(&Column0Width));
                        }
 
                        /* FIXME: Attribut DefaultColumn1Width="0" */
 
                        VariantClear(&ViewMode);
                        VariantClear(&ScopePane);
                        VariantClear(&ActionsPane);
                        VariantClear(&DescriptionBar);
                        VariantClear(&Column0Width);
                    }
                }
 
                SysFreeString(NodeName);
                NodeName = NULL;
            }
        }
 
        nextItem->Release();
    }
 
    if (FAILED(hr))
        goto done;
 
    /* Create the view */
 
    mcs.szTitle = pRootSnapin->DisplayName();
    mcs.szClass = CConsoleWnd::GetWndClassName();
    mcs.hOwner = _AtlBaseModule.GetModuleInstance();
    mcs.x = mcs.cx = CW_USEDEFAULT;
    mcs.y = mcs.cy = CW_USEDEFAULT;
    mcs.style = MDIS_ALLCHILDSTYLES;
 
    pConsoleWnd = new CConsoleWnd(pMainWnd, pRootSnapin, pSelectedSnapin);
 
    pConsoleWnd->m_ViewId = uViewId;
    pConsoleWnd->m_iTreeViewWidth = iScopePanelWidth;
    pConsoleWnd->m_iActionsPaneWidth = iActionsPanelWidth;
 
    bMaximized = FALSE;
    hWndOld = (HWND)pMainWnd->m_MDIClient.SendMessage(WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
    mcs.lParam = bMaximized || !hWndOld;
    hChild = (HWND)pMainWnd->m_MDIClient.SendMessage(WM_MDICREATE, 0, (LONG_PTR)&mcs);
    if (!hChild)
    {
        delete pConsoleWnd;
        hr = E_FAIL;
        goto done;
    }
 
    pConsoleWnd->SetListViewMode(ListViewMode);
    pConsoleWnd->SetTreeViewVisible(bScopePaneVisible);
    pConsoleWnd->SetActionsPaneVisible(bActionsPaneVisible);
    pConsoleWnd->SetDescriptionBarVisible(bDescriptionBarVisible);
 
    pConsoleWnd->m_ListView.SetColumnWidth(0, iColumn0Width);
 
    pMainWnd->UpdateLayout();
    pMainWnd->UpdateTitle();
    pMainWnd->UpdateMenu();
    pMainWnd->UpdateViewMenu(ListViewMode);
 
done:
    if (pChildList)
        pChildList->Release();
 
    if (NodeName)
        SysFreeString(NodeName);
 
    return hr;
}
 
// +IConsole
STDMETHODIMP
CConsoleWnd::QueryInterface(REFIID riid, void **ppvObject)
{
    if (riid == IID_IUnknown || riid == IID_IConsole)
    {
        *ppvObject = static_cast<IConsole*>(this);
        AddRef();
        return S_OK;
    }
    else if (riid == IID_IConsole2)
    {
        *ppvObject = static_cast<IConsole2*>(this);
        AddRef();
        return S_OK;
    }
    else if (riid == IID_IConsoleNameSpace)
    {
        *ppvObject = static_cast<IConsoleNameSpace*>(this);
        AddRef();
        return S_OK;
    }
    else if (riid == IID_IConsoleNameSpace2)
    {
        *ppvObject = static_cast<IConsoleNameSpace2*>(this);
        AddRef();
        return S_OK;
    }
    else
    {
        CComHeapPtr<OLECHAR> guidstr;
        HRESULT hr = StringFromCLSID(riid, &guidstr);
        if (SUCCEEDED(hr))
            DPRINT1("Unhandled riid: %S\n", (PCWSTR)guidstr);
        else
            DPRINT1("Unhandled riid\n");
    }
 
 
    *ppvObject = NULL;
    return E_NOINTERFACE;
}
 
STDMETHODIMP_(ULONG)
CConsoleWnd::AddRef()
{
    DPRINT("%s()\n", __FUNCTION__);
    return 2;
}
 
STDMETHODIMP_(ULONG)
CConsoleWnd::Release()
{
    DPRINT("%s()\n", __FUNCTION__);
    return 1;
}
 
 
STDMETHODIMP
CConsoleWnd::SetHeader(LPHEADERCTRL pHeader)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::SetToolbar(LPTOOLBAR pToolbar)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::QueryResultView(LPUNKNOWN *pUnknown)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::QueryScopeImageList(LPIMAGELIST *ppImageList)
{
    DPRINT("%s(%p)\n", __FUNCTION__);
    if (!ppImageList)
        return E_INVALIDARG;
 
    __debugbreak();
    //*ppImageList = m_ScopeImageList;
    return S_OK;
}
 
STDMETHODIMP
CConsoleWnd::QueryResultImageList(LPIMAGELIST *ppImageList)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::UpdateAllViews(LPDATAOBJECT lpDataObject, LPARAM data, LONG_PTR hint)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::MessageBox(LPCWSTR lpszText, LPCWSTR lpszTitle, UINT fuStyle, int *piRetval)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::QueryConsoleVerb(LPCONSOLEVERB *ppConsoleVerb)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::SelectScopeItem(HSCOPEITEM hScopeItem)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::GetMainWindow(HWND *phwnd)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::NewWindow(HSCOPEITEM hScopeItem, ULONG lOptions)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
// -IConsole
 
// +IConsole2
STDMETHODIMP
CConsoleWnd::Expand(HSCOPEITEM hItem, BOOL bExpand)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::IsTaskpadViewPreferred()
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
 
STDMETHODIMP
CConsoleWnd::SetStatusText(LPOLESTR pszStatusText)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
// -IConsole2
 
// +IConsoleNameSpace
STDMETHODIMP
CConsoleWnd::InsertItem(LPSCOPEDATAITEM item)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::DeleteItem(HSCOPEITEM hItem, LONG fDeleteThis)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::SetItem(LPSCOPEDATAITEM item)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::GetItem(LPSCOPEDATAITEM item)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::GetChildItem(HSCOPEITEM item, HSCOPEITEM *pItemChild, LONG *plCookie)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::GetNextItem(HSCOPEITEM item, HSCOPEITEM *pItemNext, LONG *plCookie)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::GetParentItem(HSCOPEITEM item, HSCOPEITEM *pItemParent, LONG *plCookie)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
// -IConsoleNameSpace
 
 
 
// +IConsoleNameSpace2
STDMETHODIMP
CConsoleWnd::Expand(HSCOPEITEM hItem)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
 
STDMETHODIMP
CConsoleWnd::AddExtension(HSCOPEITEM hItem, LPCLSID lpClsid)
{
    DPRINT("%s()\n", __FUNCTION__);
    __debugbreak();
    return E_NOTIMPL;
}
// -IConsoleNameSpace2