1958 lines
52 KiB
C++
1958 lines
52 KiB
C++
//Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
/*++
|
|
|
|
Module Name:
|
|
|
|
RtList.cpp
|
|
|
|
Abstract:
|
|
|
|
This Module contains the implementation of CRightList class
|
|
(The View class used for the Right pane of the splitter)
|
|
|
|
Author:
|
|
|
|
Arathi Kundapur (v-akunda) 11-Feb-1998
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include "LicMgr.h"
|
|
#include "defines.h"
|
|
#include "LSServer.h"
|
|
#include "RtList.h"
|
|
#include "Mainfrm.h"
|
|
|
|
|
|
|
|
#include "LSmgrdoc.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
extern int GetStatusPosition( CLicense *pLic );
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRightList
|
|
|
|
IMPLEMENT_DYNCREATE(CRightList, CListView)
|
|
|
|
CRightList::CRightList()
|
|
{
|
|
|
|
}
|
|
|
|
CRightList::~CRightList()
|
|
{
|
|
m_ImageListLarge.DeleteImageList();
|
|
m_ImageListSmall.DeleteImageList();
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRightList, CListView)
|
|
//{{AFX_MSG_MAP(CRightList)
|
|
ON_MESSAGE(WM_SEL_CHANGE, OnSelChange)
|
|
ON_COMMAND(ID_LARGE_ICONS, OnLargeIcons)
|
|
ON_COMMAND(ID_SMALL_ICONS, OnSmallIcons)
|
|
ON_COMMAND(ID_LIST, OnList)
|
|
ON_COMMAND(ID_DETAILS, OnDetails)
|
|
ON_MESSAGE(WM_ADD_SERVER, OnAddServer)
|
|
ON_MESSAGE(WM_DELETE_SERVER, OnDeleteServer)
|
|
ON_MESSAGE(WM_UPDATE_SERVER, OnUpdateServer)
|
|
ON_MESSAGE(WM_ADD_KEYPACK, OnAddKeyPack)
|
|
ON_NOTIFY_REFLECT(NM_DBLCLK, OnDblclk)
|
|
ON_NOTIFY_REFLECT(LVN_KEYDOWN, OnKeydown)
|
|
ON_NOTIFY_REFLECT(LVN_COLUMNCLICK, OnColumnClick)
|
|
ON_NOTIFY_REFLECT(NM_CLICK , OnLeftClick )
|
|
|
|
|
|
// server menuitems
|
|
|
|
// all server menus
|
|
ON_WM_CONTEXTMENU()
|
|
// ON_COMMAND( ID_LPK_CONNECT , OnServerConnect )
|
|
ON_COMMAND( ID_LPK_REFRESHALL , OnRefreshAllServers )
|
|
|
|
// 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 )
|
|
|
|
|
|
|
|
// license pak items
|
|
|
|
// license items
|
|
|
|
/* removed from spec
|
|
|
|
ON_COMMAND( ID_LIC_CONNECT , OnServerConnect )
|
|
ON_COMMAND( ID_LIC_REFRESH , OnRefreshServer )
|
|
ON_COMMAND( ID_LIC_DOWNLOADLICENSES , OnDownloadKeepPack )
|
|
ON_COMMAND( ID_LIC_HELP , OnGeneralHelp )
|
|
|
|
*/
|
|
|
|
|
|
//}}AFX_MSG_MAP
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRightList drawing
|
|
|
|
void CRightList::OnDraw(CDC* pDC)
|
|
{
|
|
CDocument* pDoc = GetDocument();
|
|
// TODO: add draw code here
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRightList diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CRightList::AssertValid() const
|
|
{
|
|
CListView::AssertValid();
|
|
}
|
|
|
|
void CRightList::Dump(CDumpContext& dc) const
|
|
{
|
|
CListView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRightList message handlers
|
|
|
|
LRESULT CRightList::OnSelChange(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
BOOL bChangeColumns = FALSE;
|
|
|
|
CLicMgrDoc * pDoc = (CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
return lResult;
|
|
|
|
CLicServer * pLicServer = NULL;
|
|
CKeyPack * pKeyPack = NULL;
|
|
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
ListCtrl.DeleteAllItems();
|
|
NODETYPE CurNodeType = ((CLicMgrDoc *)GetDocument())->GetNodeType();
|
|
|
|
if(CurNodeType != (NODETYPE)wParam)
|
|
{
|
|
bChangeColumns = TRUE;
|
|
pDoc->SetNodeType((NODETYPE)wParam);
|
|
}
|
|
|
|
switch(wParam)
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
if(bChangeColumns)
|
|
SetServerColumns();
|
|
AddServerstoList();
|
|
|
|
SetActiveServer( NULL );
|
|
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
pLicServer = (CLicServer *)lParam;
|
|
ASSERT(pLicServer);
|
|
if(NULL == pLicServer)
|
|
break;
|
|
if(bChangeColumns)
|
|
SetKeyPackColumns();
|
|
/* 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);
|
|
break;
|
|
}
|
|
|
|
}*/
|
|
SetActiveServer( pLicServer );
|
|
|
|
AddKeyPackstoList((CLicServer *)lParam);
|
|
SetCursor(LoadCursor(NULL,IDC_ARROW));
|
|
break;
|
|
|
|
case NODE_KEYPACK:
|
|
pKeyPack = (CKeyPack *)lParam;
|
|
ASSERT(pKeyPack);
|
|
if(NULL == pKeyPack)
|
|
break;
|
|
if(bChangeColumns)
|
|
SetLicenseColumns();
|
|
/*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());
|
|
break;
|
|
}
|
|
|
|
}*/
|
|
|
|
SetActiveServer( pKeyPack->GetServer( ) );
|
|
|
|
((CMainFrame *)AfxGetMainWnd())->AddLicensestoList(
|
|
(CKeyPack *)lParam,
|
|
&ListCtrl,
|
|
FALSE
|
|
);
|
|
SetCursor(LoadCursor(NULL,IDC_ARROW));
|
|
break;
|
|
}
|
|
|
|
return lResult;
|
|
}
|
|
|
|
|
|
HRESULT CRightList::AddServerstoList()
|
|
{
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
//Get the List Control
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
|
|
CString TempString;
|
|
CString StatusString;
|
|
|
|
LicServerList * licserverlist = NULL;
|
|
int nIndex = 0;
|
|
|
|
CAllServers *pAllServer = pDoc->GetAllServers();
|
|
if(NULL == pAllServer)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
licserverlist = pAllServer->GetLicServerList();
|
|
|
|
LV_ITEM lvI;
|
|
lvI.mask = LVIF_TEXT |LVIF_IMAGE |LVIF_STATE | LVIF_PARAM;
|
|
lvI.state = 0;
|
|
lvI.stateMask =0;
|
|
// lvI.iImage = 0;
|
|
|
|
POSITION pos;
|
|
pos = licserverlist->GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
//Display the Server Name
|
|
|
|
DWORD dwServerStatus;
|
|
|
|
lvI.iItem = nIndex;
|
|
lvI.iSubItem = 0;
|
|
CLicServer * pLicServer = licserverlist->GetNext(pos);
|
|
lvI.lParam = (LPARAM)pLicServer;
|
|
TempString = pLicServer->GetName();
|
|
lvI.pszText = TempString.GetBuffer(TempString.GetLength());
|
|
lvI.cchTextMax =lstrlen(lvI.pszText + 1);
|
|
|
|
dwServerStatus = pLicServer->GetServerRegistrationStatus();
|
|
|
|
|
|
if(pLicServer->GetServerType() == SERVER_TS5_ENFORCED)
|
|
{
|
|
if( dwServerStatus == LSERVERSTATUS_REGISTER_INTERNET
|
|
||
|
|
dwServerStatus == LSERVERSTATUS_REGISTER_OTHER )
|
|
{
|
|
StatusString.LoadString(IDS_SERVER_REGISTERED);
|
|
|
|
lvI.iImage = 3;
|
|
}
|
|
else if( dwServerStatus == LSERVERSTATUS_WAITFORPIN )
|
|
{
|
|
StatusString.LoadString(IDS_SERVER_WAITFORPIN);
|
|
|
|
lvI.iImage = 4;
|
|
}
|
|
else if( dwServerStatus == LSERVERSTATUS_UNREGISTER )
|
|
{
|
|
lvI.iImage = 5;
|
|
|
|
StatusString.LoadString(IDS_SERVER_UNREGISTER);
|
|
}
|
|
else
|
|
{
|
|
lvI.iImage = 6;
|
|
|
|
StatusString.LoadString( IDS_UNKNOWN );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
StatusString.LoadString(IDS_SERVER_NOTREQUIRE);
|
|
|
|
lvI.iImage = 0;
|
|
}
|
|
|
|
//
|
|
// Display registration status
|
|
//
|
|
|
|
nIndex = ListCtrl.InsertItem(&lvI);
|
|
|
|
// ListCtrl.SetItemText(nIndex,1,(LPCTSTR)pLicServer->GetScope());
|
|
ListCtrl.SetItemText(nIndex, 1, (LPCTSTR)StatusString);
|
|
nIndex ++;
|
|
}
|
|
|
|
ListCtrl.SetItemState(0,LVIS_SELECTED,LVIS_SELECTED);
|
|
|
|
cleanup:
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
HRESULT
|
|
CRightList::AddKeyPackstoList(
|
|
CLicServer * pServer,
|
|
BOOL bRefresh
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
|
|
Parameter:
|
|
|
|
bRefresh : TRUE if refresh licenses, FALSE otherwise.
|
|
|
|
--*/
|
|
{
|
|
ASSERT(pServer);
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
|
|
if(NULL == pDoc || NULL == pServer)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
ULONG nIndex = 0;
|
|
POSITION pos;
|
|
int nSubItemIndex = 1;
|
|
CString TempString;
|
|
DWORD dwLicenses = 0;
|
|
|
|
if(bRefresh == TRUE)
|
|
{
|
|
if(pServer->RefreshCachedKeyPack() != S_OK)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
KeyPackList * keypacklist = pServer->GetKeyPackList();
|
|
|
|
ULONG nNumKeyPacks = (ULONG)keypacklist->GetCount();
|
|
|
|
if(0 == nNumKeyPacks)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
pos = keypacklist->GetHeadPosition();
|
|
|
|
for(nIndex = 0; nIndex < nNumKeyPacks; nIndex++)
|
|
{
|
|
CKeyPack * pKeyPack = keypacklist->GetNext(pos);
|
|
if(NULL == pKeyPack)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddKeyPack(ListCtrl, nIndex, pKeyPack);
|
|
}
|
|
|
|
ListCtrl.SetItemState(0,LVIS_SELECTED,LVIS_SELECTED);
|
|
|
|
cleanup:
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CRightList::SetServerColumns()
|
|
{
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
for(int index = 0; index < MAX_COLUMNS; index++)
|
|
{
|
|
ListCtrl.DeleteColumn(0);
|
|
}
|
|
LV_COLUMN lvC;
|
|
CString ColumnText;
|
|
lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM ;
|
|
lvC.fmt = LVCFMT_LEFT;
|
|
lvC.cx = 125;
|
|
for(index = 0; index < NUM_SERVER_COLUMNS; index ++)
|
|
{
|
|
lvC.iSubItem = index;
|
|
ColumnText.LoadString(IDS_SERVER_COLUMN1 + index);
|
|
lvC.pszText = ColumnText.GetBuffer(ColumnText.GetLength());
|
|
GetListCtrl().InsertColumn(index, &lvC);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CRightList::SetKeyPackColumns()
|
|
{
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
for(int index = 0; index < MAX_COLUMNS; index++)
|
|
{
|
|
ListCtrl.DeleteColumn(0);
|
|
}
|
|
LV_COLUMN lvC;
|
|
CString ColumnText;
|
|
lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM ;
|
|
lvC.fmt = LVCFMT_LEFT;
|
|
lvC.cx = KEYPACK_DISPNAME_WIDTH;
|
|
for(index = 0; index < NUM_KEYPACK_COLUMNS; index ++)
|
|
{
|
|
lvC.iSubItem = index;
|
|
ColumnText.LoadString(IDS_KEYPACK_COLUMN1 + index);
|
|
lvC.pszText = ColumnText.GetBuffer(ColumnText.GetLength());
|
|
ListCtrl.InsertColumn(index, &lvC);
|
|
lvC.cx = KEYPACK_OTHERS_WIDTH;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CRightList::SetLicenseColumns()
|
|
{
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
for(int index = 0; index < MAX_COLUMNS; index++)
|
|
{
|
|
ListCtrl.DeleteColumn(0);
|
|
}
|
|
LV_COLUMN lvC;
|
|
CString ColumnText;
|
|
lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM ;
|
|
lvC.fmt = LVCFMT_LEFT;
|
|
lvC.cx = 125;
|
|
for(index = 0; index < NUM_LICENSE_COLUMNS; index ++)
|
|
{
|
|
lvC.iSubItem = index;
|
|
ColumnText.LoadString(IDS_LICENSE_COLUMN1 + index);
|
|
lvC.pszText = ColumnText.GetBuffer(ColumnText.GetLength());
|
|
ListCtrl.InsertColumn(index, &lvC);
|
|
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
void CRightList::OnInitialUpdate()
|
|
{
|
|
CListView::OnInitialUpdate();
|
|
|
|
CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
|
|
ASSERT(pMainFrame);
|
|
if(NULL == pMainFrame)
|
|
return;
|
|
|
|
//Create and set the image lists
|
|
m_ImageListSmall.Create( SM_BITMAP_WIDTH,SM_BITMAP_HEIGHT,TRUE, 7, 7);
|
|
|
|
m_ImageListLarge.Create( LG_BITMAP_WIDTH,LG_BITMAP_HEIGHT,TRUE, 7, 7);
|
|
|
|
HICON hIcon = NULL;
|
|
|
|
DWORD rgdwIDs[] = { IDI_SERVER , IDI_KEYPACK , IDI_LICENSE , IDI_SERVERREG , IDI_SERVERM , IDI_SERVERX , IDI_SERVERQ , (DWORD)-1 };
|
|
|
|
int index = 0;
|
|
|
|
while( rgdwIDs[ index ] != ( DWORD )-1 )
|
|
{
|
|
hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE( rgdwIDs[ index ] ) );
|
|
|
|
if (NULL == hIcon)
|
|
{
|
|
ASSERT(!"LoadIcon Failed");
|
|
continue;
|
|
}
|
|
|
|
m_ImageListSmall.Add(hIcon);
|
|
m_ImageListLarge.Add(hIcon);
|
|
|
|
/*
|
|
if ((m_ImageListSmall.Add(hIcon) == -1) || (m_ImageListLarge.Add(hIcon) == -1))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
*/
|
|
|
|
++index;
|
|
}
|
|
|
|
GetListCtrl().SetImageList(&m_ImageListSmall,LVSIL_SMALL);
|
|
GetListCtrl().SetImageList(&m_ImageListLarge,LVSIL_NORMAL);
|
|
|
|
//Set the style
|
|
GetListCtrl().ModifyStyle(0,LVS_REPORT | LVS_AUTOARRANGE | LVS_SINGLESEL | LVS_SORTASCENDING,0);
|
|
|
|
GetListCtrl().SendMessage( LVM_SETEXTENDEDLISTVIEWSTYLE , LVS_EX_FULLROWSELECT , LVS_EX_FULLROWSELECT );
|
|
|
|
//Select details view by default
|
|
CMenu *pMenu = pMainFrame->GetMenu();
|
|
if(pMenu)
|
|
pMenu->CheckMenuRadioItem(ID_DETAILS,ID_LIST, ID_DETAILS,MF_BYCOMMAND);
|
|
pMainFrame->PressButton(ID_DETAILS,TRUE);
|
|
|
|
//Display the server
|
|
pMainFrame->ConnectAndDisplay();
|
|
|
|
}
|
|
|
|
void CRightList::OnLargeIcons()
|
|
{
|
|
// TODO: Add your command handler code here
|
|
CListCtrl &ListCtrl = GetListCtrl();
|
|
ListCtrl.ModifyStyle(LVS_LIST|LVS_REPORT | LVS_SMALLICON,LVS_ICON,0);
|
|
CMenu *pMenu = AfxGetMainWnd()->GetMenu();
|
|
if(pMenu)
|
|
pMenu->CheckMenuRadioItem(ID_LARGE_ICONS,ID_LIST,ID_LARGE_ICONS,MF_BYCOMMAND);
|
|
CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
|
|
ASSERT(pMainFrame);
|
|
if(NULL == pMainFrame)
|
|
return;
|
|
pMainFrame->PressButton(ID_LARGE_ICONS,TRUE);
|
|
pMainFrame->PressButton(ID_SMALL_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_LIST,FALSE);
|
|
pMainFrame->PressButton(ID_DETAILS,FALSE);
|
|
return;
|
|
|
|
|
|
}
|
|
|
|
void CRightList::OnSmallIcons()
|
|
{
|
|
// TODO: Add your command handler code here
|
|
CListCtrl &ListCtrl = GetListCtrl();
|
|
ListCtrl.ModifyStyle(LVS_LIST|LVS_ICON | LVS_REPORT,LVS_SMALLICON,0);
|
|
CMenu *pMenu = AfxGetMainWnd()->GetMenu();
|
|
if(pMenu)
|
|
pMenu->CheckMenuRadioItem(ID_LARGE_ICONS,ID_LIST,ID_SMALL_ICONS,MF_BYCOMMAND);
|
|
CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
|
|
ASSERT(pMainFrame);
|
|
if(NULL == pMainFrame)
|
|
return;
|
|
pMainFrame->PressButton(ID_LARGE_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_SMALL_ICONS,TRUE);
|
|
pMainFrame->PressButton(ID_LIST,FALSE);
|
|
pMainFrame->PressButton(ID_DETAILS,FALSE);
|
|
return;
|
|
|
|
|
|
}
|
|
|
|
void CRightList::OnList()
|
|
{
|
|
// TODO: Add your command handler code here
|
|
CListCtrl &ListCtrl = GetListCtrl();
|
|
ListCtrl.ModifyStyle(LVS_REPORT|LVS_ICON | LVS_SMALLICON,LVS_LIST,0);
|
|
CMenu *pMenu = AfxGetMainWnd()->GetMenu();
|
|
if(pMenu)
|
|
pMenu->CheckMenuRadioItem(ID_LARGE_ICONS,ID_LIST,ID_LIST,MF_BYCOMMAND);
|
|
CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
|
|
ASSERT(pMainFrame);
|
|
if(NULL == pMainFrame)
|
|
return;
|
|
pMainFrame->PressButton(ID_LARGE_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_SMALL_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_LIST,TRUE);
|
|
pMainFrame->PressButton(ID_DETAILS,FALSE);
|
|
return;
|
|
}
|
|
|
|
void CRightList::OnDetails()
|
|
{
|
|
// TODO: Add your command handler code here
|
|
CListCtrl &ListCtrl = GetListCtrl();
|
|
ListCtrl.ModifyStyle(LVS_LIST|LVS_ICON | LVS_SMALLICON,LVS_REPORT,0);
|
|
CMenu *pMenu = AfxGetMainWnd()->GetMenu();
|
|
if(pMenu)
|
|
pMenu->CheckMenuRadioItem(ID_LARGE_ICONS,ID_LIST,ID_DETAILS,MF_BYCOMMAND);
|
|
CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
|
|
ASSERT(pMainFrame);
|
|
if(NULL == pMainFrame)
|
|
return;
|
|
pMainFrame->PressButton(ID_LARGE_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_SMALL_ICONS,FALSE);
|
|
pMainFrame->PressButton(ID_LIST,FALSE);
|
|
pMainFrame->PressButton(ID_DETAILS,TRUE);
|
|
return;
|
|
}
|
|
|
|
LRESULT CRightList::OnAddServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
if(NODE_ALL_SERVERS != pDoc->GetNodeType())
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
|
|
CLicServer *pServer = (CLicServer*)lParam;
|
|
ASSERT(pServer);
|
|
if(NULL == pServer)
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
LV_ITEM lvI;
|
|
|
|
lvI.iImage = 0;
|
|
|
|
if( pServer->GetServerType() == SERVER_TS5_ENFORCED )
|
|
{
|
|
|
|
DWORD dwStatus = pServer->GetServerRegistrationStatus( );
|
|
|
|
if( dwStatus == LSERVERSTATUS_REGISTER_INTERNET || dwStatus == LSERVERSTATUS_REGISTER_OTHER )
|
|
{
|
|
lvI.iImage = 3;
|
|
}
|
|
else if( dwStatus == LSERVERSTATUS_WAITFORPIN )
|
|
{
|
|
lvI.iImage = 4;
|
|
}
|
|
else if( dwStatus == LSERVERSTATUS_UNREGISTER )
|
|
{
|
|
lvI.iImage = 5;
|
|
}
|
|
else
|
|
{
|
|
lvI.iImage = 6;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
CString Name;
|
|
int nIndex = GetListCtrl().GetItemCount();
|
|
|
|
// Insert Server Name;
|
|
|
|
lvI.mask = LVIF_TEXT |LVIF_IMAGE |LVIF_STATE | LVIF_PARAM;
|
|
lvI.state = 0;
|
|
lvI.stateMask =0;
|
|
lvI.iSubItem = 0;
|
|
//lvI.iImage = 0;
|
|
lvI.iItem = nIndex;
|
|
lvI.lParam = (LPARAM)pServer;
|
|
Name = pServer->GetName();
|
|
lvI.pszText = Name.GetBuffer(Name.GetLength());
|
|
lvI.cchTextMax =lstrlen(lvI.pszText + 1);
|
|
nIndex = ListCtrl.InsertItem(&lvI);
|
|
|
|
//Insert Server Scope
|
|
|
|
//ListCtrl.SetItemText(nIndex,1,pServer->GetScope());
|
|
|
|
CString TempString;
|
|
|
|
if(pServer->GetServerType() == SERVER_TS5_ENFORCED)
|
|
{
|
|
if(pServer->GetServerRegistrationStatus() == LSERVERSTATUS_REGISTER_INTERNET
|
|
||
|
|
pServer->GetServerRegistrationStatus() == LSERVERSTATUS_REGISTER_OTHER )
|
|
{
|
|
VERIFY(TempString.LoadString(IDS_SERVER_REGISTERED) == TRUE);
|
|
}
|
|
else if( pServer->GetServerRegistrationStatus() == LSERVERSTATUS_WAITFORPIN )
|
|
{
|
|
VERIFY(TempString.LoadString(IDS_SERVER_WAITFORPIN) == TRUE);
|
|
}
|
|
else if( pServer->GetServerRegistrationStatus() == LSERVERSTATUS_UNREGISTER )
|
|
{
|
|
VERIFY(TempString.LoadString(IDS_SERVER_UNREGISTER) == TRUE);
|
|
}
|
|
else
|
|
{
|
|
VERIFY(TempString.LoadString(IDS_UNKNOWN ) == TRUE);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
VERIFY(TempString.LoadString(IDS_SERVER_NOTREQUIRE) == TRUE);
|
|
}
|
|
|
|
ListCtrl.SetItemText(nIndex, 1, (LPCTSTR)TempString);
|
|
|
|
if(nIndex == 0)
|
|
{
|
|
ListCtrl.SetItemState(0,LVIS_SELECTED,LVIS_SELECTED);
|
|
}
|
|
|
|
return lResult;
|
|
} // OnAddServer
|
|
|
|
LRESULT CRightList::OnAddKeyPack(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
return lResult;
|
|
|
|
if(NODE_SERVER != pDoc->GetNodeType())
|
|
return lResult;
|
|
|
|
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
int nIndex = ListCtrl.GetItemCount();
|
|
|
|
CKeyPack *pKeyPack = (CKeyPack*)lParam;
|
|
ASSERT(pKeyPack);
|
|
if(NULL == pKeyPack)
|
|
return lResult;
|
|
|
|
AddKeyPack(ListCtrl,nIndex,pKeyPack);
|
|
if(nIndex == 0)
|
|
ListCtrl.SetItemState(0,LVIS_SELECTED,LVIS_SELECTED);
|
|
|
|
|
|
return lResult;
|
|
|
|
} // OnAddKeyPack
|
|
|
|
|
|
void CRightList::AddKeyPack(CListCtrl& ListCtrl,int nIndex, CKeyPack * pKeyPack)
|
|
{
|
|
if(NULL == pKeyPack)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LSKeyPack sKeyPack;
|
|
int nSubItemIndex = 1;
|
|
DWORD dwLicenses = 0;
|
|
|
|
CLicMgrDoc * pDoc = (CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CString TempString;
|
|
DWORD dwIssuedLicenses = 0;
|
|
|
|
LV_ITEM lvI;
|
|
lvI.mask = LVIF_TEXT |LVIF_IMAGE |LVIF_STATE | LVIF_PARAM;
|
|
lvI.state = 0;
|
|
lvI.stateMask =0;
|
|
lvI.iItem = 0;
|
|
lvI.iSubItem = 0;
|
|
lvI.iImage = 1;
|
|
lvI.iItem = nIndex;
|
|
lvI.lParam = (LPARAM)pKeyPack;
|
|
|
|
TempString = pKeyPack->GetDisplayName();
|
|
lvI.pszText = TempString.GetBuffer(TempString.GetLength());
|
|
lvI.cchTextMax =lstrlen(lvI.pszText + 1);
|
|
nIndex = ListCtrl.InsertItem(&lvI);
|
|
|
|
sKeyPack = pKeyPack->GetKeyPackStruct();
|
|
|
|
//Set the KeyPack Type.
|
|
|
|
if(NUM_KEYPACK_TYPE <= sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN );
|
|
}
|
|
else
|
|
{
|
|
if(LSKEYPACKTYPE_FREE == sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_LSKEYPACKTYPE_FREE );
|
|
}
|
|
else
|
|
{
|
|
TempString.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN+ sKeyPack.ucKeyPackType);
|
|
}
|
|
}
|
|
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
nSubItemIndex++;
|
|
|
|
//Set the Activation date, Now called Registered on
|
|
|
|
#ifdef SPANISH
|
|
|
|
if(LSKEYPACKTYPE_TEMPORARY != sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString = pDoc->TimeToString(&sKeyPack.dwActivateDate);
|
|
if(TempString.IsEmpty())
|
|
{
|
|
TempString.LoadString(IDS_UNKNOWN);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TempString.LoadString(IDS_DASH);
|
|
}
|
|
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
nSubItemIndex++;
|
|
#endif
|
|
|
|
//Set Total licenses.
|
|
|
|
//
|
|
// HueiWang 7/7/98 - per marketing request
|
|
//
|
|
if(LSKEYPACKTYPE_TEMPORARY == sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_DASH);
|
|
}
|
|
else
|
|
{
|
|
if(LSKEYPACKTYPE_FREE == sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_UNLIMITED);
|
|
}
|
|
else
|
|
{
|
|
TempString.Format(_T("%d"),sKeyPack.dwTotalLicenseInKeyPack);
|
|
}
|
|
}
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
|
|
nSubItemIndex++;
|
|
|
|
//Set Available licenses.
|
|
|
|
if(LSKEYPACKTYPE_TEMPORARY == sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_DASH);
|
|
}
|
|
else
|
|
{
|
|
if( LSKEYPACKSTATUS_RETURNED == sKeyPack.ucKeyPackStatus ||
|
|
LSKEYPACKSTATUS_REVOKED == sKeyPack.ucKeyPackStatus )
|
|
{
|
|
TempString.Format(_T("%d"), 0);
|
|
}
|
|
else if(LSKEYPACKTYPE_FREE == sKeyPack.ucKeyPackType)
|
|
{
|
|
TempString.LoadString(IDS_UNLIMITED);
|
|
}
|
|
else
|
|
{
|
|
TempString.Format(_T("%d"),sKeyPack.dwNumberOfLicenses);
|
|
}
|
|
}
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
|
|
nSubItemIndex++;
|
|
|
|
//Set Issued licenses.
|
|
|
|
if(LSKEYPACKTYPE_TEMPORARY == sKeyPack.ucKeyPackType ||
|
|
LSKEYPACKTYPE_FREE == sKeyPack.ucKeyPackType )
|
|
{
|
|
dwLicenses = sKeyPack.dwNumberOfLicenses;
|
|
}
|
|
else
|
|
{
|
|
dwLicenses = sKeyPack.dwTotalLicenseInKeyPack - sKeyPack.dwNumberOfLicenses;
|
|
}
|
|
|
|
TempString.Format(_T("%d"),dwLicenses);
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
|
|
nSubItemIndex++;
|
|
|
|
TempString.Empty( );
|
|
|
|
switch( sKeyPack.ucKeyPackStatus )
|
|
{
|
|
case LSKEYPACKSTATUS_UNKNOWN:
|
|
TempString.LoadString( IDS_KEYPACKSTATUS_UNKNOWN );
|
|
break;
|
|
|
|
case LSKEYPACKSTATUS_TEMPORARY:
|
|
TempString.LoadString( IDS_KEYPACKSTATUS_TEMPORARY );
|
|
break;
|
|
|
|
case LSKEYPACKSTATUS_ACTIVE:
|
|
case LSKEYPACKSTATUS_PENDING:
|
|
//case LSKEYPACKSTATUS_RESTORE:
|
|
TempString.LoadString( IDS_KEYPACKSTATUS_ACTIVE );
|
|
break;
|
|
|
|
case LSKEYPACKSTATUS_RETURNED:
|
|
TempString.LoadString( IDS_KEYPACKSTATUS_RETURNED );
|
|
break;
|
|
|
|
case LSKEYPACKSTATUS_REVOKED:
|
|
TempString.LoadString( IDS_KEYPACKSTATUS_REVOKED );
|
|
break;
|
|
}
|
|
|
|
if( TempString.IsEmpty() )
|
|
{
|
|
TempString.LoadString(IDS_UNKNOWN);
|
|
}
|
|
|
|
ListCtrl.SetItemText(nIndex,nSubItemIndex,(LPCTSTR)TempString);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
LRESULT CRightList::OnDeleteServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
|
|
DBGMSG( L"CRightList_OnDeleteServer\n" , 0 );
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
return lResult;
|
|
|
|
CLicServer *pServer = (CLicServer*)lParam;
|
|
ASSERT(pServer);
|
|
if(NULL == pServer)
|
|
return lResult;
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
if(0 == ListCtrl.GetItemCount())
|
|
return lResult;
|
|
|
|
|
|
int nIndex = 0;
|
|
CKeyPack * pKeyPack = NULL;
|
|
LV_ITEM Item;
|
|
ZeroMemory((LPVOID)&Item,sizeof(Item));
|
|
|
|
switch(pDoc->GetNodeType())
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
DBGMSG( L"\tNODE_ALL_SERVERS\n",0 );
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.psz = NULL;
|
|
FindInfo.lParam = (LPARAM)pServer;
|
|
|
|
nIndex = ListCtrl.FindItem(&FindInfo);
|
|
if(-1 == nIndex)
|
|
return lResult;
|
|
|
|
ListCtrl.DeleteItem(nIndex);
|
|
break;
|
|
case NODE_SERVER:
|
|
DBGMSG( L"\tNODE_SERVER\n",0 );
|
|
Item.iItem = 0;
|
|
Item.mask = LVIF_PARAM;
|
|
nIndex = ListCtrl.GetItem(&Item);
|
|
if(-1 == nIndex)
|
|
break;
|
|
pKeyPack = (CKeyPack *)Item.lParam;
|
|
if(NULL == pKeyPack)
|
|
break;
|
|
if(pServer == pKeyPack->GetServer())
|
|
ListCtrl.DeleteAllItems();
|
|
|
|
break;
|
|
case NODE_KEYPACK:
|
|
DBGMSG( L"\tNODE_KEYPACK\n",0 );
|
|
Item.iItem = 0;
|
|
Item.mask = LVIF_PARAM;
|
|
nIndex = ListCtrl.GetItem(&Item);
|
|
if(-1 == nIndex)
|
|
break;
|
|
CLicense * pLicense = (CLicense *)Item.lParam;
|
|
if(NULL == pLicense)
|
|
break;
|
|
pKeyPack = pLicense->GetKeyPack();
|
|
if(NULL == pKeyPack)
|
|
break;
|
|
if(pServer == pKeyPack->GetServer())
|
|
ListCtrl.DeleteAllItems();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
return lResult;
|
|
|
|
} // OnDeleteServer
|
|
|
|
LRESULT CRightList::OnUpdateServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
int item;
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
ASSERT(pDoc);
|
|
if(NULL == pDoc)
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
CLicServer *pServer = (CLicServer*)lParam;
|
|
ASSERT(pServer);
|
|
if(NULL == pServer)
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
CListCtrl& ListCtrl = GetListCtrl();
|
|
if(0 == ListCtrl.GetItemCount())
|
|
{
|
|
return lResult;
|
|
}
|
|
|
|
int nIndex = 0;
|
|
CKeyPack * pKeyPack = NULL;
|
|
LV_ITEM Item;
|
|
ZeroMemory((LPVOID)&Item,sizeof(Item));
|
|
|
|
Item.mask = LVIF_IMAGE;
|
|
|
|
CString sServerName;
|
|
if(pServer->UseIpAddress())
|
|
sServerName = pServer->GetIpAddress();
|
|
else
|
|
sServerName = pServer->GetName();
|
|
|
|
switch(pDoc->GetNodeType())
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
for( item = 0; item < ListCtrl.GetItemCount( ); ++item )
|
|
{
|
|
CString sItemName = ListCtrl.GetItemText(item, 0);
|
|
|
|
//We'll only refresh the server we were asked to refresh
|
|
if(sServerName != sItemName)
|
|
continue;
|
|
|
|
// update status of registration
|
|
|
|
CString TempString;
|
|
|
|
if(pServer->GetServerType() == SERVER_TS5_ENFORCED)
|
|
{
|
|
if(pServer->GetServerRegistrationStatus() == LSERVERSTATUS_REGISTER_INTERNET
|
|
||
|
|
pServer->GetServerRegistrationStatus() == LSERVERSTATUS_REGISTER_OTHER )
|
|
{
|
|
TempString.LoadString(IDS_SERVER_REGISTERED);
|
|
Item.iImage = 3;
|
|
}
|
|
else if( pServer->GetServerRegistrationStatus() == LSERVERSTATUS_WAITFORPIN )
|
|
{
|
|
TempString.LoadString( IDS_SERVER_WAITFORPIN );
|
|
Item.iImage = 4;
|
|
}
|
|
else if( pServer->GetServerRegistrationStatus() == LSERVERSTATUS_UNREGISTER )
|
|
{
|
|
TempString.LoadString(IDS_SERVER_UNREGISTER);
|
|
Item.iImage = 5;
|
|
}
|
|
else
|
|
{
|
|
TempString.LoadString(IDS_UNKNOWN);
|
|
Item.iImage = 6;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
TempString.LoadString(IDS_SERVER_NOTREQUIRE);
|
|
}
|
|
|
|
Item.iItem = item;
|
|
|
|
ListCtrl.SetItem( &Item );
|
|
|
|
ListCtrl.SetItemText(item, 1, (LPCTSTR)TempString);
|
|
}
|
|
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
Item.iItem = 0;
|
|
Item.mask = LVIF_PARAM;
|
|
nIndex = ListCtrl.GetItem(&Item);
|
|
if(-1 == nIndex)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pKeyPack = (CKeyPack *)Item.lParam;
|
|
if(NULL == pKeyPack)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(pServer == pKeyPack->GetServer())
|
|
{
|
|
ListCtrl.DeleteAllItems();
|
|
AddKeyPackstoList(pServer, TRUE);
|
|
}
|
|
break;
|
|
|
|
case NODE_KEYPACK:
|
|
Item.iItem = 0;
|
|
Item.mask = LVIF_PARAM;
|
|
nIndex = ListCtrl.GetItem(&Item);
|
|
if(-1 == nIndex)
|
|
{
|
|
break;
|
|
}
|
|
|
|
CLicense * pLicense = (CLicense *)Item.lParam;
|
|
if(NULL == pLicense)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pKeyPack = pLicense->GetKeyPack();
|
|
if(NULL == pKeyPack)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(pServer == pKeyPack->GetServer())
|
|
{
|
|
ListCtrl.DeleteAllItems();
|
|
((CMainFrame *)AfxGetMainWnd())->AddLicensestoList(pKeyPack, &ListCtrl, TRUE);
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return lResult;
|
|
} // OnUpdateServer
|
|
|
|
//-----------------------------------------------------------------------------------------------------
|
|
void CRightList::OnDblclk(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
// TODO: Add your control notification handler code here
|
|
CListCtrl& listctrl = GetListCtrl();
|
|
|
|
//Get the selected item
|
|
int nSelected = listctrl.GetNextItem(-1, LVNI_SELECTED);
|
|
if(-1 == nSelected)
|
|
return;
|
|
|
|
//Get the Data associated with the item.
|
|
#ifdef _WIN64
|
|
DWORD_PTR dCurrSel;
|
|
#else
|
|
DWORD dCurrSel;
|
|
#endif
|
|
|
|
dCurrSel = listctrl.GetItemData(nSelected);
|
|
if(LB_ERR == dCurrSel)
|
|
return;
|
|
|
|
switch(((CLicMgrDoc *)GetDocument())->GetNodeType())
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
((CMainFrame *)AfxGetMainWnd())->SetTreeViewSel(dCurrSel,NODE_SERVER);
|
|
break;
|
|
case NODE_SERVER:
|
|
((CMainFrame *)AfxGetMainWnd())->SetTreeViewSel(dCurrSel,NODE_KEYPACK);
|
|
break;
|
|
}
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------
|
|
void CRightList::OnKeydown(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
LV_KEYDOWN* pLVKeyDow = (LV_KEYDOWN*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
CMainFrame * pMainFrame = ((CMainFrame *)AfxGetMainWnd());
|
|
if(pLVKeyDow->wVKey == VK_RETURN)
|
|
{
|
|
OnDblclk(pNMHDR,pResult);
|
|
pMainFrame->SelectView(LISTVIEW);
|
|
}
|
|
if(pLVKeyDow->wVKey == VK_TAB)
|
|
{
|
|
pMainFrame->SelectView(TREEVIEW);
|
|
}
|
|
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
/*
|
|
* Column Sorting.
|
|
*/
|
|
|
|
BOOL fColSortDir[MAX_COLUMNS * NODE_NONE];
|
|
|
|
int CALLBACK CompareAllServers(LPARAM, LPARAM, LPARAM);
|
|
int CALLBACK CompareServer(LPARAM, LPARAM, LPARAM);
|
|
int CALLBACK CompareKeyPack(LPARAM, LPARAM, LPARAM);
|
|
|
|
VOID
|
|
CRightList::OnColumnClick(
|
|
NMHDR* pNMHDR,
|
|
LRESULT* pResult
|
|
)
|
|
{
|
|
NM_LISTVIEW* pnmlv = (NM_LISTVIEW*)pNMHDR;
|
|
NODETYPE curType = ((CLicMgrDoc*)GetDocument())->GetNodeType();
|
|
|
|
switch(curType) {
|
|
case NODE_ALL_SERVERS:
|
|
GetListCtrl().SortItems(CompareAllServers, pnmlv->iSubItem);
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
GetListCtrl().SortItems(CompareServer, pnmlv->iSubItem);
|
|
break;
|
|
|
|
case NODE_KEYPACK:
|
|
GetListCtrl().SortItems(CompareKeyPack, pnmlv->iSubItem);
|
|
break;
|
|
}
|
|
|
|
fColSortDir[curType * MAX_COLUMNS + pnmlv->iSubItem] =
|
|
!fColSortDir[curType * MAX_COLUMNS + pnmlv->iSubItem];
|
|
}
|
|
|
|
/*
|
|
* Compare Functions.
|
|
*/
|
|
|
|
|
|
int CALLBACK
|
|
CompareAllServers(
|
|
LPARAM lParam1,
|
|
LPARAM lParam2,
|
|
LPARAM lParamSort
|
|
)
|
|
{
|
|
CLicServer* pItem1 = (CLicServer*)lParam1;
|
|
CLicServer* pItem2 = (CLicServer*)lParam2;
|
|
int retVal = 0;
|
|
int iCol = (NODE_ALL_SERVERS * MAX_COLUMNS) + (int)lParamSort;
|
|
int dir;
|
|
|
|
switch(lParamSort) {
|
|
|
|
case 0:
|
|
case 1:
|
|
retVal = pItem1->GetName().CompareNoCase(pItem2->GetName());
|
|
break;
|
|
|
|
default:
|
|
return(0);
|
|
}
|
|
|
|
dir = fColSortDir[iCol] ? 1 : -1;
|
|
|
|
return(dir * retVal);
|
|
}
|
|
|
|
int CALLBACK
|
|
CompareServer(
|
|
LPARAM lParam1,
|
|
LPARAM lParam2,
|
|
LPARAM lParamSort
|
|
)
|
|
{
|
|
CKeyPack* pItem1 = (CKeyPack*)lParam1;
|
|
CKeyPack* pItem2 = (CKeyPack*)lParam2;
|
|
CString szTemp1;
|
|
CString szTemp2;
|
|
int retVal = 0;
|
|
int iCol = (NODE_SERVER * MAX_COLUMNS) + (int)lParamSort;
|
|
int dir;
|
|
int tmp1, tmp2;
|
|
|
|
switch(lParamSort) {
|
|
|
|
case 0:
|
|
retVal = _tcsicmp(pItem1->GetDisplayName(), pItem2->GetDisplayName());
|
|
break;
|
|
|
|
case 1:
|
|
tmp1 = pItem1->GetKeyPackStruct().ucKeyPackType;
|
|
tmp2 = pItem2->GetKeyPackStruct().ucKeyPackType;
|
|
|
|
if (tmp1 >= NUM_KEYPACK_TYPE) {
|
|
szTemp1.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN);
|
|
} else if(tmp1 == LSKEYPACKTYPE_FREE) {
|
|
szTemp1.LoadString(IDS_LSKEYPACKTYPE_FREE);
|
|
} else {
|
|
szTemp1.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN + tmp1);
|
|
}
|
|
|
|
if (tmp2 >= NUM_KEYPACK_TYPE) {
|
|
szTemp2.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN);
|
|
} else if(tmp2 == LSKEYPACKTYPE_FREE) {
|
|
szTemp2.LoadString(IDS_LSKEYPACKTYPE_FREE);
|
|
} else {
|
|
szTemp2.LoadString(IDS_LSKEYPACKTYPE_UNKNOWN + tmp2);
|
|
}
|
|
|
|
retVal = _tcsicmp(szTemp1, szTemp2);
|
|
break;
|
|
|
|
case 2:
|
|
tmp1 = pItem1->GetKeyPackStruct().ucKeyPackType;
|
|
tmp2 = pItem2->GetKeyPackStruct().ucKeyPackType;
|
|
|
|
if (tmp1 == LSKEYPACKTYPE_FREE) {
|
|
retVal = 1;
|
|
} else if (tmp1 == LSKEYPACKTYPE_TEMPORARY) {
|
|
retVal = -1;
|
|
} else {
|
|
if (tmp2 == LSKEYPACKTYPE_FREE) {
|
|
retVal = -1;
|
|
} else if (tmp2 == LSKEYPACKTYPE_TEMPORARY) {
|
|
retVal = 1;
|
|
} else {
|
|
retVal = pItem1->GetKeyPackStruct().dwTotalLicenseInKeyPack -
|
|
pItem2->GetKeyPackStruct().dwTotalLicenseInKeyPack;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
tmp1 = pItem1->GetKeyPackStruct().ucKeyPackType;
|
|
tmp2 = pItem2->GetKeyPackStruct().ucKeyPackType;
|
|
|
|
if (tmp1 == LSKEYPACKTYPE_FREE) {
|
|
retVal = 1;
|
|
} else if (tmp1 == LSKEYPACKTYPE_TEMPORARY) {
|
|
retVal = -1;
|
|
} else {
|
|
if (tmp2 == LSKEYPACKTYPE_FREE) {
|
|
retVal = -1;
|
|
} else if (tmp2 == LSKEYPACKTYPE_TEMPORARY) {
|
|
retVal = 1;
|
|
} else {
|
|
retVal = pItem1->GetKeyPackStruct().dwNumberOfLicenses -
|
|
pItem2->GetKeyPackStruct().dwNumberOfLicenses;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
DWORD sort1, sort2;
|
|
|
|
tmp1 = pItem1->GetKeyPackStruct().ucKeyPackType;
|
|
tmp2 = pItem2->GetKeyPackStruct().ucKeyPackType;
|
|
|
|
if ((tmp1 == LSKEYPACKTYPE_TEMPORARY) || (tmp1 == LSKEYPACKTYPE_FREE)) {
|
|
sort1 = pItem1->GetKeyPackStruct().dwNumberOfLicenses;
|
|
} else {
|
|
sort1 = pItem1->GetKeyPackStruct().dwTotalLicenseInKeyPack -
|
|
pItem1->GetKeyPackStruct().dwNumberOfLicenses;
|
|
}
|
|
|
|
if ((tmp2 == LSKEYPACKTYPE_TEMPORARY) || (tmp2 == LSKEYPACKTYPE_FREE)) {
|
|
sort2 = pItem2->GetKeyPackStruct().dwNumberOfLicenses;
|
|
} else {
|
|
sort2 = pItem2->GetKeyPackStruct().dwTotalLicenseInKeyPack -
|
|
pItem2->GetKeyPackStruct().dwNumberOfLicenses;
|
|
}
|
|
|
|
retVal = sort1 - sort2;
|
|
break;
|
|
|
|
default:
|
|
return(0);
|
|
}
|
|
|
|
dir = fColSortDir[iCol] ? 1 : -1;
|
|
|
|
return(dir * retVal);
|
|
}
|
|
|
|
int CALLBACK
|
|
CompareKeyPack(
|
|
LPARAM lParam1,
|
|
LPARAM lParam2,
|
|
LPARAM lParamSort
|
|
)
|
|
{
|
|
CLicense* pItem1 = (CLicense*)lParam1;
|
|
CLicense* pItem2 = (CLicense*)lParam2;
|
|
int retVal = 0;
|
|
int iCol = (NODE_KEYPACK * MAX_COLUMNS) + (int)lParamSort;
|
|
int dir;
|
|
|
|
switch(lParamSort) {
|
|
|
|
case 0:
|
|
retVal = _tcsicmp(pItem1->GetLicenseStruct().szMachineName,
|
|
pItem2->GetLicenseStruct().szMachineName);
|
|
break;
|
|
|
|
case 1:
|
|
retVal = pItem1->GetLicenseStruct().ftIssueDate -
|
|
pItem2->GetLicenseStruct().ftIssueDate;
|
|
break;
|
|
|
|
case 2:
|
|
retVal = pItem1->GetLicenseStruct().ftExpireDate -
|
|
pItem2->GetLicenseStruct().ftExpireDate;
|
|
break;
|
|
|
|
default:
|
|
return(0);
|
|
}
|
|
|
|
dir = fColSortDir[iCol] ? 1 : -1;
|
|
|
|
return(dir * retVal);
|
|
}
|
|
|
|
afx_msg void CRightList::OnLeftClick( NMHDR* pNMHDR, LRESULT* pResult )
|
|
{
|
|
CPoint pt;
|
|
|
|
DWORD_PTR itemData;
|
|
|
|
GetCursorPos( &pt );
|
|
|
|
ScreenToClient( &pt );
|
|
UINT flag;
|
|
|
|
CListCtrl& listctrl = GetListCtrl();
|
|
|
|
int iItem = listctrl.HitTest( pt , &flag );
|
|
|
|
itemData = listctrl.GetItemData( iItem );
|
|
|
|
if( itemData == LB_ERR )
|
|
{
|
|
int iItem = listctrl.GetNextItem(-1, LVNI_SELECTED | LVNI_FOCUSED );
|
|
|
|
if( iItem != LB_ERR )
|
|
{
|
|
itemData = listctrl.GetItemData( iItem );
|
|
}
|
|
else
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
|
|
if(NULL == pDoc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
NODETYPE nt = pDoc->GetNodeType();
|
|
|
|
switch( nt )
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
{
|
|
CLicServer *pServer = reinterpret_cast< CLicServer* >( itemData );
|
|
|
|
SetActiveServer( pServer );
|
|
|
|
if( NULL == pServer )
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
DBGMSG( L"\tServer item selected\n", 0 );
|
|
}
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
{
|
|
CKeyPack *pKeyPack = reinterpret_cast< CKeyPack * >( itemData );
|
|
|
|
if(NULL == pKeyPack)
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
SetActiveServer( NULL );
|
|
|
|
break;
|
|
}
|
|
|
|
SetActiveServer( pKeyPack->GetServer( ) );
|
|
|
|
DBGMSG( L"\tLicense pak item selected\n", 0 );
|
|
}
|
|
|
|
break;
|
|
|
|
case NODE_KEYPACK:
|
|
{
|
|
CLicense * pLicense = reinterpret_cast< CLicense * >( itemData );
|
|
|
|
if( pLicense != NULL )
|
|
{
|
|
CKeyPack *pKeyPack = pLicense->GetKeyPack( );
|
|
|
|
if( pKeyPack != NULL )
|
|
{
|
|
SetActiveServer( pKeyPack->GetServer( ) );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetActiveServer( NULL );
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
afx_msg void CRightList::OnContextMenu( CWnd* pWnd, CPoint pt )
|
|
{
|
|
CMenu menu;
|
|
|
|
CMenu *pContextMenu = NULL;
|
|
|
|
DWORD_PTR itemData;
|
|
|
|
DBGMSG( L"LICMGR @ CRightList::OnContextMenu\n" , 0 );
|
|
|
|
DBGMSG( L"\tpoint x = %d " , pt.x );
|
|
|
|
DBGMSG( L"y = %d\n" , pt.y );
|
|
|
|
UINT flag;
|
|
|
|
int nItem = -1;
|
|
|
|
CListCtrl& listctrl = GetListCtrl();
|
|
|
|
// maybe keyboard selected this item
|
|
|
|
if(pt.x == -1 && pt.y == -1)
|
|
{
|
|
if( listctrl.GetSelectedCount( ) > 0 )
|
|
{
|
|
RECT rect;
|
|
|
|
nItem = listctrl.GetNextItem( nItem , LVNI_SELECTED );
|
|
|
|
if( nItem != ( int )LB_ERR )
|
|
{
|
|
listctrl.GetItemRect( nItem , &rect , LVIR_BOUNDS );
|
|
|
|
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 );
|
|
|
|
nItem = listctrl.HitTest( pt , &flag );
|
|
}
|
|
|
|
itemData = listctrl.GetItemData( nItem );
|
|
|
|
|
|
CLicMgrDoc * pDoc =(CLicMgrDoc *)GetDocument();
|
|
|
|
if(NULL == pDoc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ClientToScreen( &pt );
|
|
|
|
NODETYPE nt = pDoc->GetNodeType();
|
|
|
|
switch( nt )
|
|
{
|
|
case NODE_ALL_SERVERS:
|
|
{
|
|
CLicServer *pServer = reinterpret_cast< CLicServer* >( itemData );
|
|
|
|
SetActiveServer( pServer );
|
|
|
|
if( NULL == pServer )
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
DBGMSG( L"\tServer item selected\n", 0 );
|
|
|
|
menu.LoadMenu( IDR_MENU_LPK );
|
|
|
|
pContextMenu = menu.GetSubMenu( 0 );
|
|
|
|
nt = NODE_SERVER;
|
|
|
|
}
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
{
|
|
nt = NODE_KEYPACK;
|
|
|
|
CKeyPack *pKeyPack = reinterpret_cast< CKeyPack * >( itemData );
|
|
|
|
if(NULL == pKeyPack)
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
// SetActiveServer( NULL );
|
|
|
|
break;
|
|
}
|
|
|
|
SetActiveServer( pKeyPack->GetServer( ) );
|
|
|
|
DBGMSG( L"\tLicense pak item selected\n", 0 );
|
|
|
|
menu.LoadMenu( IDR_MENU_LPK );
|
|
|
|
pContextMenu = menu.GetSubMenu( 1 );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NODE_KEYPACK:
|
|
{
|
|
CLicense * pLicense = reinterpret_cast< CLicense * >( itemData );
|
|
|
|
if( pLicense == NULL )
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
// SetActiveServer( NULL );
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
CKeyPack *pKeyPack = pLicense->GetKeyPack( );
|
|
|
|
if( pKeyPack != NULL )
|
|
{
|
|
SetActiveServer( pKeyPack->GetServer( ) );
|
|
}
|
|
else
|
|
{
|
|
// impossible! a license with out a home
|
|
ASSERT( 0 );
|
|
}
|
|
|
|
/*
|
|
nt = NODE_NONE; // its safe
|
|
|
|
CLicense * pLicense = reinterpret_cast< CLicense * >( itemData );
|
|
|
|
if( pLicense == NULL )
|
|
{
|
|
DBGMSG( L"\tno item selected\n", 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
DBGMSG( L"\tLicense item selected\n", 0 );
|
|
|
|
menu.LoadMenu( IDR_MENU_LPK );
|
|
|
|
pContextMenu = menu.GetSubMenu( 2 );
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
UI_initmenu( pContextMenu , nt );
|
|
|
|
if( pContextMenu != NULL )
|
|
{
|
|
pContextMenu->TrackPopupMenu( TPM_LEFTALIGN , pt.x , pt.y , this );
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void CRightList::UI_initmenu( CMenu *pMenu , NODETYPE nt )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
pMainFrame->UI_initmenu( pMenu , nt );
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
DWORD CRightList::WizardActionOnServer( WIZACTION wa , PBOOL pbRefresh )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
return pMainFrame->WizardActionOnServer( wa , pbRefresh , LISTVIEW );
|
|
}
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnServerConnect( )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
pMainFrame->ConnectServer( );
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnRefreshAllServers( )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
pMainFrame->OnRefresh( );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnRefreshServer( )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
CLicServer *pServer = NULL;
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
CListCtrl& listctrl = GetListCtrl();
|
|
|
|
CLicMgrDoc * pDoc = (CLicMgrDoc *)GetDocument();
|
|
|
|
ASSERT(pDoc);
|
|
|
|
if(NULL == pDoc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int nSelected = listctrl.GetNextItem(-1, LVNI_SELECTED);
|
|
|
|
if( -1 != nSelected)
|
|
{
|
|
DWORD_PTR dCurrSel = listctrl.GetItemData( nSelected );
|
|
|
|
if( NODE_ALL_SERVERS == pDoc->GetNodeType() )
|
|
{
|
|
pServer = reinterpret_cast< CLicServer * >( dCurrSel );
|
|
}
|
|
else if( pDoc->GetNodeType() == NODE_SERVER )
|
|
{
|
|
CKeyPack *pKeyPack = reinterpret_cast< CKeyPack *>( dCurrSel );
|
|
|
|
if( pKeyPack != NULL )
|
|
{
|
|
pServer = pKeyPack->GetServer( );
|
|
}
|
|
}
|
|
else if( pDoc->GetNodeType( ) == NODE_KEYPACK )
|
|
{
|
|
CLicense * pLicense = reinterpret_cast< CLicense * >( dCurrSel );
|
|
|
|
pServer = ( pLicense->GetKeyPack() )->GetServer( );
|
|
}
|
|
}
|
|
|
|
|
|
if( pServer != NULL )
|
|
{
|
|
pMainFrame->RefreshServer( pServer );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnDownloadKeepPack()
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_DOWNLOADLKP , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnDownloadKeepPack StartWizard returned 0x%x\n" , dwStatus );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnRegisterServer()
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_REGISTERLS , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnRegisterServer StartWizard returned 0x%x\n" , dwStatus );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnRepeatLastDownload()
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_DOWNLOADLASTLKP , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnRepeatLastDownload StartWizard returned 0x%x\n" , dwStatus );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnReactivateServer( )
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_REREGISTERLS , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnReactivateServer StartWizard returned 0x%x\n" , dwStatus );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnDeactivateServer( )
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_UNREGISTERLS , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnDeactivateServer StartWizard returned 0x%x\n" , dwStatus );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnServerProperties( )
|
|
{
|
|
BOOL bRefresh;
|
|
|
|
DWORD dwStatus = WizardActionOnServer( WIZACTION_SHOWPROPERTIES , &bRefresh );
|
|
|
|
DBGMSG( L"LICMGR : CRightList::OnServerProperties StartWizard returned 0x%x\n" , dwStatus );
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::OnGeneralHelp( )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
pMainFrame->OnHelp( );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
void CRightList::SetActiveServer( CLicServer *pServer )
|
|
{
|
|
CMainFrame *pMainFrame = static_cast< CMainFrame * >( AfxGetMainWnd() );
|
|
|
|
if( pServer != NULL )
|
|
{
|
|
DBGMSG( L"LICMGR : CRightList::SetActiveServer %s\n" , (LPCTSTR)pServer->GetName( ) );
|
|
}
|
|
|
|
|
|
if( pMainFrame != NULL )
|
|
{
|
|
pMainFrame->SetActiveServer( pServer );
|
|
}
|
|
}
|
|
|