windows-xp/Source/XPSP1/NT/admin/netui/llsmgr/llsview.cpp

/*++

Copyright (c) 1994-95  Microsoft Corporation

Module Name:

    llsview.cpp

Abstract:

    View window implementation.

Author:

    Don Ryan (donryan) 12-Feb-1995

Environment:

    User Mode - Win32

Revision History:

    Jeff Parham (jeffparh) 16-Jan-1996
        o  Ported to CCF API to add/remove licenses.
        o  Added new element to LV_COLUMN_ENTRY to differentiate the string
           used for the column header from the string used in the menus
           (so that the menu option can contain hot keys).
        o  Added better error message in case where a server being expanded
           in the server browser is not configured for the License Service.

--*/

#include "stdafx.h"
#include "llsmgr.h"
#include "llsdoc.h"
#include "llsview.h"
#include "prdpsht.h"
#include "usrpsht.h"
#include "mappsht.h"
#include "srvpsht.h"
#include "sdomdlg.h"
#include "lmoddlg.h"
#include "lgrpdlg.h"
#include "nmapdlg.h"

static const TCHAR szRegKeyLlsmgr[]             = REG_KEY_LLSMGR;
static const TCHAR szRegKeyLlsmgrMruList[]      = REG_KEY_LLSMGR_MRU_LIST;
static const TCHAR szRegKeyLlsmgrFontFaceName[] = REG_KEY_LLSMGR_FONT_FACENAME;
static const TCHAR szRegKeyLlsmgrFontHeight[]   = REG_KEY_LLSMGR_FONT_HEIGHT;
static const TCHAR szRegKeyLlsmgrFontWeight[]   = REG_KEY_LLSMGR_FONT_WEIGHT;
static const TCHAR szRegKeyLlsmgrFontItalic[]   = REG_KEY_LLSMGR_FONT_ITALIC;
static const TCHAR szRegKeyLlsmgrSaveSettings[] = REG_KEY_LLSMGR_SAVE_SETTINGS;
static const TCHAR szRegKeyLlsmgrFontCharset[] = REG_KEY_LLSMGR_FONT_CHARSET;

static LV_COLUMN_INFO g_licenseColumnInfo = {

    0, 1, LVID_PURCHASE_HISTORY_TOTAL_COLUMNS,

    {{LVID_SEPARATOR,                      0,                  0,                     0                                  },
     {LVID_PURCHASE_HISTORY_DATE,          IDS_DATE,           IDS_DATE_MENUOPT,           LVCX_PURCHASE_HISTORY_DATE         },
     {LVID_PURCHASE_HISTORY_PRODUCT,       IDS_PRODUCT,        IDS_PRODUCT_MENUOPT,        LVCX_PURCHASE_HISTORY_PRODUCT      },
     {LVID_PURCHASE_HISTORY_QUANTITY,      IDS_QUANTITY,       IDS_QUANTITY_MENUOPT,       LVCX_PURCHASE_HISTORY_QUANTITY     },
     {LVID_PURCHASE_HISTORY_ADMINISTRATOR, IDS_ADMINISTRATOR,  IDS_ADMINISTRATOR_MENUOPT,  LVCX_PURCHASE_HISTORY_ADMINISTRATOR},
     {LVID_PURCHASE_HISTORY_COMMENT,       IDS_COMMENT,        IDS_COMMENT_MENUOPT,        LVCX_PURCHASE_HISTORY_COMMENT      }},

};

static LV_COLUMN_INFO g_productColumnInfo = {

    0, 0, LVID_PRODUCTS_VIEW_TOTAL_COLUMNS,

    {{LVID_PRODUCTS_VIEW_NAME,                 IDS_PRODUCT,              IDS_PRODUCT_MENUOPT,              LVCX_PRODUCTS_VIEW_NAME                },
     {LVID_PRODUCTS_VIEW_PER_SEAT_PURCHASED,   IDS_PER_SEAT_PURCHASED,   IDS_PER_SEAT_PURCHASED_MENUOPT,   LVCX_PRODUCTS_VIEW_PER_SEAT_PURCHASED  },
     {LVID_PRODUCTS_VIEW_PER_SEAT_CONSUMED,    IDS_PER_SEAT_CONSUMED,    IDS_PER_SEAT_CONSUMED_MENUOPT,    LVCX_PRODUCTS_VIEW_PER_SEAT_CONSUMED   },
     {LVID_PRODUCTS_VIEW_PER_SERVER_PURCHASED, IDS_PER_SERVER_PURCHASED, IDS_PER_SERVER_PURCHASED_MENUOPT, LVCX_PRODUCTS_VIEW_PER_SERVER_PURCHASED},
     {LVID_PRODUCTS_VIEW_PER_SERVER_REACHED,   IDS_PER_SERVER_REACHED,   IDS_PER_SERVER_REACHED_MENUOPT,   LVCX_PRODUCTS_VIEW_PER_SERVER_REACHED  }},

};

static LV_COLUMN_INFO g_userColumnInfo = {

    0, 0, LVID_PER_SEAT_CLIENTS_TOTAL_COLUMNS,

    {{LVID_PER_SEAT_CLIENTS_NAME,             IDS_USER_NAME,        IDS_USER_NAME_MENUOPT,        LVCX_PER_SEAT_CLIENTS_NAME            },
     {LVID_PER_SEAT_CLIENTS_LICENSED_USAGE,   IDS_LICENSED_USAGE,   IDS_LICENSED_USAGE_MENUOPT,   LVCX_PER_SEAT_CLIENTS_LICENSED_USAGE  },
     {LVID_PER_SEAT_CLIENTS_UNLICENSED_USAGE, IDS_UNLICENSED_USAGE, IDS_UNLICENSED_USAGE_MENUOPT, LVCX_PER_SEAT_CLIENTS_UNLICENSED_USAGE},
     {LVID_PER_SEAT_CLIENTS_SERVER_PRODUCTS,  IDS_PRODUCTS,         IDS_PRODUCTS_MENUOPT,         LVCX_PER_SEAT_CLIENTS_SERVER_PRODUCTS }},

};

static TC_TAB_INFO g_tcTabInfo = {

    TCID_TOTAL_TABS,
    {{TCID_PURCHASE_HISTORY, IDS_PURCHASE_HISTORY, TCE_LISTVIEW|TCE_FORMAT_REPORT|TCE_SUPPORTS_SORT,   NULL, &g_licenseColumnInfo},
     {TCID_PRODUCTS_VIEW,    IDS_PRODUCTS_VIEW,    TCE_LISTVIEW|TCE_FORMAT_REPORT|TCE_SUPPORTS_ALL,    NULL, &g_productColumnInfo},
     {TCID_PER_SEAT_CLIENTS, IDS_PER_SEAT_CLIENTS, TCE_LISTVIEW|TCE_FORMAT_REPORT|TCE_SUPPORTS_ALL,    NULL, &g_userColumnInfo   },
     {TCID_SERVER_BROWSER,   IDS_SERVER_BROWSER,   TCE_TREEVIEW|TCE_SUPPORTS_EDIT,                     NULL, NULL                }},

};

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

IMPLEMENT_DYNCREATE(CLlsmgrView, CView)

BEGIN_MESSAGE_MAP(CLlsmgrView, CView)
    //{{AFX_MSG_MAP(CLlsmgrView)
    ON_WM_SIZE()
    ON_COMMAND(ID_SELECT_FONT, OnSelectFont)
    ON_COMMAND(ID_VIEW_LICENSES, OnViewLicenses)
    ON_COMMAND(ID_VIEW_MAPPINGS, OnViewMappings)
    ON_COMMAND(ID_VIEW_PRODUCTS, OnViewProducts)
    ON_COMMAND(ID_VIEW_SERVERS, OnViewServers)
    ON_COMMAND(ID_VIEW_USERS, OnViewUsers)
    ON_COMMAND(ID_VIEW_DELETE, OnDelete)
    ON_COMMAND(ID_VIEW_ICONS, OnFormatIcons)
    ON_COMMAND(MY_ID_VIEW_LIST, OnFormatList)
    ON_COMMAND(ID_VIEW_PROPERTIES, OnViewProperties)
    ON_COMMAND(ID_VIEW_REFRESH, OnViewRefresh)
    ON_COMMAND(ID_VIEW_REPORT, OnFormatReport)
    ON_COMMAND(ID_VIEW_SMALL_ICONS, OnFormatSmallIcons)
    ON_WM_CREATE()
    ON_COMMAND(ID_SORT_COLUMN0, OnSortColumn0)
    ON_COMMAND(ID_SORT_COLUMN1, OnSortColumn1)
    ON_COMMAND(ID_SORT_COLUMN2, OnSortColumn2)
    ON_COMMAND(ID_SORT_COLUMN3, OnSortColumn3)
    ON_COMMAND(ID_SORT_COLUMN4, OnSortColumn4)
    ON_COMMAND(ID_SORT_COLUMN5, OnSortColumn5)
    ON_COMMAND(ID_NEW_LICENSE, OnNewLicense)
    ON_COMMAND(ID_NEW_MAPPING, OnNewMapping)
    ON_COMMAND(ID_SELECT_DOMAIN, OnSelectDomain)
    ON_COMMAND(ID_SAVE_SETTINGS, OnSaveSettings)
    ON_UPDATE_COMMAND_UI(ID_SAVE_SETTINGS, OnUpdateSaveSettings)
    ON_UPDATE_COMMAND_UI(ID_VIEW_DELETE, OnUpdateViewDelete)
    ON_UPDATE_COMMAND_UI(ID_VIEW_PROPERTIES, OnUpdateViewProperties)
    ON_WM_ERASEBKGND()
    ON_WM_DESTROY()
    //}}AFX_MSG_MAP

    ON_NOTIFY(TCN_SELCHANGING,   IDC_VIEW_TAB_CTRL,     OnSelChangingTabCtrl)
    ON_NOTIFY(TCN_SELCHANGE,     IDC_VIEW_TAB_CTRL,     OnSelChangeTabCtrl)
    ON_NOTIFY(TCN_KEYDOWN,       IDC_VIEW_TAB_CTRL,     OnKeyDownTabCtrl)
    ON_NOTIFY(NM_SETFOCUS,       IDC_VIEW_TAB_CTRL,     OnSetFocusTabCtrl)

    ON_NOTIFY(LVN_KEYDOWN,       IDC_VIEW_LICENSE_LIST, OnKeyDownLicenseList)
    ON_NOTIFY(LVN_COLUMNCLICK,   IDC_VIEW_LICENSE_LIST, OnColumnClickLicenseList)
    ON_NOTIFY(LVN_GETDISPINFO,   IDC_VIEW_LICENSE_LIST, OnGetDispInfoLicenseList)
    ON_NOTIFY(NM_SETFOCUS,       IDC_VIEW_LICENSE_LIST, OnSetFocusLicenseList)

    ON_NOTIFY(LVN_KEYDOWN,       IDC_VIEW_PRODUCT_LIST, OnKeyDownProductList)
    ON_NOTIFY(NM_DBLCLK,         IDC_VIEW_PRODUCT_LIST, OnDblClkProductList)
    ON_NOTIFY(NM_RETURN,         IDC_VIEW_PRODUCT_LIST, OnReturnProductList)
    ON_NOTIFY(LVN_COLUMNCLICK,   IDC_VIEW_PRODUCT_LIST, OnColumnClickProductList)
    ON_NOTIFY(LVN_GETDISPINFO,   IDC_VIEW_PRODUCT_LIST, OnGetDispInfoProductList)
    ON_NOTIFY(NM_SETFOCUS,       IDC_VIEW_PRODUCT_LIST, OnSetFocusProductList)

    ON_NOTIFY(LVN_KEYDOWN,       IDC_VIEW_USER_LIST,    OnKeyDownUserList)
    ON_NOTIFY(NM_DBLCLK,         IDC_VIEW_USER_LIST,    OnDblClkUserList)
    ON_NOTIFY(NM_RETURN,         IDC_VIEW_USER_LIST,    OnReturnUserList)
    ON_NOTIFY(LVN_COLUMNCLICK,   IDC_VIEW_USER_LIST,    OnColumnClickUserList)
    ON_NOTIFY(LVN_GETDISPINFO,   IDC_VIEW_USER_LIST,    OnGetDispInfoUserList)
    ON_NOTIFY(NM_SETFOCUS,       IDC_VIEW_USER_LIST,    OnSetFocusUserList)

    ON_NOTIFY(TVN_KEYDOWN,       IDC_VIEW_SERVER_TREE,  OnKeyDownServerTree)
    ON_NOTIFY(NM_DBLCLK,         IDC_VIEW_SERVER_TREE,  OnDblClkServerTree)
    ON_NOTIFY(NM_RETURN,         IDC_VIEW_SERVER_TREE,  OnReturnServerTree)
    ON_NOTIFY(TVN_ITEMEXPANDING, IDC_VIEW_SERVER_TREE,  OnItemExpandingServerTree)
    ON_NOTIFY(TVN_GETDISPINFO,   IDC_VIEW_SERVER_TREE,  OnGetDispInfoServerTree)
    ON_NOTIFY(NM_SETFOCUS,       IDC_VIEW_SERVER_TREE,  OnSetFocusServerTree)

    ON_MESSAGE(WM_CONTEXTMENU, OnContextMenu)

    ON_COMMAND_EX_RANGE(ID_MRU_DOMAIN0, ID_MRU_DOMAIN15, OnSelMruDomain)

END_MESSAGE_MAP()


CLlsmgrView::CLlsmgrView()

/*++

Routine Description:

    Constructor for view window.

Arguments:

    None.

Return Values:

    None.

--*/

{
    m_pTabEntry = g_tcTabInfo.tcTabEntry;
    m_bOrder = FALSE;
    LoadSettings();
}


CLlsmgrView::~CLlsmgrView()

/*++

Routine Description:

    Destructor for view window.

Arguments:

    None.

Return Values:

    None.

--*/

{
    SaveSettings();
}


void CLlsmgrView::AddToMRU(LPCTSTR lpszDomainName)

/*++

Routine Description:

    Adds domain to mru list.

Arguments:

    lpszDomainName - domain of focus.

Return Values:

    None.

--*/

{
    if (lpszDomainName && *lpszDomainName)
    {
        POSITION curPos;
        POSITION nextPos;

        nextPos = m_mruDomainList.GetHeadPosition();

        while (curPos = nextPos)
        {
            CString strDomain = m_mruDomainList.GetNext(nextPos);

            if (!strDomain.CompareNoCase(lpszDomainName))
                m_mruDomainList.RemoveAt(curPos);
        }

        m_mruDomainList.AddHead(lpszDomainName);

        if (m_mruDomainList.GetCount() > MAX_MRU_ENTRIES)
            m_mruDomainList.RemoveTail();
    }
}


#ifdef _DEBUG

void CLlsmgrView::AssertValid() const

/*++

Routine Description:

    Validates object.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CView::AssertValid();
}

#endif //_DEBUG


#ifdef _DEBUG

void CLlsmgrView::Dump(CDumpContext& dc) const

/*++

Routine Description:

    Dumps contents of object.

Arguments:

    dc - dump context.

Return Values:

    None.

--*/

{
    CView::Dump(dc);
}

#endif //_DEBUG


void CLlsmgrView::EnableCurSelTab(BOOL bEnable)

/*++

Routine Description:

    Enables or disables currently selected control.

Arguments:

    bEnable - enable control if true.

Return Values:

    None.

--*/

{
    if (bEnable)
    {
        m_pTabEntry = g_tcTabInfo.tcTabEntry + m_tabCtrl.GetCurSel();

        m_pTabEntry->pWnd->EnableWindow(TRUE);
        m_pTabEntry->pWnd->ShowWindow(SW_SHOW);
        m_pTabEntry->pWnd->UpdateWindow();

        if (!IsTabUpdated(m_pTabEntry))
        {
            DWORD fUpdateHint = UPDATE_INFO_NONE;

            switch (m_pTabEntry->iItem)
            {
            case TCID_PURCHASE_HISTORY:
                fUpdateHint = UPDATE_INFO_LICENSES;
                break;

            case TCID_PRODUCTS_VIEW:
                fUpdateHint = UPDATE_INFO_PRODUCTS;
                break;

            case TCID_PER_SEAT_CLIENTS:
                fUpdateHint = UPDATE_INFO_USERS;
                break;

            case TCID_SERVER_BROWSER:
                fUpdateHint = UPDATE_INFO_SERVERS;
                break;
            }

            OnUpdate(this, fUpdateHint, NULL);
        }
    }
    else
    {
        m_pTabEntry->pWnd->EnableWindow(FALSE);
        m_pTabEntry->pWnd->ShowWindow(SW_HIDE);
    }
}


#ifdef _DEBUG

CLlsmgrDoc* CLlsmgrView::GetDocument()

/*++

Routine Description:

    Returns document object associated with view.

Arguments:

    None.

Return Values:

    Returns object pointer or NULL.

--*/

{
    VALIDATE_OBJECT(m_pDocument, CLlsmgrDoc);
    return (CLlsmgrDoc*)m_pDocument;
}

#endif //_DEBUG


void CLlsmgrView::InitLicenseList()

/*++

Routine Description:

    Initializes license list control.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CRect emptyRect;
    emptyRect.SetRectEmpty();

    m_licenseList.Create(
                    WS_CHILD|
                    WS_BORDER|
                    WS_VISIBLE|
                    WS_CLIPSIBLINGS|
                    LVS_REPORT|
                    LVS_SINGLESEL|
                    LVS_SHOWSELALWAYS|
                    LVS_SHAREIMAGELISTS|
                    LVS_AUTOARRANGE,
                    emptyRect,
                    &m_tabCtrl,
                    IDC_VIEW_LICENSE_LIST
                    );

    ::LvInitColumns(&m_licenseList, &g_licenseColumnInfo);
    g_tcTabInfo.tcTabEntry[TCID_PURCHASE_HISTORY].pWnd = &m_licenseList;
}


void CLlsmgrView::InitProductList()

/*++

Routine Description:

    Initializes product list control.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CRect emptyRect;
    emptyRect.SetRectEmpty();

    m_productList.Create(
                    WS_CHILD|
                    WS_BORDER|
                    WS_DISABLED|
                    WS_CLIPSIBLINGS|
                    LVS_REPORT|
                    LVS_SINGLESEL|
                    LVS_SHOWSELALWAYS|
                    LVS_SHAREIMAGELISTS|
                    LVS_AUTOARRANGE,
                    emptyRect,
                    &m_tabCtrl,
                    IDC_VIEW_PRODUCT_LIST
                    );

    ::LvInitColumns(&m_productList, &g_productColumnInfo);
    g_tcTabInfo.tcTabEntry[TCID_PRODUCTS_VIEW].pWnd = &m_productList;
}


void CLlsmgrView::InitServerTree()

/*++

Routine Description:

    Initializes tree ctrl.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CRect emptyRect;
    emptyRect.SetRectEmpty();

    m_serverTree.Create(
                    WS_CHILD|
                    WS_BORDER|
                    WS_DISABLED|
                    WS_CLIPSIBLINGS|
                    TVS_LINESATROOT|
                    TVS_HASBUTTONS|
                    TVS_HASLINES|
                    TVS_DISABLEDRAGDROP|
                    TVS_SHOWSELALWAYS,
                    emptyRect,
                    &m_tabCtrl,
                    IDC_VIEW_SERVER_TREE
                    );

    m_serverTree.SetImageList(&theApp.m_smallImages, TVSIL_NORMAL);
    ::SetDefaultFont(&m_serverTree);

    g_tcTabInfo.tcTabEntry[TCID_SERVER_BROWSER].pWnd = &m_serverTree;
}


void CLlsmgrView::InitTabCtrl()

/*++

Routine Description:

    Initializes tab control.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CRect emptyRect;
    emptyRect.SetRectEmpty();

    m_tabCtrl.Create(
                WS_CHILD|
                WS_VISIBLE|
                WS_CLIPCHILDREN|
                TCS_SINGLELINE|
                TCS_FOCUSONBUTTONDOWN|
                TCS_TABS,
                emptyRect,
                this,
                IDC_VIEW_TAB_CTRL
                );

    ::TcInitTabs(&m_tabCtrl, &g_tcTabInfo);
}


void CLlsmgrView::InitUserList()

/*++

Routine Description:

    Initializes user list control.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CRect emptyRect;
    emptyRect.SetRectEmpty();

    m_userList.Create(
                WS_CHILD|
                WS_BORDER|
                WS_DISABLED|
                LVS_REPORT|
                LVS_SINGLESEL|
                LVS_SHOWSELALWAYS|
                LVS_SHAREIMAGELISTS|
                LVS_AUTOARRANGE,
                emptyRect,
                &m_tabCtrl,
                IDC_VIEW_USER_LIST
                );

    ::LvInitColumns(&m_userList, &g_userColumnInfo);
    g_tcTabInfo.tcTabEntry[TCID_PER_SEAT_CLIENTS].pWnd = &m_userList;
}


void CLlsmgrView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)

/*++

Routine Description:

    Called by framework when view is activated.

Arguments:

    bActivate - activated or deactivated.
    pActivateView - view being activated.
    pDeactiveView - view being deactivated.

Return Values:

    None.

--*/

{
    if (bActivate && (pActivateView == this))
    {
        if (IsTabInFocus(m_pTabEntry))
        {
            m_tabCtrl.SetFocus();
        }
        else
        {
            m_pTabEntry->pWnd->SetFocus();
        }
    }
}


void CLlsmgrView::OnColumnClickLicenseList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_COLUMNCLICK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    //g_licenseColumnInfo.bSortOrder  = GetKeyState(VK_CONTROL) < 0;
    g_licenseColumnInfo.bSortOrder = !g_licenseColumnInfo.bSortOrder;

    g_licenseColumnInfo.nSortedItem = ((NM_LISTVIEW*)pNMHDR)->iSubItem;

    m_licenseList.SortItems(CompareLicenses, 0);    // use column info    

    *pResult = 0;
}


void CLlsmgrView::OnDestroy()

/*++

Routine Description:

    Message handler for WM_DESTROY.

Arguments:

    None.

Return Values:

    None.

--*/

{
    ResetLicenseList();
    ResetProductList();
    ResetUserList();
    ResetServerTree();

    m_userList.DestroyWindow();
    m_serverTree.DestroyWindow();
    m_productList.DestroyWindow();
    m_licenseList.DestroyWindow();
    m_tabCtrl.DestroyWindow();

    CView::OnDestroy();
}


void CLlsmgrView::LoadSettings()

/*++

Routine Description:

    Load settings from registry.

Arguments:

    None.

Return Values:

    None.

--*/

{
    long Status;
    HKEY hKeyLlsmgr;

    m_bSaveSettings = TRUE;
    m_mruDomainList.RemoveAll();

    memset(&m_lFont, 0, sizeof(LOGFONT));

    m_lFont.lfHeight = FONT_HEIGHT_DEFAULT;
    m_lFont.lfWeight = FONT_WEIGHT_DEFAULT;
    CHARSETINFO csi;
    DWORD dw = ::GetACP();

    if (!::TranslateCharsetInfo((DWORD*)UIntToPtr(dw), &csi, TCI_SRCCODEPAGE))
        csi.ciCharset = ANSI_CHARSET;
    m_lFont.lfCharSet = (BYTE)csi.ciCharset; // default charset

    ::lstrcpy(m_lFont.lfFaceName, TEXT("MS Shell Dlg")); // default facename

    Status = RegOpenKeyEx(HKEY_CURRENT_USER, szRegKeyLlsmgr, 0, KEY_READ, &hKeyLlsmgr);

    if (Status == ERROR_SUCCESS)
    {
        DWORD dwType;
        DWORD dwSize;

        DWORD dwValue;
        TCHAR szValue[512];

        //
        // Load save settings on exit
        //

        dwType = REG_DWORD;
        dwSize = sizeof(DWORD);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrSaveSettings, 0, &dwType, (LPBYTE)&dwValue, &dwSize))
            m_bSaveSettings = (BOOL)dwValue;

        //
        // Load font information
        //

        dwType = REG_DWORD;
        dwSize = sizeof(DWORD);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontHeight, 0, &dwType, (LPBYTE)&dwValue, &dwSize))
            m_lFont.lfHeight = ((LONG)dwValue > 0) ? -((LONG)dwValue) : 0;

        dwType = REG_DWORD;
        dwSize = sizeof(DWORD);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontWeight, 0, &dwType, (LPBYTE)&dwValue, &dwSize))
            m_lFont.lfWeight = ((LONG)dwValue > 0) ? ((LONG)dwValue) : 0;

        dwType = REG_DWORD;
        dwSize = sizeof(DWORD);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontItalic, 0, &dwType, (LPBYTE)&dwValue, &dwSize))
            m_lFont.lfItalic = (BOOL)dwValue;

        dwType = REG_SZ;
        dwSize = sizeof(szValue);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontFaceName, 0, &dwType, (LPBYTE)szValue, &dwSize))
            lstrcpyn(m_lFont.lfFaceName, szValue, 32);

        dwType = REG_DWORD;
        dwSize = sizeof(DWORD);

        if (!::RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontCharset, 0, &dwType, (LPBYTE)&dwValue, &dwSize))
            m_lFont.lfCharSet = (BYTE)dwValue;

        //
        // MRU domain list
        //

        dwType = REG_MULTI_SZ;
        dwSize = sizeof(szValue);

        if (!RegQueryValueEx(hKeyLlsmgr, szRegKeyLlsmgrMruList, 0, &dwType, (LPBYTE)szValue, &dwSize))
        {
            LPTSTR psz = szValue;

            while (*psz)
            {
                AddToMRU(psz);
                psz += lstrlen(psz) + 1;
            }
        }

        RegCloseKey(hKeyLlsmgr);
    }
}


void CLlsmgrView::OnColumnClickProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_COLUMNCLICK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    // g_productColumnInfo.bSortOrder  = GetKeyState(VK_CONTROL) < 0;
    g_productColumnInfo.bSortOrder  = !g_productColumnInfo.bSortOrder;
    g_productColumnInfo.nSortedItem = ((NM_LISTVIEW*)pNMHDR)->iSubItem;
    m_productList.SortItems(CompareProducts, 0);    // use column info
    *pResult = 0;
}


void CLlsmgrView::OnColumnClickUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_COLUMNCLICK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    // g_userColumnInfo.bSortOrder  = GetKeyState(VK_CONTROL) < 0;
    g_userColumnInfo.bSortOrder = !g_userColumnInfo.bSortOrder;
    g_userColumnInfo.nSortedItem = ((NM_LISTVIEW*)pNMHDR)->iSubItem;
    m_userList.SortItems(CompareUsers, 0);          // use column info
    *pResult = 0;
}


LRESULT CLlsmgrView::OnContextMenu(WPARAM wParam, LPARAM lParam)

/*++

Routine Description:

    Message handler for WM_CONTEXTMENU.

Arguments:

    wParam - control window handle.
    lParam - screen coordinates of mouse.

Return Values:

    Returns 0 if successful.

--*/

{
    if (IsEditSupported(m_pTabEntry))
    {
        POINT  pt;
        POINTS pts = MAKEPOINTS(lParam);

        pt.x = (long)(short)pts.x;
        pt.y = (long)(short)pts.y;

        CRect wndRect;
        m_pTabEntry->pWnd->GetWindowRect(wndRect);

        if (wndRect.PtInRect(pt) && IsItemSelected(m_pTabEntry))
        {
            CMenu optionMenu;
            optionMenu.LoadMenu(IDM_POPUP);

            CMenu* pPopupMenu = optionMenu.GetSubMenu(m_pTabEntry->iItem);

            if (pPopupMenu)
            {
                pPopupMenu->TrackPopupMenu(
                                TPM_LEFTALIGN|
                                TPM_RIGHTBUTTON,
                                pt.x,
                                pt.y,
                                GetParentFrame(),
                                NULL
                                );
            }
        }
    }

    return 0;
}


BOOL CLlsmgrView::PreCreateWindow(CREATESTRUCT& cs)

/*++

Routine Description:

    Called by framework before window created.

Arguments:

    cs - window creation information.

Return Values:

    Returns 0 if successful.

--*/

{
    cs.style |= WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
    return CView::PreCreateWindow(cs);
}


int CLlsmgrView::OnCreate(LPCREATESTRUCT lpCreateStruct)

/*++

Routine Description:

    Message handler for WM_CREATE.

Arguments:

    lpCreateStruct - window creation information.

Return Values:

    Returns 0 if successful.

--*/

{
    if (CView::OnCreate(lpCreateStruct) == -1)
        return -1;

    InitTabCtrl();
    InitLicenseList();
    InitProductList();
    InitUserList();
    InitServerTree();

    CFont* pFont;

    if (pFont = CFont::FromHandle(::CreateFontIndirect(&m_lFont)))
    {
        m_tabCtrl.SetFont(pFont);
        m_licenseList.SetFont(pFont);
        m_productList.SetFont(pFont);
        m_userList.SetFont(pFont);
        m_serverTree.SetFont(pFont);
    }

    return 0;
}


void CLlsmgrView::OnDblClkProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_DBLCLK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ViewProductProperties();
    *pResult = 0;
}


void CLlsmgrView::OnDblClkServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_DBLCLK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    CService* pService;

    if (pService = (CService*)::TvGetSelObj(&m_serverTree))
    {
        ASSERT_VALID(pService);

        if (pService->IsKindOf(RUNTIME_CLASS(CService)))
        {
            ViewServerProperties(); // only support dblclk services
        }
    }

    *pResult = 0;
}


void CLlsmgrView::OnDblClkUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_DBLCLK.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ViewUserProperties();
    *pResult = 0;
}


void CLlsmgrView::OnDelete()

/*++

Routine Description:

    Message handler for ID_VIEW_DELETE.

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (m_pTabEntry->iItem == TCID_PER_SEAT_CLIENTS)
    {
        CUser* pUser;
        CString strConfirm;

        if (pUser = (CUser*)::LvGetSelObj(&m_userList))
        {
            AfxFormatString1(strConfirm, IDP_CONFIRM_DELETE_USER, pUser->m_strName);

            if (AfxMessageBox(strConfirm, MB_YESNO) == IDYES)
            {
                NTSTATUS NtStatus;

                NtStatus = ::LlsUserDelete(
                                LlsGetActiveHandle(),
                                MKSTR(pUser->m_strName)
                                );

                if (NtStatus == STATUS_OBJECT_NAME_NOT_FOUND)
                    NtStatus = STATUS_SUCCESS;

                if (NT_SUCCESS(NtStatus))
                {
                    OnUpdate(this, UPDATE_LICENSE_DELETED, NULL);
                }
                else
                {
                    theApp.DisplayStatus(NtStatus);
                }
            }
        }
    }
    else if (m_pTabEntry->iItem == TCID_PRODUCTS_VIEW)
    {
        CProduct* pProduct;

        if (pProduct = (CProduct*)::LvGetSelObj(&m_productList))
        {
            CController* pController = (CController*)MKOBJ(LlsGetApp()->GetActiveController());
            VALIDATE_OBJECT(pController, CController);

            LPTSTR pszUniServerName  = pController->GetName();

            if ( NULL == pszUniServerName )
            {
                theApp.DisplayStatus( STATUS_NO_MEMORY );
            }
            else
            {
                LPSTR pszAscServerName  = (LPSTR) LocalAlloc( LMEM_FIXED, 1 + lstrlen( pszUniServerName  ) );

                if ( NULL == pszAscServerName )
                {
                    theApp.DisplayStatus( STATUS_NO_MEMORY );
                }
                else
                {
                    wsprintfA( pszAscServerName, "%ls", pszUniServerName );

                    LPSTR  pszAscProductName = NULL;
                    LPTSTR pszUniProductName = pProduct->GetName();

                    if ( NULL != pszUniProductName )
                    {
                        pszAscProductName = (LPSTR) LocalAlloc( LMEM_FIXED, 1 + lstrlen( pszUniProductName ) );

                        if ( NULL != pszAscProductName )
                        {
                            wsprintfA( pszAscProductName, "%ls", pszUniProductName );
                        }

                        SysFreeString( pszUniProductName );
                    }

                    CCFCertificateRemoveUI( m_hWnd, pszAscServerName, pszAscProductName, pszAscProductName ? "Microsoft" : NULL, NULL, NULL );

                    OnUpdate(this, UPDATE_LICENSE_DELETED, NULL);

                    LocalFree( pszAscServerName );
                    if ( NULL != pszAscProductName )
                    {
                        LocalFree( pszAscProductName );
                    }
                }

                SysFreeString( pszUniServerName );
            }
        }
    }
}


void CLlsmgrView::OnDraw(CDC* pDC)

/*++

Routine Description:

    Message handler for WM_DRAW.

Arguments:

    pDC - device context.

Return Values:

    None.

--*/

{
    //
    // Nothing to do here...
    //
}


BOOL CLlsmgrView::OnEraseBkgnd(CDC* pDC)

/*++

Routine Description:

    Message handler for WM_ERASEBKGND.

Arguments:

    pDC - device context.

Return Values:

    None.

--*/

{
    CBrush grayBrush(RGB(192,192,192));
    CBrush* pOldBrush = pDC->SelectObject(&grayBrush);

    CRect clientRect;
    GetClientRect(clientRect);

    pDC->FillRect(clientRect, &grayBrush);

    pDC->SelectObject(pOldBrush);

    return TRUE;
}


void CLlsmgrView::OnFormatIcons()

/*++

Routine Description:

    Message handler for ID_VIEW_ICONS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (IsFormatSupported(m_pTabEntry) && !IsFormatLargeIcons(m_pTabEntry))
    {
        VALIDATE_OBJECT(m_pTabEntry->pWnd, CWnd);

        ::LvChangeFormat((CListCtrl*)m_pTabEntry->pWnd, LVS_ICON);
        SetFormatLargeIcons(m_pTabEntry);
    }
}


void CLlsmgrView::OnFormatList()

/*++

Routine Description:

    Message handler for MY_ID_VIEW_LIST.

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (IsFormatSupported(m_pTabEntry) && !IsFormatList(m_pTabEntry))
    {
        VALIDATE_OBJECT(m_pTabEntry->pWnd, CWnd);

        ::LvChangeFormat((CListCtrl*)m_pTabEntry->pWnd, LVS_LIST);
        SetFormatList(m_pTabEntry);
    }
}

void CLlsmgrView::OnFormatReport()

/*++

Routine Description:

    Message handler for ID_VIEW_REPORT.

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (IsFormatSupported(m_pTabEntry) && !IsFormatReport(m_pTabEntry))
    {
        VALIDATE_OBJECT(m_pTabEntry->pWnd, CWnd);

        ::LvChangeFormat((CListCtrl*)m_pTabEntry->pWnd, LVS_REPORT);
        SetFormatReport(m_pTabEntry);
    }
}

void CLlsmgrView::OnFormatSmallIcons()

/*++

Routine Description:

    Message handler for ID_VIEW_SMALL_ICON

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (IsFormatSupported(m_pTabEntry) && !IsFormatSmallIcons(m_pTabEntry))
    {
        VALIDATE_OBJECT(m_pTabEntry->pWnd, CWnd);

        ::LvChangeFormat((CListCtrl*)m_pTabEntry->pWnd, LVS_SMALLICON);
        SetFormatSmallIcons(m_pTabEntry);
    }
}


void CLlsmgrView::OnGetDispInfoLicenseList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_GETDISPINFO.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    LV_ITEM* plvItem = &((LV_DISPINFO*)pNMHDR)->item;
    ASSERT(plvItem);

    CLicense* pLicense = (CLicense*)plvItem->lParam;
    VALIDATE_OBJECT(pLicense, CLicense);

    switch (plvItem->iSubItem)
    {
    case LVID_SEPARATOR:
    {
        plvItem->iImage = 0;
        CString strLabel = _T("");
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PURCHASE_HISTORY_DATE:
    {
        BSTR bstrDate = pLicense->GetDateString();
        if(bstrDate != NULL )
        {
            lstrcpyn(plvItem->pszText, bstrDate, plvItem->cchTextMax);
            SysFreeString(bstrDate);
        }
    }
        break;

    case LVID_PURCHASE_HISTORY_PRODUCT:
        lstrcpyn(plvItem->pszText, pLicense->m_strProduct, plvItem->cchTextMax);
        break;

    case LVID_PURCHASE_HISTORY_QUANTITY:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pLicense->m_lQuantity);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PURCHASE_HISTORY_ADMINISTRATOR:
        lstrcpyn(plvItem->pszText, pLicense->m_strUser, plvItem->cchTextMax);
        break;

    case LVID_PURCHASE_HISTORY_COMMENT:
        lstrcpyn(plvItem->pszText, pLicense->m_strDescription, plvItem->cchTextMax);
        break;
    }

    *pResult = 0;
}


void CLlsmgrView::OnGetDispInfoProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_GETDISPINFO.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    LV_ITEM* plvItem = &((LV_DISPINFO*)pNMHDR)->item;
    ASSERT(plvItem);

    CProduct* pProduct = (CProduct*)plvItem->lParam;
    VALIDATE_OBJECT(pProduct, CProduct);

    switch (plvItem->iSubItem)
    {
    case LVID_PRODUCTS_VIEW_NAME:
        plvItem->iImage = CalcProductBitmap(pProduct);
        lstrcpyn(plvItem->pszText, pProduct->m_strName, plvItem->cchTextMax);
        break;

    case LVID_PRODUCTS_VIEW_PER_SEAT_CONSUMED:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pProduct->m_lInUse);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PRODUCTS_VIEW_PER_SEAT_PURCHASED:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pProduct->m_lLimit);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PRODUCTS_VIEW_PER_SERVER_PURCHASED:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pProduct->m_lConcurrent);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PRODUCTS_VIEW_PER_SERVER_REACHED:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pProduct->m_lHighMark);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;
    }

    *pResult = 0;
}


void CLlsmgrView::OnGetDispInfoServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TVN_GETDISPINFO.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    TV_ITEM* ptvItem = &((TV_DISPINFO*)pNMHDR)->item;

    CCmdTarget *pObject = (CCmdTarget*)ptvItem->lParam;
    VALIDATE_OBJECT(pObject, CCmdTarget);

    if (pObject->IsKindOf(RUNTIME_CLASS(CDomain)))
    {
        lstrcpyn(ptvItem->pszText, ((CDomain*)pObject)->m_strName, ptvItem->cchTextMax);

        ptvItem->iImage         = BMPI_DOMAIN;
        ptvItem->iSelectedImage = ptvItem->iImage;
    }
    else if (pObject->IsKindOf(RUNTIME_CLASS(CServer)))
    {
        lstrcpyn(ptvItem->pszText, ((CServer*)pObject)->m_strName, ptvItem->cchTextMax);

        ptvItem->iImage         = BMPI_SERVER;
        ptvItem->iSelectedImage = ptvItem->iImage;
    }
    else if (pObject->IsKindOf(RUNTIME_CLASS(CService)))
    {
        BSTR bstrServiceName = ((CService*)pObject)->GetDisplayName();
        lstrcpyn(ptvItem->pszText, bstrServiceName, ptvItem->cchTextMax);
        SysFreeString(bstrServiceName);

        ptvItem->iImage         = CalcServiceBitmap((CService*)pObject);
        ptvItem->iSelectedImage = ptvItem->iImage;
    }

    *pResult = 0;
}


void CLlsmgrView::OnGetDispInfoUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_GETDISPINFO.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    LV_ITEM* plvItem = &((LV_DISPINFO*)pNMHDR)->item;
    ASSERT(plvItem);

    CUser* pUser = (CUser*)plvItem->lParam;
    VALIDATE_OBJECT(pUser, CUser);

    switch (plvItem->iSubItem)
    {
    case LVID_PER_SEAT_CLIENTS_NAME:
        plvItem->iImage = CalcUserBitmap(pUser);
        lstrcpyn(plvItem->pszText, pUser->m_strName, plvItem->cchTextMax);
        break;

    case LVID_PER_SEAT_CLIENTS_LICENSED_USAGE:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pUser->m_lInUse);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PER_SEAT_CLIENTS_UNLICENSED_USAGE:
    {
        CString strLabel;
        strLabel.Format(_T("%ld"), pUser->m_lUnlicensed);
        lstrcpyn(plvItem->pszText, strLabel, plvItem->cchTextMax);
    }
        break;

    case LVID_PER_SEAT_CLIENTS_SERVER_PRODUCTS:
        lstrcpyn(plvItem->pszText, pUser->m_strProducts, plvItem->cchTextMax);
        break;
    }

    *pResult = 0;
}


void CLlsmgrView::OnItemExpandingServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TVN_ITEMEXPANDING.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
    TV_ITEM tvItem = pNMTreeView->itemNew;

    if (!(tvItem.state & TVIS_EXPANDEDONCE))
    {
        BeginWaitCursor();

        CCmdTarget* pParent = (CCmdTarget*)tvItem.lParam;
        VALIDATE_OBJECT(pParent, CCmdTarget);

        VARIANT va;
        VariantInit(&va);

        BOOL bIsInserted = FALSE;
        BOOL bDisplayError = TRUE;

        if (pParent->IsKindOf(RUNTIME_CLASS(CApplication)))
        {
            CDomains* pDomains = (CDomains*)MKOBJ(((CApplication*)pParent)->GetDomains(va));

            if (pDomains)
            {
                if (::TvInsertObArray(&m_serverTree, tvItem.hItem, pDomains->m_pObArray))
                {
                    bIsInserted = TRUE;
                }

                pDomains->InternalRelease();    // objects AddRef'd individually
            }
        }
        else if (pParent->IsKindOf(RUNTIME_CLASS(CDomain)))
        {
            CServers* pServers = (CServers*)MKOBJ(((CDomain*)pParent)->GetServers(va));

            if (pServers)
            {
                if (::TvInsertObArray(&m_serverTree, tvItem.hItem, pServers->m_pObArray))
                {
                    bIsInserted = TRUE;
                }

                pServers->InternalRelease();    // objects AddRef'd individually
            }
        }
        else if (pParent->IsKindOf(RUNTIME_CLASS(CServer)))
        {
            CServices* pServices = (CServices*)MKOBJ(((CServer*)pParent)->GetServices(va));

            if (pServices)
            {
                if (::TvInsertObArray(&m_serverTree, tvItem.hItem, pServices->m_pObArray, FALSE))
                {
                    bIsInserted = TRUE;
                }

                pServices->InternalRelease();   // objects AddRef'd individually
            }
            else if (    ( ERROR_FILE_NOT_FOUND == LlsGetLastStatus() )
                      || ( STATUS_NOT_FOUND     == LlsGetLastStatus() ) )
            {
                // license service not configured on the target server
                AfxMessageBox( IDP_ERROR_SERVER_NOT_CONFIGURED, MB_OK | MB_ICONEXCLAMATION, 0 );
                bDisplayError = FALSE;
            }
        }

        EndWaitCursor();

        if (!bIsInserted && bDisplayError)
        {
            theApp.DisplayLastStatus();
        }
    }

    *pResult = 0;
}


void CLlsmgrView::OnInitialUpdate()

/*++

Routine Description:

    Called by framework after the view is first attached
    to the document but before it is initially displayed.

Arguments:

    None.

Return Values:

    None.

--*/

{
    if (LlsGetApp()->IsConnected())
    {
        OnUpdate(this, UPDATE_MAIN_TABS, NULL);
    }
}


void CLlsmgrView::OnKeyDownLicenseList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_KEYDOWN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    if (((LV_KEYDOWN*)pNMHDR)->wVKey == VK_TAB)
    {
        m_tabCtrl.SetFocus();
    }

    *pResult = 0;
}


void CLlsmgrView::OnKeyDownProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_KEYDOWN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    if (((LV_KEYDOWN*)pNMHDR)->wVKey == VK_TAB)
    {
        m_tabCtrl.SetFocus();
    }

    *pResult = 0;
}


void CLlsmgrView::OnKeyDownServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TVN_KEYDOWN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    if (((TV_KEYDOWN*)pNMHDR)->wVKey == VK_TAB)
    {
        m_tabCtrl.SetFocus();
    }

    *pResult = TRUE;
}


void CLlsmgrView::OnKeyDownTabCtrl(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TCN_KEYDOWN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    TC_KEYDOWN* tcKeyDown = (TC_KEYDOWN*)pNMHDR;

    if (tcKeyDown->wVKey == VK_TAB)
    {
        m_pTabEntry->pWnd->SetFocus();
    }
    else if ((tcKeyDown->wVKey == VK_LEFT) &&
             (m_pTabEntry->iItem == TCID_PURCHASE_HISTORY))
    {
        PostMessage(WM_COMMAND, ID_VIEW_SERVERS);
    }
    else if ((tcKeyDown->wVKey == VK_RIGHT) &&
             (m_pTabEntry->iItem == TCID_SERVER_BROWSER))
    {
        PostMessage(WM_COMMAND, ID_VIEW_LICENSES);
    }

    *pResult = 0;
}


void CLlsmgrView::OnKeyDownUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for LVN_KEYDOWN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    if (((LV_KEYDOWN*)pNMHDR)->wVKey == VK_TAB)
    {
        m_tabCtrl.SetFocus();
    }

    *pResult = 0;
}



void CLlsmgrView::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)

/*++

Routine Description:

    Message handler for WM_INITMENU.

Arguments:

    pPopupMenu - menu object.
    nIndex - menu position.
    bSysMenu - true if system menu.

Return Values:

    None.

--*/

{
#define SUBMENU_LICENSE             0
#define SUBMENU_LICENSE_DELETE      2
#define SUBMENU_LICENSE_PROPERTIES  3
#define SUBMENU_LICENSE_INSERT_MRU  7

#define SUBMENU_LICENSE_ITEM_ID0    ID_NEW_LICENSE

#define SUBMENU_OPTIONS             2
#define SUBMENU_OPTIONS_FORMAT      2
#define SUBMENU_OPTIONS_SORTBY      3

#define SUBMENU_OPTIONS_ITEM_ID0    ID_SELECT_FONT

#define SUBMENU_FORMAT_LARGE_ICON   0
#define SUBMENU_FORMAT_SMALL_ICON   1
#define SUBMENU_FORMAT_LIST         2
#define SUBMENU_FORMAT_DETAILS      3

    if (bSysMenu)
        return; // bail...

    if ((nIndex != SUBMENU_LICENSE) && (nIndex != SUBMENU_OPTIONS))
        return; // bail...

    int nMenuItemId = pPopupMenu->GetMenuItemID(0); // check first item

    if (nMenuItemId == SUBMENU_LICENSE_ITEM_ID0)
    {
        UINT CmdId;
        UINT MenuId;

        CmdId = ID_MRU_DOMAIN0;
        while (pPopupMenu->RemoveMenu(CmdId++, MF_BYCOMMAND))
            ;

        POSITION position;
        position = m_mruDomainList.GetHeadPosition();

        CmdId  = ID_MRU_DOMAIN0;
        MenuId = SUBMENU_LICENSE_INSERT_MRU;

        while (position)
        {
            TCHAR num[10];
            wsprintf(num, _T("&%d "), CmdId - ID_MRU_DOMAIN0 + 1);

            CString strDomain = m_mruDomainList.GetNext(position);
            pPopupMenu->InsertMenu(MenuId++, MF_BYPOSITION, CmdId++, CString(num) + strDomain);
        }
    }
    else if (nMenuItemId == SUBMENU_OPTIONS_ITEM_ID0)
    {
        UINT fEnableFormat = IsFormatSupported(m_pTabEntry) ? MF_ENABLED : MF_GRAYED;
        UINT fEnableSortBy = IsSortSupported(m_pTabEntry)   ? MF_ENABLED : MF_GRAYED;

        pPopupMenu->EnableMenuItem(SUBMENU_OPTIONS_FORMAT, MF_BYPOSITION|fEnableFormat);
        pPopupMenu->EnableMenuItem(SUBMENU_OPTIONS_SORTBY, MF_BYPOSITION|fEnableSortBy);

        if (fEnableSortBy == MF_ENABLED)
        {
            ASSERT(m_pTabEntry->plvColumnInfo);
            PLV_COLUMN_ENTRY plvColumnEntry = m_pTabEntry->plvColumnInfo->lvColumnEntry;

            CMenu* pSortByMenu = pPopupMenu->GetSubMenu(SUBMENU_OPTIONS_SORTBY);

            while (pSortByMenu->RemoveMenu(0, MF_BYPOSITION))
                ;

            int index;
            int nStringId;
            CString strMenu;

            for (index = 0; index < m_pTabEntry->plvColumnInfo->nColumns; index++)
            {
                if (nStringId = plvColumnEntry->nMenuStringId)
                {
                    strMenu.LoadString(nStringId);
                    pSortByMenu->AppendMenu(MF_STRING, ID_SORT_COLUMN0+index, strMenu);
                }

                plvColumnEntry++;
            }

            pSortByMenu->CheckMenuItem(ID_SORT_COLUMN0+m_pTabEntry->plvColumnInfo->nSortedItem, MF_BYCOMMAND|MF_CHECKED);
        }

        if (fEnableFormat == MF_ENABLED)
        {
            CMenu* pFormatMenu = pPopupMenu->GetSubMenu(SUBMENU_OPTIONS_FORMAT);

            pFormatMenu->CheckMenuItem(SUBMENU_FORMAT_LARGE_ICON, MF_BYPOSITION|(IsFormatLargeIcons(m_pTabEntry) ? MF_CHECKED : MF_UNCHECKED));
            pFormatMenu->CheckMenuItem(SUBMENU_FORMAT_SMALL_ICON, MF_BYPOSITION|(IsFormatSmallIcons(m_pTabEntry) ? MF_CHECKED : MF_UNCHECKED));
            pFormatMenu->CheckMenuItem(SUBMENU_FORMAT_LIST      , MF_BYPOSITION|(IsFormatList(m_pTabEntry)       ? MF_CHECKED : MF_UNCHECKED));
            pFormatMenu->CheckMenuItem(SUBMENU_FORMAT_DETAILS   , MF_BYPOSITION|(IsFormatReport(m_pTabEntry)     ? MF_CHECKED : MF_UNCHECKED));
        }
    }
}


void CLlsmgrView::OnNewLicense()

/*++

Routine Description:

    Message handler for ID_NEW_LICENSE.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CController* pController = (CController*)MKOBJ(LlsGetApp()->GetActiveController());
    VALIDATE_OBJECT(pController, CController);

    LPTSTR pszUniServerName  = pController->GetName();

    if ( NULL == pszUniServerName )
    {
        theApp.DisplayStatus( STATUS_NO_MEMORY );
    }
    else
    {
        LPSTR pszAscServerName  = (LPSTR) LocalAlloc( LMEM_FIXED, 1 + lstrlen( pszUniServerName  ) );

        if ( NULL == pszAscServerName )
        {
            theApp.DisplayStatus( STATUS_NO_MEMORY );
        }
        else
        {
            wsprintfA( pszAscServerName, "%ls", pszUniServerName );

            LPSTR pszAscProductName = NULL;

            if ( m_pTabEntry->iItem == TCID_PRODUCTS_VIEW )
            {
                CProduct* pProduct = (CProduct*) ::LvGetSelObj(&m_productList);

                if ( NULL != pProduct )
                {
                    LPTSTR pszUniProductName = pProduct->GetName();

                    if ( NULL != pszUniProductName )
                    {
                        pszAscProductName = (LPSTR) LocalAlloc( LMEM_FIXED, 1 + lstrlen( pszUniProductName ) );

                        if ( NULL != pszAscProductName )
                        {
                            wsprintfA( pszAscProductName, "%ls", pszUniProductName );
                        }

                        SysFreeString( pszUniProductName );
                    }
                }
            }

            DWORD dwError = CCFCertificateEnterUI( m_hWnd, pszAscServerName, pszAscProductName, pszAscProductName ? "Microsoft" : NULL, CCF_ENTER_FLAG_PER_SEAT_ONLY | CCF_ENTER_FLAG_SERVER_IS_ES, NULL );
            DWORD fUpdateHint;

            if ( ERROR_SUCCESS == dwError )
            {
                fUpdateHint = UPDATE_LICENSE_ADDED;
            }
            else
            {
                fUpdateHint = UPDATE_INFO_NONE;
            }

            OnUpdate(this, fUpdateHint, NULL);

            LocalFree( pszAscServerName );
            if ( NULL != pszAscProductName )
            {
                LocalFree( pszAscProductName );
            }
        }

        SysFreeString( pszUniServerName );
    }
}


void CLlsmgrView::OnNewMapping()

/*++

Routine Description:

    Message handler for ID_NEW_MAPPING.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CNewMappingDialog newmDlg;
    newmDlg.DoModal();

    OnUpdate(this, newmDlg.m_fUpdateHint, NULL);
}


void CLlsmgrView::OnReturnProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_RETURN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ViewProductProperties();
    *pResult = 0;
}


void CLlsmgrView::OnReturnServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_RETURN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ViewServerProperties();
    *pResult = 0;
}


void CLlsmgrView::OnReturnUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_RETURN.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ViewUserProperties();
    *pResult = 0;
}


void CLlsmgrView::OnSaveSettings()

/*++

Routine Description:

    Message handler for ID_SAVE_SETTINGS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    m_bSaveSettings = !m_bSaveSettings;
}


void CLlsmgrView::OnSelChangeTabCtrl(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TCN_SELCHANGE.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    EnableCurSelTab(TRUE);
    *pResult = 0;
}


void CLlsmgrView::OnSelChangingTabCtrl(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for TCN_SELCHANGING.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    EnableCurSelTab(FALSE);
    *pResult = 0;
}


void CLlsmgrView::OnSelectDomain()

/*++

Routine Description:

    Message handler for ID_SELECT_DOMAIN.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CSelectDomainDialog domainDlg;
    domainDlg.DoModal();

    OnUpdate(this, domainDlg.m_fUpdateHint, NULL);
}


void CLlsmgrView::OnSelectFont()

/*++

Routine Description:

    Message handler for ID_SELECT_FONT.

Arguments:

    None.

Return Values:

    None.

--*/

{
    LOGFONT lFont = m_lFont;

    CFontDialog fontDlg(&lFont, CF_SCREENFONTS|CF_LIMITSIZE, NULL, NULL);

    fontDlg.m_cf.nSizeMin  = 8;
    fontDlg.m_cf.nSizeMax  = 20;

    if (fontDlg.DoModal() == IDOK)
    {
        CFont* pNewFont;

        if (!*(m_lFont.lfFaceName))
            lFont.lfCharSet = m_lFont.lfCharSet;
        if (pNewFont = CFont::FromHandle(::CreateFontIndirect(&lFont)))
        {
            m_lFont = lFont;

            BeginWaitCursor();

            m_tabCtrl.SetFont(pNewFont);
            m_licenseList.SetFont(pNewFont);
            m_productList.SetFont(pNewFont);
            m_userList.SetFont(pNewFont);
            m_serverTree.SetFont(pNewFont);

            EndWaitCursor();
        }
    }
}


BOOL CLlsmgrView::OnSelMruDomain(UINT nID)

/*++

Routine Description:

    Message handler for ID_MRU_DOMAIN*.

Arguments:

    nID - id of domain.

Return Values:

    Returns true always.

--*/

{
    POSITION position;

    if (position = m_mruDomainList.FindIndex(nID - ID_MRU_DOMAIN0))
        theApp.OpenDocumentFile(m_mruDomainList.GetAt(position));

    return TRUE;
}


void CLlsmgrView::OnSetFocusLicenseList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_SETFOCUS.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ClrTabInFocus(m_pTabEntry);
    *pResult = 0;
}


void CLlsmgrView::OnSetFocusProductList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_SETFOCUS.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ClrTabInFocus(m_pTabEntry);
    *pResult = 0;
}


void CLlsmgrView::OnSetFocusTabCtrl(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_SETFOCUS.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    SetTabInFocus(m_pTabEntry);
    *pResult = 0;
}


void CLlsmgrView::OnSetFocusServerTree(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_SETFOCUS.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ClrTabInFocus(m_pTabEntry);
    *pResult = 0;
}


void CLlsmgrView::OnSetFocusUserList(NMHDR* pNMHDR, LRESULT* pResult)

/*++

Routine Description:

    Notification handler for NM_SETFOCUS.

Arguments:

    pNMHDR - notification header.
    pResult - return code.

Return Values:

    None.

--*/

{
    ClrTabInFocus(m_pTabEntry);
    *pResult = 0;
}


void CLlsmgrView::OnSize(UINT nType, int cx, int cy)

/*++

Routine Description:

    Message handler for WM_SIZE.

Arguments:

    nType - type of resizing.
    cx - new width of client area.
    cy - new height of client area.

Return Values:

    None.

--*/

{
    int x, y;

    CView::OnSize(nType, cx, cy);

#define INDENT_FROM_FRAME    5
#define INDENT_FROM_TAB_CTRL 10

    if (m_tabCtrl.GetSafeHwnd())
    {
        CRect clientRect;
        GetClientRect(clientRect);

        x  = INDENT_FROM_FRAME;
        y  = INDENT_FROM_FRAME;
        cx = clientRect.Width()  - ((2 * x) + 1);
        cy = clientRect.Height() - ((2 * y) + 1);

        m_tabCtrl.MoveWindow(x, y, cx, cy, TRUE);

        RECT tabRect;
        m_tabCtrl.GetClientRect(clientRect);
        m_tabCtrl.GetItemRect(0, &tabRect);

        int tabHeight = tabRect.bottom - tabRect.top;

        x  = INDENT_FROM_TAB_CTRL;
        y  = (2 * tabHeight);
        cx = clientRect.Width()  - ((2 * x) + 1);
        cy = clientRect.Height() - ((2 * tabHeight) + INDENT_FROM_TAB_CTRL + 1);

        m_licenseList.MoveWindow(x, y, cx, cy, TRUE);
        m_productList.MoveWindow(x, y, cx, cy, TRUE);
        m_userList.MoveWindow   (x, y, cx, cy, TRUE);
        m_serverTree.MoveWindow (x, y, cx, cy, TRUE);

        RecalcListColumns();
    }
}


void CLlsmgrView::OnSortColumn(int iColumn)

/*++

Routine Description:

    Sort dispatcher.

Arguments:

    iColumn - sort criteria.

Return Values:

    None.

--*/

{
    //BOOL bOrder = GetKeyState(VK_CONTROL) < 0;

    

    switch (m_pTabEntry->iItem)
    {
    case TCID_PURCHASE_HISTORY:
        g_licenseColumnInfo.bSortOrder  = m_bOrder;
        g_licenseColumnInfo.nSortedItem = iColumn;
        m_licenseList.SortItems(CompareLicenses, 0);    // use column info
        break;
    case TCID_PRODUCTS_VIEW:
        g_productColumnInfo.bSortOrder  = m_bOrder;
        g_productColumnInfo.nSortedItem = iColumn;
        m_productList.SortItems(CompareProducts, 0);    // use column info
        break;
    case TCID_PER_SEAT_CLIENTS:
        g_userColumnInfo.bSortOrder  = m_bOrder;
        g_userColumnInfo.nSortedItem = iColumn;
        m_userList.SortItems(CompareUsers, 0);          // use column info
        break;
    }
    
    m_bOrder = !m_bOrder;
}

void CLlsmgrView::OnSortColumn0()
    { OnSortColumn(0); }

void CLlsmgrView::OnSortColumn1()
    { OnSortColumn(1); }

void CLlsmgrView::OnSortColumn2()
    { OnSortColumn(2); }

void CLlsmgrView::OnSortColumn3()
    { OnSortColumn(3); }

void CLlsmgrView::OnSortColumn4()
    { OnSortColumn(4); }

void CLlsmgrView::OnSortColumn5()
    { OnSortColumn(5); }


void CLlsmgrView::OnUpdate(CView* pSender, LPARAM fUpdateHint, CObject* pIgnore)

/*++

Routine Description:

    Called by framework when view needs to be refreshed.

Arguments:

    pSender - view that modified document (only one).
    fUpdateHint - hints about modifications.
    pIgnore - not used.

Return Values:

    None.

--*/

{
    ASSERT(pSender);

    BeginWaitCursor();

    if (IsLicenseInfoUpdated(fUpdateHint))
    {
        if (RefreshLicenseList())
        {
            SetTabUpdated(&g_tcTabInfo.tcTabEntry[TCID_PURCHASE_HISTORY]);
        }
        else
        {
            fUpdateHint = UPDATE_INFO_ABORT;
            theApp.DisplayLastStatus();
        }
    }

    if (IsProductInfoUpdated(fUpdateHint))
    {
        if (RefreshProductList())
        {
            SetTabUpdated(&g_tcTabInfo.tcTabEntry[TCID_PRODUCTS_VIEW]);
        }
        else
        {
            fUpdateHint = UPDATE_INFO_ABORT;
            theApp.DisplayLastStatus();
        }
    }

    if (IsUserInfoUpdated(fUpdateHint))
    {
        if (RefreshUserList())
        {
            SetTabUpdated(&g_tcTabInfo.tcTabEntry[TCID_PER_SEAT_CLIENTS]);
        }
        else
        {
            fUpdateHint = UPDATE_INFO_ABORT;
            theApp.DisplayLastStatus();
        }
    }

    if (IsUpdateAborted(fUpdateHint))
    {
        ResetLicenseList();
        ResetProductList();
        ResetUserList();

        CSelectDomainDialog sdomDlg;

        if (sdomDlg.DoModal() != IDOK)
        {
            theApp.m_pMainWnd->PostMessage(WM_CLOSE);
        }
    }
    else if (IsServerInfoUpdated(fUpdateHint))
    {
        if (RefreshServerTree())
        {
            SetTabUpdated(&g_tcTabInfo.tcTabEntry[TCID_SERVER_BROWSER]);
        }
        else
        {
            ResetServerTree();
            theApp.DisplayLastStatus();
        }
    }

    EndWaitCursor();
}


void CLlsmgrView::OnUpdateSaveSettings(CCmdUI* pCmdUI)

/*++

Routine Description:

    Notification handler for ID_SAVE_SETTINGS.

Arguments:

    pCmdUI - interface for updating menu.

Return Values:

    None.

--*/

{
    pCmdUI->SetCheck(m_bSaveSettings);
}


void CLlsmgrView::OnUpdateViewDelete(CCmdUI* pCmdUI)

/*++

Routine Description:

    Notification handler for ID_VIEW_DELETE.

Arguments:

    pCmdUI - interface for updating menu.

Return Values:

    None.

--*/

{
    if (!(IsItemSelected(m_pTabEntry) && IsDeleteSupported(m_pTabEntry)))
    {
        pCmdUI->Enable(FALSE);
    }
    else if (m_pTabEntry->iItem == TCID_PRODUCTS_VIEW)
    {
        //
        // Make sure they are licenses to delete...
        //

        CProduct* pProduct = (CProduct*)::LvGetSelObj(&m_productList);
        VALIDATE_OBJECT(pProduct, CProduct);

        if ( pProduct )
        {
            pCmdUI->Enable(pProduct->m_lLimit);
        }
    }
    else
    {
        pCmdUI->Enable(TRUE);
    }
}


void CLlsmgrView::OnUpdateViewProperties(CCmdUI* pCmdUI)

/*++

Routine Description:

    Notification handler for ID_VIEW_PROPERTIES.

Arguments:

    pCmdUI - interface for updating menu.

Return Values:

    None.

--*/

{
    if (!(IsItemSelected(m_pTabEntry) && IsEditSupported(m_pTabEntry)))
    {
        pCmdUI->Enable(FALSE);
    }
    else if (m_pTabEntry->iItem == TCID_SERVER_BROWSER)
    {
        //
        // No properties for enterprise or domain...
        //

        CCmdTarget* pObject = (CCmdTarget*)::TvGetSelObj(&m_serverTree);
        VALIDATE_OBJECT(pObject, CCmdTarget);

        if ( pObject )
        {
            pCmdUI->Enable(pObject->IsKindOf(RUNTIME_CLASS(CServer)) ||
                           pObject->IsKindOf(RUNTIME_CLASS(CService)));
        }
    }
    else
    {
        pCmdUI->Enable(TRUE);
    }
}


void CLlsmgrView::OnViewLicenses()

/*++

Routine Description:

    Message handler for ID_VIEW_LICENSES.

Arguments:

    None.

Return Values:

    None.

--*/

{
    EnableCurSelTab(FALSE);
    m_tabCtrl.SetCurSel(TCID_PURCHASE_HISTORY);
    EnableCurSelTab(TRUE);
}


void CLlsmgrView::OnViewMappings()

/*++

Routine Description:

    Message handler for ID_VIEW_MAPPINGS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CLicenseGroupsDialog lgrpDlg;
    lgrpDlg.DoModal();

    OnUpdate(this, lgrpDlg.m_fUpdateHint, NULL);
}


void CLlsmgrView::OnViewProducts()

/*++

Routine Description:

    Message handler for ID_VIEW_PRODUCTS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    EnableCurSelTab(FALSE);
    m_tabCtrl.SetCurSel(TCID_PRODUCTS_VIEW);
    EnableCurSelTab(TRUE);
}


void CLlsmgrView::OnViewProperties()

/*++

Routine Description:

    View the properties of selected object.

Arguments:

    None.

Return Values:

    None.

--*/

{
    switch (m_pTabEntry->iItem)
    {
    case TCID_PRODUCTS_VIEW:
        ViewProductProperties();
        return;
    case TCID_PER_SEAT_CLIENTS:
        ViewUserProperties();
        return;
    case TCID_SERVER_BROWSER:
        ViewServerProperties();
        return;
    }
}


void CLlsmgrView::OnViewRefresh()

/*++

Routine Description:

    Message handler for ID_VIEW_REFRESH.

Arguments:

    None.

Return Values:

    None.

--*/

{
    GetDocument()->Update();

    OnUpdate(
        this,
        (m_pTabEntry->iItem == TCID_SERVER_BROWSER)
            ? UPDATE_BROWSER_TAB
            : UPDATE_MAIN_TABS,
        NULL
        );
}


void CLlsmgrView::OnViewServers()

/*++

Routine Description:

    Message handler for ID_VIEW_SERVERS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    EnableCurSelTab(FALSE);
    m_tabCtrl.SetCurSel(TCID_SERVER_BROWSER);
    EnableCurSelTab(TRUE);
    m_serverTree.SetFocus();
}


void CLlsmgrView::OnViewUsers()

/*++

Routine Description:

    Message handler for ID_VIEW_USERS.

Arguments:

    None.

Return Values:

    None.

--*/

{
    EnableCurSelTab(FALSE);
    m_tabCtrl.SetCurSel(TCID_PER_SEAT_CLIENTS);
    EnableCurSelTab(TRUE);
}


void CLlsmgrView::RecalcListColumns()

/*++

Routine Description:

    Adjusts list columns to client area.

Arguments:

    None.

Return Values:

    None.

--*/

{
    ::LvResizeColumns(&m_licenseList, &g_licenseColumnInfo);
    ::LvResizeColumns(&m_productList, &g_productColumnInfo);
    ::LvResizeColumns(&m_userList,    &g_userColumnInfo);
}


BOOL CLlsmgrView::RefreshLicenseList()

/*++

Routine Description:

    Refreshs license list control.

Arguments:

    None.

Return Values:

    Returns true if licenses successfully updated.

--*/

{
    CLicenses* pLicenses;

    if (pLicenses = GetDocument()->GetLicenses())
    {
        return ::LvRefreshObArray(
                    &m_licenseList,
                    &g_licenseColumnInfo,
                    pLicenses->m_pObArray
                    );
    }

    return FALSE;
}


BOOL CLlsmgrView::RefreshProductList()

/*++

Routine Description:

    Refreshs product list control.

Arguments:

    None.

Return Values:

    Returns true if products successfully updated.

--*/

{
    CProducts* pProducts;

    if (pProducts = GetDocument()->GetProducts())
    {
        return ::LvRefreshObArray(
                    &m_productList,
                    &g_productColumnInfo,
                    pProducts->m_pObArray
                    );
    }

    return FALSE;
}


BOOL CLlsmgrView::RefreshServerTree()

/*++

Routine Description:

    Refreshs server tree control.

Arguments:

    None.

Return Values:

    Returns true if servers successfully updated.

--*/

{
    HTREEITEM hRoot;
    HTREEITEM hDomain;

    TV_ITEM tvItem = {0};
    TV_INSERTSTRUCT tvInsert;

    BOOL bIsRefreshed = FALSE;

    if (hRoot = m_serverTree.GetRootItem())
    {
        VARIANT va;
        VariantInit(&va);

        CDomain*  pDomain;
        CDomains* pDomains = (CDomains*)MKOBJ(LlsGetApp()->GetDomains(va));

        m_serverTree.SetRedraw( FALSE );

        if (pDomains)
        {
            TV_EXPANDED_INFO tvExpandedInfo;

            if (::TvRefreshObArray(
                    &m_serverTree,
                    hRoot,
                    pDomains->m_pObArray,
                    &tvExpandedInfo))
            {
                TV_EXPANDED_ITEM* pExpandedItem = tvExpandedInfo.pExpandedItems;

                while (tvExpandedInfo.nExpandedItems--)
                {
                    pDomain = (CDomain*)pExpandedItem->pObject;
                    VALIDATE_OBJECT(pDomain, CDomain);

                    if (hDomain = ::TvGetDomain(&m_serverTree, hRoot, pDomain))
                    {
                        ::TvSwitchItem(&m_serverTree, hDomain, pExpandedItem);

                        if (!RefreshServerTreeServers(pExpandedItem->hItem))
                        {
                            ::TvReleaseObArray(&m_serverTree, pExpandedItem->hItem);
                        }
                    }
                    else
                    {
                        ::TvReleaseObArray(&m_serverTree, pExpandedItem->hItem);
                    }

                    pDomain->InternalRelease(); // release now...
                    pExpandedItem++;
                }

                delete [] tvExpandedInfo.pExpandedItems;

                bIsRefreshed = TRUE;
            }

            pDomains->InternalRelease(); // release now...
        }

        if (bIsRefreshed)
        {
            TV_SORTCB tvSortCB;

            tvSortCB.hParent     = hRoot;
            tvSortCB.lpfnCompare = CompareDomains;
            tvSortCB.lParam      = 0L;  // ignored...

            m_serverTree.SortChildrenCB(&tvSortCB);
        }

        m_serverTree.SetRedraw( TRUE );
    }
    else
    {
        CString strLabel;

        tvItem.mask = TVIF_TEXT|
                      TVIF_PARAM|
                      TVIF_CHILDREN|
                      TVIF_SELECTEDIMAGE|
                      TVIF_IMAGE;

        tvItem.cChildren = TRUE;
        tvItem.iImage = BMPI_ENTERPRISE;
        tvItem.iSelectedImage = BMPI_ENTERPRISE;

        strLabel.LoadString(IDS_ENTERPRISE);
        tvItem.pszText = MKSTR(strLabel);

        tvItem.lParam = (LPARAM)(LPVOID)LlsGetApp();

        tvInsert.item         = tvItem;
        tvInsert.hInsertAfter = (HTREEITEM)TVI_ROOT;
        tvInsert.hParent      = (HTREEITEM)NULL;

        if (hRoot = m_serverTree.InsertItem(&tvInsert))
        {
            hDomain = hRoot; // initialize...

            if (m_serverTree.Expand(hRoot, TVE_EXPAND))
            {
                if (LlsGetApp()->IsFocusDomain())
                {
                    CDomain* pActiveDomain = GetDocument()->GetDomain();
                    ASSERT(pActiveDomain);

                    if (hDomain = ::TvGetDomain(&m_serverTree, hRoot, pActiveDomain))
                    {
                        m_serverTree.Expand(hDomain, TVE_EXPAND);
                    }
                }
            }
            else
            {
                theApp.DisplayLastStatus(); // display warning...
            }

            VERIFY(m_serverTree.Select(hDomain, TVGN_FIRSTVISIBLE));
            VERIFY(m_serverTree.Select(hDomain, TVGN_CARET));

            bIsRefreshed = TRUE;
        }
        else
        {
            LlsSetLastStatus(STATUS_NO_MEMORY);
        }
    }

    return bIsRefreshed;
}


BOOL CLlsmgrView::RefreshServerTreeServers(HTREEITEM hParent)

/*++

Routine Description:

    Refreshs servers of domain.

Arguments:

    hParent - handle of expanded domain.

Return Values:

    Returns true if successful.

--*/

{
    TV_ITEM tvItem;
    HTREEITEM hServer;

    BOOL bIsRefreshed = FALSE;

    VARIANT va;
    VariantInit(&va);

    tvItem.hItem = hParent;
    tvItem.mask  = LVIF_PARAM;

    VERIFY(m_serverTree.GetItem(&tvItem));

    CDomain* pDomain = (CDomain*)tvItem.lParam;
    VALIDATE_OBJECT(pDomain, CDomain);

    CServer*  pServer;
    CServers* pServers = (CServers*)MKOBJ(pDomain->GetServers(va));

    if (pServers)
    {
        TV_EXPANDED_INFO tvExpandedInfo;

        if (::TvRefreshObArray(
                &m_serverTree,
                hParent,
                pServers->m_pObArray,
                &tvExpandedInfo))
        {
            TV_EXPANDED_ITEM* pExpandedItem = tvExpandedInfo.pExpandedItems;

            while (tvExpandedInfo.nExpandedItems--)
            {
                pServer = (CServer*)pExpandedItem->pObject;
                VALIDATE_OBJECT(pServer, CServer);

                if (hServer = ::TvGetServer(&m_serverTree, hParent, pServer))
                {
                    ::TvSwitchItem(&m_serverTree, hServer, pExpandedItem);

                    if (!RefreshServerTreeServices(pExpandedItem->hItem))
                    {
                        ::TvReleaseObArray(&m_serverTree, pExpandedItem->hItem);
                    }
                }
                else
                {
                    ::TvReleaseObArray(&m_serverTree, pExpandedItem->hItem);
                }

                pServer->InternalRelease(); // release now...
                pExpandedItem++;
            }

            delete [] tvExpandedInfo.pExpandedItems;
            bIsRefreshed = TRUE;
        }

        pServers->InternalRelease(); // release now...
    }

    if (bIsRefreshed)
    {
        TV_SORTCB tvSortCB;

        tvSortCB.hParent     = hParent;
        tvSortCB.lpfnCompare = CompareServers;
        tvSortCB.lParam      = 0L;  // ignored...

        m_serverTree.SortChildrenCB(&tvSortCB);
    }
    else
    {
        theApp.DisplayLastStatus();
    }

    return bIsRefreshed;
}


BOOL CLlsmgrView::RefreshServerTreeServices(HTREEITEM hParent)

/*++

Routine Description:

    Refreshs services of server.

Arguments:

    hParent - handle of expanded server.

Return Values:

    Returns true if successful.

--*/

{
    TV_ITEM tvItem;

    BOOL bIsRefreshed = FALSE;

    VARIANT va;
    VariantInit(&va);

    tvItem.hItem = hParent;
    tvItem.mask  = LVIF_PARAM;

    VERIFY(m_serverTree.GetItem(&tvItem));

    CServer* pServer = (CServer*)tvItem.lParam;
    VALIDATE_OBJECT(pServer, CServer);

    CServices* pServices = (CServices*)MKOBJ(pServer->GetServices(va));

    if (pServices)
    {
        TV_EXPANDED_INFO tvExpandedInfo;

        if (::TvRefreshObArray(&m_serverTree, hParent, pServices->m_pObArray, &tvExpandedInfo))
        {
            ASSERT(!tvExpandedInfo.nExpandedItems);
            ASSERT(!tvExpandedInfo.pExpandedItems);

            bIsRefreshed = TRUE;    // should be no expanded items...
        }

        pServices->InternalRelease();    // release now...
    }

    if (bIsRefreshed)
    {
        TV_SORTCB tvSortCB;

        tvSortCB.hParent     = hParent;
        tvSortCB.lpfnCompare = CompareServices;
        tvSortCB.lParam      = 0L;  // ignored...

        m_serverTree.SortChildrenCB(&tvSortCB);
    }
    else
    {
        theApp.DisplayLastStatus();
    }

    return bIsRefreshed;
}


BOOL CLlsmgrView::RefreshUserList()

/*++

Routine Description:

    Refreshs user list control.

Arguments:

    None.

Return Values:

    Returns true if users successfully updated.

--*/

{
    CUsers* pUsers;

    if (pUsers = GetDocument()->GetUsers())
    {
        return ::LvRefreshObArray(
                    &m_userList,
                    &g_userColumnInfo,
                    pUsers->m_pObArray
                    );
    }

    return FALSE;
}


void CLlsmgrView::SaveSettings()

/*++

Routine Description:

    Save settings to registry.

Arguments:

    None.

Return Values:

    None.

--*/

{
    long Status;
    HKEY hKeyLlsmgr;

    DWORD dwDisposition;

    Status = RegCreateKeyEx(
                HKEY_CURRENT_USER,
                szRegKeyLlsmgr,
                0,
                NULL,
                REG_OPTION_NON_VOLATILE,
                KEY_ALL_ACCESS,
                NULL,
                &hKeyLlsmgr,
                &dwDisposition
                );

    if (Status == ERROR_SUCCESS)
    {
        //
        // Save settings on exit
        //

        RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrSaveSettings, 0, REG_DWORD, (LPBYTE)&m_bSaveSettings, sizeof(DWORD));

        if (m_bSaveSettings)
        {
            //
            // Save font information
            //

            long lValue;

            lValue = (m_lFont.lfHeight < 0) ? -m_lFont.lfHeight : 0;
            RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontHeight, 0, REG_DWORD, (LPBYTE)&lValue, sizeof(DWORD));

            lValue = (m_lFont.lfWeight > 0) ?  m_lFont.lfWeight : 0;
            RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontWeight, 0, REG_DWORD, (LPBYTE)&lValue, sizeof(DWORD));

            lValue = (m_lFont.lfItalic > 0) ? TRUE : FALSE;
            RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontItalic, 0, REG_DWORD, (LPBYTE)&lValue, sizeof(DWORD));

            RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontFaceName, 0, REG_SZ, (LPBYTE)m_lFont.lfFaceName, (lstrlen(m_lFont.lfFaceName) + 1) * sizeof(TCHAR));

            lValue = (LONG)m_lFont.lfCharSet;
            ::RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrFontCharset, 0, REG_DWORD, (LPBYTE)&lValue, sizeof(DWORD));

            //
            // MRU domain list
            //

            TCHAR  szValue[512];
            LPTSTR pszValue = szValue;

            DWORD  cbValue  = 2 * sizeof(TCHAR);    // terminators

            CString strDomain;
            UINT    cchDomain;

            POSITION position;
            position = m_mruDomainList.GetTailPosition();

            while (position)
            {
                strDomain = m_mruDomainList.GetPrev(position);
                cchDomain = strDomain.GetLength() + 1;

                lstrcpyn(pszValue, strDomain, cchDomain);

                pszValue += cchDomain;
                cbValue  += cchDomain * sizeof(TCHAR);
            }

            *pszValue     = _T('\0');
            *(pszValue+1) = _T('\0');

            RegSetValueEx(hKeyLlsmgr, szRegKeyLlsmgrMruList, 0, REG_MULTI_SZ, (LPBYTE)szValue, cbValue);
        }

        RegCloseKey(hKeyLlsmgr);
    }
}


void CLlsmgrView::ViewProductProperties()

/*++

Routine Description:

    View properties of selected product.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CProduct* pProduct;

    if (pProduct = (CProduct*)::LvGetSelObj(&m_productList))
    {
        VALIDATE_OBJECT(pProduct, CProduct);

        CString strTitle;
        AfxFormatString1(strTitle, IDS_PROPERTIES_OF, pProduct->m_strName);

        CProductPropertySheet productProperties(strTitle);
        productProperties.InitPages(pProduct);
        productProperties.DoModal();

        OnUpdate(this, productProperties.m_fUpdateHint, NULL);
   }
}


void CLlsmgrView::ViewServerProperties()

/*++

Routine Description:

    View properties of selected server.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CObject* pObject;

    if (pObject = (CObject*)::TvGetSelObj(&m_serverTree))
    {
        CString strTitle;

        ASSERT_VALID(pObject);

        if (pObject->IsKindOf(RUNTIME_CLASS(CServer)))
        {
            CServer* pServer = (CServer*)pObject;
            AfxFormatString1(strTitle, IDS_PROPERTIES_OF, pServer->m_strName);

            CServerPropertySheet serverProperties(strTitle);
            serverProperties.InitPages(pServer);
            serverProperties.DoModal();

            OnUpdate(this, serverProperties.m_fUpdateHint, NULL);
        }
        else if (pObject->IsKindOf(RUNTIME_CLASS(CService)))
        {
            CService* pService = (CService*)pObject;

            CLicensingModeDialog lmodDlg;
            lmodDlg.InitDialog(pService);
            lmodDlg.DoModal();

            if (lmodDlg.m_fUpdateHint)
            {
                TV_ITEM tvItem;

                tvItem.mask = TVIF_IMAGE|TVIF_SELECTEDIMAGE;
                tvItem.hItem = m_serverTree.GetSelectedItem();
                tvItem.iImage = pService->IsPerServer() ? BMPI_PRODUCT_PER_SERVER : BMPI_PRODUCT_PER_SEAT;
                tvItem.iSelectedImage = tvItem.iImage;

                VERIFY(m_serverTree.SetItem(&tvItem));
                VERIFY(m_serverTree.Select(tvItem.hItem, TVGN_CARET));
            }

            OnUpdate(this, lmodDlg.m_fUpdateHint, NULL);
        }
    }
}


void CLlsmgrView::ViewUserProperties()

/*++

Routine Description:

    View properties of selected user.

Arguments:

    None.

Return Values:

    None.

--*/

{
    CUser* pUser;

    if (pUser = (CUser*)::LvGetSelObj(&m_userList))
    {
        VALIDATE_OBJECT(pUser, CUser);

        CString strTitle;
        AfxFormatString1(strTitle, IDS_PROPERTIES_OF, pUser->m_strName);

        CUserPropertySheet userProperties(strTitle);
        userProperties.InitPages(pUser);
        userProperties.DoModal();

        OnUpdate(this, userProperties.m_fUpdateHint, NULL);
   }

}


int CALLBACK CompareLicenses(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for LVM_SORTITEMS.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pLicense1 ((CLicense*)lParam1)
#define pLicense2 ((CLicense*)lParam2)

    VALIDATE_OBJECT(pLicense1, CLicense);
    VALIDATE_OBJECT(pLicense2, CLicense);

    int iResult;

    switch (g_licenseColumnInfo.nSortedItem)
    {
    case LVID_PURCHASE_HISTORY_DATE:
        iResult = pLicense1->m_lDate - pLicense2->m_lDate;
        break;

    case LVID_PURCHASE_HISTORY_PRODUCT:
        iResult = pLicense1->m_strProduct.CompareNoCase(pLicense2->m_strProduct);
        break;

    case LVID_PURCHASE_HISTORY_QUANTITY:
        iResult = pLicense1->m_lQuantity - pLicense2->m_lQuantity;
        break;

    case LVID_PURCHASE_HISTORY_ADMINISTRATOR:
        iResult = pLicense1->m_strUser.CompareNoCase(pLicense2->m_strUser);
        break;

    case LVID_PURCHASE_HISTORY_COMMENT:
        iResult = pLicense1->m_strDescription.CompareNoCase(pLicense2->m_strDescription);
        break;

    default:
        iResult = 0;
        break;
    }

    return g_licenseColumnInfo.bSortOrder ? -iResult : iResult;
}


int CALLBACK CompareProducts(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for LVM_SORTITEMS.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pProduct1 ((CProduct*)lParam1)
#define pProduct2 ((CProduct*)lParam2)

    VALIDATE_OBJECT(pProduct1, CProduct);
    VALIDATE_OBJECT(pProduct2, CProduct);

    int iResult;

    switch (g_productColumnInfo.nSortedItem)
    {
    case LVID_PRODUCTS_VIEW_NAME:
        iResult = pProduct1->m_strName.CompareNoCase(pProduct2->m_strName);
        break;

    case LVID_PRODUCTS_VIEW_PER_SEAT_CONSUMED:
        iResult = pProduct1->m_lInUse - pProduct2->m_lInUse;
        break;

    case LVID_PRODUCTS_VIEW_PER_SEAT_PURCHASED:
        iResult = pProduct1->m_lLimit - pProduct2->m_lLimit;
        break;

    case LVID_PRODUCTS_VIEW_PER_SERVER_PURCHASED:
        iResult = pProduct1->m_lConcurrent - pProduct2->m_lConcurrent;
        break;

    case LVID_PRODUCTS_VIEW_PER_SERVER_REACHED:
        iResult = pProduct1->m_lHighMark - pProduct2->m_lHighMark;
        break;

    default:
        iResult = 0;
        break;
    }

    return g_productColumnInfo.bSortOrder ? -iResult : iResult;
}


int CALLBACK CompareUsers(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for LVM_SORTITEMS.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pUser1 ((CUser*)lParam1)
#define pUser2 ((CUser*)lParam2)

    VALIDATE_OBJECT(pUser1, CUser);
    VALIDATE_OBJECT(pUser2, CUser);

    int iResult;

    switch (g_userColumnInfo.nSortedItem)
    {
    case LVID_PER_SEAT_CLIENTS_NAME:
        iResult = pUser1->m_strName.CompareNoCase(pUser2->m_strName);
        break;

    case LVID_PER_SEAT_CLIENTS_LICENSED_USAGE:
        iResult = pUser1->m_lInUse - pUser2->m_lInUse;
        break;

    case LVID_PER_SEAT_CLIENTS_UNLICENSED_USAGE:
        iResult = pUser1->m_lUnlicensed - pUser2->m_lUnlicensed;
        break;

    case LVID_PER_SEAT_CLIENTS_SERVER_PRODUCTS:
        iResult = pUser1->m_strProducts.CompareNoCase(pUser2->m_strProducts);
        break;

    default:
        iResult = 0;
        break;
    }

    return g_userColumnInfo.bSortOrder ? -iResult : iResult;
}


int CALLBACK CompareDomains(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for TVM_SORTCHILDRENCB.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pDomain1 ((CDomain*)lParam1)
#define pDomain2 ((CDomain*)lParam2)

    VALIDATE_OBJECT(pDomain1, CDomain);
    VALIDATE_OBJECT(pDomain2, CDomain);

    return pDomain1->m_strName.CompareNoCase(pDomain2->m_strName);
}


int CALLBACK CompareServers(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for TVM_SORTCHILDRENCB.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pServer1 ((CServer*)lParam1)
#define pServer2 ((CServer*)lParam2)

    VALIDATE_OBJECT(pServer1, CServer);
    VALIDATE_OBJECT(pServer2, CServer);

    return pServer1->m_strName.CompareNoCase(pServer2->m_strName);
}


int CALLBACK CompareServices(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)

/*++

Routine Description:

    Notification handler for TVM_SORTCHILDRENCB.

Arguments:

    lParam1 - object to sort.
    lParam2 - object to sort.
    lParamSort - sort criteria.

Return Values:

    Same as lstrcmp.

--*/

{
#define pService1 ((CService*)lParam1)
#define pService2 ((CService*)lParam2)

    VALIDATE_OBJECT(pService1, CService);
    VALIDATE_OBJECT(pService2, CService);

    return pService1->m_strName.CompareNoCase(pService2->m_strName);
}