windows-server-2003/termsrv/license/licmgr/ltview.cpp

//Copyright (c) 1998 - 1999 Microsoft Corporation
/*++
  
Module Name:

    LtView.cpp

Abstract:
    
    This Module contains the implementation of CLicMgrLeftView class
    (The View class used for the Left pane of the splitter)

Author:

    Arathi Kundapur (v-akunda) 11-Feb-1998

Revision History:

--*/
#include "stdafx.h"
#include "LicMgr.h"
#include "defines.h"
#include "LSMgrDoc.h"
#include "LtView.h"
#include "TreeNode.h"
#include "LSServer.h"
#include "mainfrm.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView

IMPLEMENT_DYNCREATE(CLicMgrLeftView, CTreeView)

BEGIN_MESSAGE_MAP(CLicMgrLeftView, CTreeView)
    //{{AFX_MSG_MAP(CLicMgrLeftView)
    ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelchanged)
    ON_NOTIFY_REFLECT(TVN_ITEMEXPANDING, OnItemexpanding)
    ON_NOTIFY_REFLECT(TVN_KEYDOWN, OnKeydown)
    ON_NOTIFY_REFLECT(NM_RCLICK , OnRightClick )
    ON_NOTIFY_REFLECT(NM_CLICK , OnLeftClick )
    ON_WM_DESTROY()
    //}}AFX_MSG_MAP
    // Standard printing commands
    ON_COMMAND(ID_FILE_PRINT, CTreeView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_DIRECT, CTreeView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW, CTreeView::OnFilePrintPreview)
    ON_MESSAGE(WM_ADD_SERVER, OnAddServer)
    ON_MESSAGE(WM_DELETE_SERVER, OnDeleteServer)
    ON_MESSAGE(WM_UPDATE_SERVER, OnUpdateServer)
    ON_MESSAGE(WM_ADD_ALL_SERVERS, OnAddAllServers)
    
    // all server menus
    ON_WM_CONTEXTMENU( )

    ON_COMMAND( ID_ALLSVR_CONNECT , OnServerConnect )
    ON_COMMAND( ID_ALLSVR_REFRESHALL , OnRefreshAllServers )
    ON_COMMAND( ID_ALLSVR_HELP , OnGeneralHelp )
    
    // server menuitems

    // ON_COMMAND( ID_LPK_CONNECT , OnServerConnect )
    ON_COMMAND( ID_LPK_REFRESH , OnRefreshServer )
    ON_COMMAND( ID_LPK_REFRESHALL , OnRefreshAllServers )    
    ON_COMMAND( ID_LPK_DOWNLOADLICENSES , OnDownloadKeepPack )

    ON_COMMAND( ID_SVR_ACTIVATESERVER , OnRegisterServer )
    ON_COMMAND( ID_LPK_ADVANCED_REPEATLASTDOWNLOAD , OnRepeatLastDownload )
    ON_COMMAND( ID_LPK_ADVANCED_REACTIVATESERVER , OnReactivateServer )
    ON_COMMAND( ID_LPK_ADVANCED_DEACTIVATESERVER , OnDeactivateServer )    
    ON_COMMAND( ID_LPK_PROPERTIES , OnServerProperties )
    ON_COMMAND( ID_LPK_HELP , OnGeneralHelp )

    // license pak items

    // ON_COMMAND( ID_LICPAK_CONNECT , OnServerConnect )
    ON_COMMAND( ID_LICPAK_REFRESH , OnRefreshServer )
    // ON_COMMAND( ID_LICPAK_REFRESHALL , OnRefreshAllServers )
    ON_COMMAND( ID_LICPAK_DOWNLOADLICENSES , OnDownloadKeepPack )
    ON_COMMAND( ID_LICPAK_REPEATDOWNLOAD , OnRepeatLastDownload )
    ON_COMMAND( ID_LICPAK_HELP , OnGeneralHelp )    


    
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView construction/destruction

CLicMgrLeftView::CLicMgrLeftView()
{
    // TODO: add construction code here
   
    m_ht = ( HTREEITEM )NULL;
}

CLicMgrLeftView::~CLicMgrLeftView()
{
 }

BOOL CLicMgrLeftView::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Modify the Window class or styles here by modifying
    //  the CREATESTRUCT cs

    return CTreeView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView drawing

void CLicMgrLeftView::OnDraw(CDC* pDC)
{
    CLicMgrDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);

    // TODO: add draw code for native data here
}

void CLicMgrLeftView::OnInitialUpdate()
{
    CTreeView::OnInitialUpdate();
    GetTreeCtrl().ModifyStyle(0,TVS_HASLINES|TVS_LINESATROOT|TVS_HASBUTTONS|TVS_SHOWSELALWAYS);
    BuildImageList();
       
    // TODO: You may populate your TreeView with items by directly accessing
    //  its tree control through a call to GetTreeCtrl().
}

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView printing

BOOL CLicMgrLeftView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}

void CLicMgrLeftView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
    // TODO: add extra initialization before printing
}

void CLicMgrLeftView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
    // TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView diagnostics

#ifdef _DEBUG
void CLicMgrLeftView::AssertValid() const
{
    CTreeView::AssertValid();
}

void CLicMgrLeftView::Dump(CDumpContext& dc) const
{
    CTreeView::Dump(dc);
}

CLicMgrDoc* CLicMgrLeftView::GetDocument() // non-debug version is inline
{
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CLicMgrDoc)));
    return (CLicMgrDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CLicMgrLeftView message handlers

HTREEITEM CLicMgrLeftView::AddItemToTree(HTREEITEM hParent, CString Text, HTREEITEM hInsAfter, int iImage, LPARAM lParam)
{
    HTREEITEM hItem = NULL;
    TV_ITEM tvItem = {0};
    TV_INSERTSTRUCT tvInsert;

    ASSERT(lParam);
    if(NULL == lParam)
        return hItem;

    tvItem.mask           = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
    tvItem.pszText        = Text.GetBuffer(Text.GetLength());
    tvItem.cchTextMax     = Text.GetLength();
    tvItem.iImage         = iImage;
    tvItem.iSelectedImage = iImage;
    tvItem.lParam          = lParam;

    tvInsert.item         = tvItem;
    tvInsert.hInsertAfter = hInsAfter;
    tvInsert.hParent      = hParent;

    hItem = GetTreeCtrl().InsertItem(&tvInsert);

   // GetTreeCtrl().Expand(GetTreeCtrl().GetRootItem(), TVE_EXPAND);
    return hItem;


}

LRESULT CLicMgrLeftView::OnAddServer(WPARAM wParam, LPARAM lParam)
{   
    LRESULT lResult = 0;
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return lResult;
    CLicServer *pServer = (CLicServer*)lParam;
    ASSERT(pServer);
    if(NULL == pServer)
        return lResult;

    HTREEITEM hServer = NULL;
    HTREEITEM hItem = NULL;
    CTreeNode* pNode = NULL;

    HTREEITEM hRoot = GetTreeCtrl().GetRootItem();
    if(!hRoot)
        goto cleanup;

    // First make sure the server isn't already in the tree
    // Get the first server under the domain
    hItem = GetTreeCtrl().GetNextItem(hRoot, TVGN_CHILD);
    while(hItem) {
        // Get the data attached to the tree item
        CTreeNode *node = (CTreeNode*)GetTreeCtrl().GetItemData(hItem);
        if(node) {
            // Is this the server we want to add
            CLicServer *pServer = (CLicServer*)node->GetTreeObject();
            if(pServer == (CLicServer*)lParam) return 0;
        }
        hItem = GetTreeCtrl().GetNextItem(hItem, TVGN_NEXT);
    }

    // Add the server to the tree
    // Create a CTreeNode object with info about this tree node
    pNode = new CTreeNode(NODE_SERVER, pServer);
    if(pNode) 
    {
        int iImage = 0;

        if( pServer->GetServerType()  == SERVER_TS5_ENFORCED )
        {
            DWORD dwStatus = pServer->GetServerRegistrationStatus();
        
            if( dwStatus == LSERVERSTATUS_REGISTER_INTERNET || dwStatus == LSERVERSTATUS_REGISTER_OTHER )
            {
                iImage = 3;
            }
            else if( dwStatus == LSERVERSTATUS_WAITFORPIN )
            { 
                iImage = 4;
            }
            else if( dwStatus == LSERVERSTATUS_UNREGISTER ) 
            {
                iImage = 5;
            }
            else
            {
                iImage = 6;
            }
        }
        
        hServer = AddItemToTree(hRoot, pServer->GetDisplayName(), TVI_SORT,  iImage , (LPARAM)pNode);
        if(!hServer) delete pNode;
        // The server wants to know his tree item handle
        pServer->SetTreeItem(hServer);
    }

cleanup:
    return lResult;                                                                  
                                                                               
} // OnAddServer


LRESULT CLicMgrLeftView::OnAddKeyPack(WPARAM wParam, LPARAM lParam)
{   
    LRESULT lResult = 0;
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return lResult;

    CLicServer *pServer = (CLicServer*)wParam;
    ASSERT(pServer);
    if(NULL == pServer)
        return lResult;

    CKeyPack *pKeyPack = (CKeyPack*)lParam;
    ASSERT(pKeyPack);
    if(NULL == pKeyPack)
        return lResult;

    HTREEITEM hKeyPackItem = NULL;
    TV_ITEM Item;
    memset((void *)&Item,0,sizeof(Item));

    Item.mask = TVIF_HANDLE;
    HTREEITEM hServer = pServer->GetTreeItem();
    if(NULL == hServer)
        return lResult;
    Item.hItem = hServer;



    if(FALSE == GetTreeCtrl().GetItem(&Item))
        return lResult;

    if(Item.state & TVIS_EXPANDED)
    {
        CTreeNode *pNode = new CTreeNode(NODE_KEYPACK, pKeyPack);
        if(pNode)
        {
            hKeyPackItem = AddItemToTree(hServer, (LPCTSTR)pKeyPack->GetDisplayName(), hServer, 2, (LPARAM)pNode);
            if(!hKeyPackItem)
                delete pNode;
        }
        pKeyPack->SetTreeItem(hKeyPackItem);
    }
    
    return lResult;                                                                  
                                                                               
} // OnAddKeyPack




LRESULT CLicMgrLeftView::OnAddAllServers(WPARAM wParam, LPARAM lParam)
{   
    LRESULT lResult = 0;
    HTREEITEM hItem = NULL;
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return lResult;
    CTreeNode* pNode = NULL;
    CAllServers *pAllServer = (CAllServers*)lParam;
    if(!pAllServer) 
        goto cleanup ;
   
    hItem = pAllServer->GetTreeItem();
    if(NULL != hItem)
        goto cleanup;

       
    // Create a CTreeNode object with info about this tree node
    pNode = new CTreeNode(NODE_ALL_SERVERS, pAllServer);
    if(pNode) 
    {
        HTREEITEM hAllServers = AddItemToTree(NULL, pAllServer->GetName(), TVI_SORT,0 , (LPARAM)pNode);
        if(!hAllServers) delete pNode;
        // The server wants to know his tree item handle
        pAllServer->SetTreeItem(hAllServers);
        //Set the Selection to this item
        GetTreeCtrl().SelectItem(hAllServers);
    }

    
    GetTreeCtrl().Expand(GetTreeCtrl().GetRootItem(), TVE_EXPAND);
cleanup:
    return lResult ;                                                                  
                                                                               
} // OnAddAllServers


void CLicMgrLeftView::AddServerKeyPacks(CLicServer *pServer)
{
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return;
    POSITION pos;
    KeyPackList *pKeyPackList = NULL;
    HTREEITEM hLastNode = NULL;

   ASSERT(pServer);
   if(NULL == pServer)
      return;
   HTREEITEM hServer = pServer->GetTreeItem();
   if(NULL == hServer)
       goto cleanup;          //Server Not in the Tree.

   hLastNode= hServer;

   // Get a pointer to the server's list of installed KeyPacks
   pKeyPackList = pServer->GetKeyPackList();
   // Iterate through the KeyPack list
   pos = pKeyPackList->GetHeadPosition();
   while(pos)
   {
        CKeyPack *pKeyPack = (CKeyPack *)pKeyPackList->GetNext(pos);
        CTreeNode *pNode = new CTreeNode(NODE_KEYPACK, pKeyPack);
        if(pNode)
        {
            hLastNode = AddItemToTree(hServer, (LPCTSTR)pKeyPack->GetDisplayName(), hLastNode, 2, (LPARAM)pNode);
            if(!hLastNode)
                delete pNode;
        }
        pKeyPack->SetTreeItem(hLastNode);
   }
cleanup:
   return;

}  // end AddKeyPacks

void CLicMgrLeftView::BuildImageList()
{
    m_ImageList.Create(16, 16, TRUE, 18, 0);
    AddIconToImageList(IDI_ALL_SERVERS);
    AddIconToImageList(IDI_SERVER);
    AddIconToImageList(IDI_KEYPACK);
    AddIconToImageList(IDI_SERVERREG );
    AddIconToImageList(IDI_SERVERM );
    AddIconToImageList(IDI_SERVERX );
    AddIconToImageList(IDI_SERVERQ );

    GetTreeCtrl().SetImageList(&m_ImageList, TVSIL_NORMAL);

}  // end BuildImageList

int CLicMgrLeftView::AddIconToImageList(int iconID)
{
    HICON hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(iconID));
       return m_ImageList.Add(hIcon);
   

}  

void CLicMgrLeftView::OnSelchanged(NMHDR* pNMHDR, LRESULT* pResult) 
{
    NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
    // TODO: Add your control notification handler code here

    //Check if the node selected is All-Servers,Server or the KeyPack.
    //Accordingly change the right pane view.
    CTreeCtrl& TreeCtrl = GetTreeCtrl();
    HTREEITEM hCurr = TreeCtrl.GetSelectedItem();
    if(NULL == hCurr)
    {
        return;
    }
    CTreeNode *pNode = (CTreeNode *)GetTreeCtrl().GetItemData(hCurr);
    if(NULL == pNode)
    {
        return;
    }
    CLicServer *pLicServer = NULL;
    CKeyPack * pKeyPack = NULL;

    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return;

    switch(pNode->GetNodeType())
    {
        case NODE_ALL_SERVERS:
            AfxGetMainWnd()->SendMessage(WM_SEL_CHANGE,NODE_ALL_SERVERS,NULL);
            break;
        case NODE_SERVER:
            pLicServer = (CLicServer *)pNode->GetTreeObject();
            if(NULL == pLicServer)
                break;
            if(FALSE == pLicServer->IsExpanded())
            {
                SetCursor(LoadCursor(NULL,IDC_WAIT));
                HRESULT hResult = pDoc->EnumerateKeyPacks(pLicServer,LSKEYPACK_SEARCH_LANGID, TRUE);
                if(hResult != S_OK)
                {
                    ((CMainFrame *)AfxGetMainWnd())->EnumFailed(hResult,pLicServer);
                    if(pLicServer && pLicServer->GetTreeItem())
                    {
                        TreeCtrl.SelectItem(TreeCtrl.GetParentItem(pLicServer->GetTreeItem()));
                    }
                    break;
                }
                AddServerKeyPacks(pLicServer);
               
            }
            else
            {
                if(!pLicServer->GetKeyPackList()->IsEmpty())
                {
                    if(!TreeCtrl.ItemHasChildren(hCurr))
                        AddServerKeyPacks(pLicServer);
                }

            }
            AfxGetMainWnd()->SendMessage(WM_SEL_CHANGE,NODE_SERVER,(LPARAM)pLicServer);
            break;
        case NODE_KEYPACK:
            pKeyPack = (CKeyPack *)pNode->GetTreeObject();
            ASSERT(pKeyPack);
            if(NULL == pKeyPack)
                break;
            if(FALSE == pKeyPack->IsExpanded())
            {
                SetCursor(LoadCursor(NULL,IDC_WAIT));
                HRESULT hResult = pDoc->EnumerateLicenses(pKeyPack,LSLICENSE_SEARCH_KEYPACKID, TRUE);
                if(hResult != S_OK)
                {
                    ((CMainFrame *)AfxGetMainWnd())->EnumFailed(hResult,pKeyPack->GetServer());
                    if(pKeyPack && pKeyPack->GetTreeItem())
                    {
                        TreeCtrl.SelectItem(TreeCtrl.GetParentItem(pKeyPack->GetTreeItem()));
                    }
                    break;
                }
                          
            }
            AfxGetMainWnd()->SendMessage(WM_SEL_CHANGE,NODE_KEYPACK,(LPARAM)pNode->GetTreeObject());
            break;
    }
    *pResult = 0;
}

void CLicMgrLeftView::OnItemexpanding(NMHDR* pNMHDR, LRESULT* pResult) 
{
    NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
    // TODO: Add your control notification handler code here
    
    *pResult = 0;
}

void CLicMgrLeftView::OnDestroy() 
{
    //Get the Root Item
    HTREEITEM hRoot = GetTreeCtrl().GetRootItem();
    if(!hRoot)
        return;
    HTREEITEM hServerItem = GetTreeCtrl().GetNextItem(hRoot,TVGN_CHILD);
    while(hServerItem)
    {
        // Get the data attached to the tree item 
        CTreeNode *pServerNode = (CTreeNode*)GetTreeCtrl().GetItemData(hServerItem);
        if(pServerNode)
        {
            // Is this the server we want to add
            HTREEITEM hKeyPackItem = GetTreeCtrl().GetNextItem(hServerItem,TVGN_CHILD);
            while(hKeyPackItem)
            {
                CTreeNode *pKeyPackNode = (CTreeNode*)GetTreeCtrl().GetItemData(hKeyPackItem);
                if(pKeyPackNode)
                    delete pKeyPackNode;
                hKeyPackItem = GetTreeCtrl().GetNextItem(hKeyPackItem,TVGN_NEXT);
            }
            delete pServerNode;
           
        }
        hServerItem = GetTreeCtrl().GetNextItem(hServerItem, TVGN_NEXT);
    }
    CTreeNode * pRootNode = (CTreeNode*)GetTreeCtrl().GetItemData(hRoot);
    if(pRootNode)
        delete pRootNode;

    return;
}

LRESULT CLicMgrLeftView::OnDeleteServer(WPARAM wParam, LPARAM lParam)
{   
    
    LRESULT lResult = 0;
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return lResult;
    CLicServer *pServer = (CLicServer*)lParam;
    ASSERT(pServer);
    if(NULL == pServer)
        return lResult;

   
    HTREEITEM hServer = pServer->GetTreeItem();

    DBGMSG( L"CLicMgrLeftView_OnDeleteServer GetTreeItem ret 0x%x\n" , hServer );

    if(hServer == NULL)
        return lResult;

    CTreeNode *pNode = (CTreeNode*)GetTreeCtrl().GetItemData(hServer);

    DBGMSG( L"CLicMgrLeftView_OnDeleteServer GetItemData ret 0x%x\n" , pNode );
    
    if(pNode)
        delete pNode;   

    GetTreeCtrl().DeleteItem(hServer);    
    

    return lResult;                                                                  
                                                                               
} // OnDeleteServer

LRESULT CLicMgrLeftView::OnUpdateServer(WPARAM wParam, LPARAM lParam)
{   
    
    LRESULT lResult = 0;
    CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
    ASSERT(pDoc);
    if(NULL == pDoc)
        return lResult;

    BOOL bIsExpanded = FALSE;
    BOOL bIsSelected = FALSE;
    BOOL bIsChild = FALSE;
    HTREEITEM hSelectedItem = NULL;
    CKeyPack * pSelectedPack = NULL;

    CLicServer *pServer = (CLicServer*)lParam;
    ASSERT(pServer);
    if(NULL == pServer)
        return lResult;

   
    HTREEITEM hServer = pServer->GetTreeItem();
    if(hServer == NULL)
        return lResult;

    // check to see if we need to remove any keypacks
    // Get a pointer to the server's list of installed KeyPacks
    // Get the data attached to the tree item 
    CTreeNode *pServerNode = (CTreeNode*)GetTreeCtrl().GetItemData(hServer);

    if( pServerNode != NULL )
    {        
        HTREEITEM hKeyPackItem = GetTreeCtrl().GetNextItem(hServer,TVGN_CHILD);
        while( hKeyPackItem != NULL )
        {
            CTreeNode *pKeyPackNode = (CTreeNode*)GetTreeCtrl().GetItemData(hKeyPackItem);

            if( pKeyPackNode != NULL )
            {
                DBGMSG( L"CLicMgrLeftView!OnUpdateServer removing a licpak\n" , 0 );
                delete pKeyPackNode;
            }

            hKeyPackItem = GetTreeCtrl().GetNextItem(hKeyPackItem,TVGN_NEXT);
        }

        delete pServerNode;
    }

    TV_ITEM Item;
    memset((void *)&Item,0,sizeof(Item));

    Item.mask = TVIF_HANDLE | TVIF_STATE;
    Item.hItem = hServer;

    if(FALSE == GetTreeCtrl().GetItem(&Item))
        return lResult;

    if(Item.state & TVIS_EXPANDED)
        bIsExpanded = TRUE;

    if(Item.state & TVIS_SELECTED)
        bIsSelected = TRUE;
    else
        hSelectedItem = GetTreeCtrl().GetSelectedItem();
    if(hSelectedItem)
    {
        if(hServer == GetTreeCtrl().GetParentItem(hSelectedItem))
        {
            CString ProdDesc = GetTreeCtrl().GetItemText(hSelectedItem);
            KeyPackList * pkeyPackList = pServer->GetKeyPackList();
            POSITION pos = pkeyPackList->GetHeadPosition();
            while(pos)
            {
                CKeyPack * pKeyPack = (CKeyPack *)pkeyPackList->GetNext(pos);
                if(NULL == pKeyPack)
                {
                   continue;
                }
                LSKeyPack sKeyPack = pKeyPack->GetKeyPackStruct();
        
                if(0 == ProdDesc.CompareNoCase(sKeyPack.szProductDesc))
                {
                   pSelectedPack = pKeyPack;
                   break;
                }
            }
           bIsChild = TRUE;
        }
    }

    GetTreeCtrl().DeleteItem(hServer);
    SendMessage(WM_ADD_SERVER,0,(LPARAM)pServer);
    AddServerKeyPacks(pServer);

    hServer = pServer->GetTreeItem();

    if(bIsExpanded)
        GetTreeCtrl().Expand(hServer, TVE_EXPAND);
    if(bIsSelected)
        GetTreeCtrl().SelectItem(hServer);
    else
    {
        //Not good, find an alternative for this....
        if(bIsChild)
        {
            if(pSelectedPack)
                GetTreeCtrl().SelectItem(pSelectedPack->GetTreeItem());
            else
            {
                hSelectedItem = GetTreeCtrl().GetChildItem(hServer);
                if(hSelectedItem)
                    GetTreeCtrl().SelectItem(hSelectedItem);
            }            
        }
    }

    return lResult;                                                                  
                                                                               
} // OnUpdateServer






void CLicMgrLeftView::SetSelection(LPARAM lParam,NODETYPE NodeType)
{
    if(NULL == lParam)
        return;
   
    HTREEITEM hItem = NULL;


    if(NODE_ALL_SERVERS == NodeType)
        hItem = ((CAllServers *)lParam)->GetTreeItem();
    else if(NODE_SERVER == NodeType)
        hItem = ((CLicServer *)lParam)->GetTreeItem();
    else if(NODE_KEYPACK == NodeType)
        hItem = ((CKeyPack *)lParam)->GetTreeItem();

    if(hItem)
            GetTreeCtrl().SelectItem(hItem);

    return;

}

void CLicMgrLeftView::OnKeydown(NMHDR* pNMHDR, LRESULT* pResult) 
{
    LV_KEYDOWN* pLVKeyDown = (LV_KEYDOWN*)pNMHDR;
    // TODO: Add your control notification handler code here
    if(pLVKeyDown->wVKey == VK_TAB)
    {
        CMainFrame * pMainFrame  = ((CMainFrame *)AfxGetMainWnd());
        pMainFrame->SelectView(LISTVIEW);
    }

    
    *pResult = 0;
}


//-----------------------------------------------------------------------------------------
afx_msg void CLicMgrLeftView::OnLeftClick(NMHDR* pNMHDR, LRESULT* pResult)
{
    CPoint pt;
    
    GetCursorPos( &pt );

    ScreenToClient( &pt );

    DBGMSG( L"LICMGR@CLicMgrLeftView::OnLeftClick\n" , 0 );

    HTREEITEM hTreeItem = GetTreeCtrl( ).GetSelectedItem( ); //GetTreeCtrl().HitTest( pt , &flag ); 

    if( hTreeItem != NULL )
    { 
        CTreeNode *pNode = (CTreeNode *)GetTreeCtrl().GetItemData(hTreeItem);       
        
        if(NULL == pNode)
        {
            return;
        }

        ClientToScreen( &pt );

        NODETYPE nt = pNode->GetNodeType();

        if(NODE_SERVER == nt )
        {
            DBGMSG( L"\tServer Node selected\n", 0  );

            SetActiveServer( static_cast< CLicServer * >( pNode->GetTreeObject() ) );

        }
        else if( nt == NODE_KEYPACK )
        {
            CKeyPack *pKeyPack = static_cast< CKeyPack *>( pNode->GetTreeObject() );

            if( pKeyPack != NULL )
            {
                SetActiveServer( pKeyPack->GetServer( ) );
            }
        }        
        else
        {
#ifdef DBG
            if( NODE_ALL_SERVERS == nt )
            {
                DBGMSG( L"\tAll servers selected\n" , 0 );    
            }
#endif
            
            SetActiveServer( NULL );
        }
    }
    else
    {
        DBGMSG( L"\tTreeview item returned NULL\n" , 0 );

        SetActiveServer( NULL );
    }


}

//-----------------------------------------------------------------------------------------
afx_msg void CLicMgrLeftView::OnContextMenu( CWnd* pWnd, CPoint pt )
{
    CMenu menu;

    CMenu *pContextmenu = NULL;
        
    DBGMSG( L"LICMGR@CLicMgrLeftView::OnContextMenu\n" , 0 );
        
    DBGMSG( L"\tpoint x = %d " , pt.x );
    
    DBGMSG( L"y = %d\n" , pt.y );

    UINT flag;    

    HTREEITEM hTreeItem;
    
    CTreeCtrl& treectrl = GetTreeCtrl();

    // maybe keyboard selected this item

    if(pt.x == -1 && pt.y == -1)
    {   
        hTreeItem = treectrl.GetSelectedItem( );

        if( hTreeItem != NULL )
        {
            RECT rect;

            treectrl.GetItemRect( hTreeItem , &rect , FALSE );

		    pt.x = rect.left + (rect.right - rect.left)/2;
		    
            pt.y = rect.top + (rect.bottom - rect.top)/2;
	   }
    }
    else
    {
        // otherwise we're invoked by the mouse
        ScreenToClient( &pt );

        hTreeItem = treectrl.HitTest( pt , &flag );
    }

    if( hTreeItem != NULL )
    { 
        CTreeNode *pNode = (CTreeNode *)GetTreeCtrl().GetItemData(hTreeItem);
        
        if(NULL == pNode)
        {
            return;
        }

        SetRightClickedItem( hTreeItem );

        ClientToScreen( &pt );

        // GetTreeCtrl().SelectItem( hTreeItem );

        NODETYPE nt = pNode->GetNodeType();

        if(NODE_SERVER == nt )
        {
            DBGMSG( L"\tServer Node selected\n", 0  );
          
            menu.LoadMenu( IDR_MENU_LPK );

            pContextmenu = menu.GetSubMenu( 0 );
            
        }
        else if( NODE_KEYPACK == nt )
        {
            DBGMSG( L"\tLicense pack selected\n" , 0 );

            menu.LoadMenu( IDR_MENU_LPK );

            pContextmenu = menu.GetSubMenu( 1 );
         
        }
        else if( NODE_ALL_SERVERS == nt )
        {
            DBGMSG( L"\tAll servers selected\n" , 0 );
            
            menu.LoadMenu( IDR_MENU_LPK );

            pContextmenu = menu.GetSubMenu( 3 );
                     
        }
        else
        {
            DBGMSG( L"\tIn left pane no item selected\n" , 0 );

            return;
        }


        UI_initmenu( pContextmenu , nt );


        if( pContextmenu != NULL )
        {
            pContextmenu->TrackPopupMenu( TPM_LEFTALIGN , pt.x , pt.y , this );
        }

    }
    else
    {
        hTreeItem = GetTreeCtrl( ).GetSelectedItem( );

        SetRightClickedItem( hTreeItem );
    }

}


//-----------------------------------------------------------------------------------------
afx_msg void CLicMgrLeftView::OnRightClick(NMHDR* pNMHDR, LRESULT* pResult)
{
    CPoint pt;

    CMenu menu;

    CMenu *pContextmenu = NULL;

    GetCursorPos( &pt );

    OnContextMenu( NULL , pt );

    return;
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::UI_initmenu( CMenu *pMenu , NODETYPE nt )
{
    CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

    if( pMainFrame != NULL )
    {
        pMainFrame->UI_initmenu( pMenu , nt );
    }
   
}

//-----------------------------------------------------------------------------------------       
void CLicMgrLeftView::OnServerConnect( )
{
    CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

    if( pMainFrame != NULL )
    {
        pMainFrame->ConnectServer( );
    }

}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnRefreshAllServers( )
{
   CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

    if( pMainFrame != NULL )
    {
        pMainFrame->OnRefresh( );
    }
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnRefreshServer( )
{
   CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

   CLicServer *pServer = NULL;

    if( pMainFrame != NULL )
    {
        CTreeNode *pNode = (CTreeNode *)GetTreeCtrl().GetItemData( GetRightClickedItem() );

        if( pNode == NULL )
        {
            return;
        }

        if( pNode->GetNodeType() == NODE_SERVER )
        {
            pServer = static_cast< CLicServer * >( pNode->GetTreeObject() );
        }
        else if( pNode->GetNodeType() == NODE_KEYPACK )
        {
            CKeyPack *pKeyPack = static_cast< CKeyPack *>( pNode->GetTreeObject() );

            if( pKeyPack != NULL )
            {
                pServer = pKeyPack->GetServer( );
            }
        }

        if( pServer != NULL )
        {
            pMainFrame->RefreshServer( pServer );
        }        
    }

}
    
//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnDownloadKeepPack()
{
    BOOL bRefresh = FALSE;    

    DWORD dwStatus = WizardActionOnServer( WIZACTION_DOWNLOADLKP , &bRefresh );
    
    //This call to RefreshServer causes problems because it tries to use
    //a pointer to the selected node on the right side. Of course, the
    //focus is on the left so there's nothing selected on the right...
    //if( bRefresh )
    //{
        // need to review this

    //    OnRefreshServer( );
    //}
  
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnDownloadKeepPack StartWizard returned 0x%x\n" , dwStatus );
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnRegisterServer()
{
    BOOL bRefresh;

    DWORD dwStatus = WizardActionOnServer( WIZACTION_REGISTERLS , &bRefresh );
    
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnRegisterServer StartWizard returned 0x%x\n" , dwStatus );    
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnRepeatLastDownload()
{
    BOOL bRefresh;

    DWORD dwStatus = WizardActionOnServer( WIZACTION_DOWNLOADLASTLKP , &bRefresh );
    
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnRepeatLastDownload StartWizard returned 0x%x\n" , dwStatus );
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnReactivateServer( )
{
    BOOL bRefresh;

    DWORD dwStatus = WizardActionOnServer( WIZACTION_REREGISTERLS , &bRefresh );
    
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnReactivateServer StartWizard returned 0x%x\n" , dwStatus );
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnDeactivateServer( )
{
    BOOL bRefresh;

    DWORD dwStatus = WizardActionOnServer( WIZACTION_UNREGISTERLS , &bRefresh );
    
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnDeactivateServer StartWizard returned 0x%x\n" , dwStatus );    
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnServerProperties( )
{
    BOOL bRefresh;

    DWORD dwStatus = WizardActionOnServer( WIZACTION_SHOWPROPERTIES , &bRefresh );
    
    DBGMSG( L"LICMGR : CLicMgrLeftView::OnServerProperties StartWizard returned 0x%x\n" , dwStatus );    
    
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::OnGeneralHelp( )
{
    CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
    
    if( pMainFrame != NULL )
    {
        pMainFrame->OnHelp( );
    }
}

//-----------------------------------------------------------------------------------------
DWORD CLicMgrLeftView::WizardActionOnServer( WIZACTION wa , PBOOL pbRefresh )
{
    CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

    if( pMainFrame != NULL )
    {
        return pMainFrame->WizardActionOnServer( wa , pbRefresh , TREEVIEW );
    }

    return ERROR_INVALID_PARAMETER;
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::SetActiveServer( CLicServer *pServer )
{
    CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );

#ifdef DBG

    if( pServer != NULL )
    {
        DBGMSG( L"CLicMgrLeftView::SetActiveServer %s\n" , (LPCTSTR)pServer->GetName( ) );
    }

#endif

    if( pMainFrame != NULL )
    {
        pMainFrame->SetActiveServer( pServer );
    }
}

//-----------------------------------------------------------------------------------------
void CLicMgrLeftView::SetRightClickedItem( HTREEITEM ht )
{
    m_ht = ht;
    
    CTreeNode *pNode = (CTreeNode *)GetTreeCtrl().GetItemData(ht);       
    
    if(NULL == pNode)
    {
        SetActiveServer( NULL );

        return;
    }

    NODETYPE nt = pNode->GetNodeType();

    
    if(NODE_SERVER == nt )
    {    
        SetActiveServer( static_cast< CLicServer * >( pNode->GetTreeObject() ) );

    }
    else if( nt == NODE_KEYPACK )
    {
        CKeyPack *pKeyPack = static_cast< CKeyPack *>( pNode->GetTreeObject() );

        if( pKeyPack != NULL )
        {
            SetActiveServer( pKeyPack->GetServer( ) );
        }
    }
    else
    {
        SetActiveServer( NULL );
    }

}