mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3166 lines
98 KiB
3166 lines
98 KiB
/*******************************************************************************
|
|
*
|
|
* allsrvpg.cpp
|
|
*
|
|
* implementations of the All Servers info pages
|
|
*
|
|
* copyright notice: Copyright 1997, Citrix Systems Inc.
|
|
* Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
*
|
|
* $Author: donm $ Don Messerli
|
|
*
|
|
* $Log: N:\nt\private\utils\citrix\winutils\tsadmin\VCS\allsrvpg.cpp $
|
|
*
|
|
* Rev 1.8 19 Feb 1998 20:01:44 donm
|
|
* removed latest extension DLL support
|
|
*
|
|
* Rev 1.7 19 Feb 1998 17:39:48 donm
|
|
* removed latest extension DLL support
|
|
*
|
|
* Rev 1.6 15 Feb 1998 09:14:56 donm
|
|
* update
|
|
*
|
|
* Rev 1.2 19 Jan 1998 17:36:06 donm
|
|
* new ui behavior for domains and servers
|
|
*
|
|
* Rev 1.5 19 Jan 1998 16:45:34 donm
|
|
* new ui behavior for domains and servers
|
|
*
|
|
* Rev 1.4 03 Nov 1997 15:18:28 donm
|
|
* Added descending sort
|
|
*
|
|
* Rev 1.3 18 Oct 1997 18:49:38 donm
|
|
* update
|
|
*
|
|
* Rev 1.2 13 Oct 1997 18:41:08 donm
|
|
* update
|
|
*
|
|
* Rev 1.1 26 Aug 1997 19:13:56 donm
|
|
* bug fixes/changes from WinFrame 1.7
|
|
*
|
|
* Rev 1.0 30 Jul 1997 17:10:18 butchd
|
|
* Initial revision.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
#include "winadmin.h"
|
|
#include "admindoc.h"
|
|
#include "allsrvpg.h"
|
|
|
|
#include <malloc.h> // for alloca used by Unicode conversion macros
|
|
#include <mfc42\afxconv.h> // for Unicode conversion macros
|
|
//USES_CONVERSION
|
|
static int _convert;
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
////////////////////////////////
|
|
// MESSAGE MAP: CAllServerServersPage
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAllServerServersPage, CFormView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAllServerServersPage, CFormView)
|
|
//{{AFX_MSG_MAP(CAllServerServersPage)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_SERVER_LIST, OnColumnclick)
|
|
ON_WM_CONTEXTMENU()
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_SERVER_LIST, OnServerItemChanged)
|
|
ON_NOTIFY(NM_SETFOCUS, IDC_SERVER_LIST, OnSetfocusServerList)
|
|
//ON_NOTIFY( NM_KILLFOCUS , IDC_SERVER_LIST , OnKillfocusServerList )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerServersPage ctor
|
|
//
|
|
CAllServerServersPage::CAllServerServersPage()
|
|
: CAdminPage(CAllServerServersPage::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAllServerServersPage)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bSortAscending = TRUE;
|
|
|
|
} // end CAllServerServersPage ctor
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerServersPage dtor
|
|
//
|
|
CAllServerServersPage::~CAllServerServersPage()
|
|
{
|
|
|
|
} // end CAllServerServersPage dtor
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerServersPage::DoDataExchange
|
|
//
|
|
void CAllServerServersPage::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAllServerServersPage)
|
|
DDX_Control(pDX, IDC_SERVER_LIST, m_ServerList);
|
|
//}}AFX_DATA_MAP
|
|
|
|
} // end CAllServerServersPage::DoDataExchange
|
|
|
|
|
|
#ifdef _DEBUG
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerServersPage::AssertValid
|
|
//
|
|
void CAllServerServersPage::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
|
|
} // end CAllServerServersPage::AssertValid
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::Dump
|
|
//
|
|
void CAllServerServersPage::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
|
|
} // end CAllServerServersPage::Dump
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::OnSize
|
|
//
|
|
void CAllServerServersPage::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
|
|
rect.top += LIST_TOP_OFFSET;
|
|
|
|
if(m_ServerList.GetSafeHwnd())
|
|
m_ServerList.MoveWindow(&rect, TRUE);
|
|
|
|
// CFormView::OnSize(nType, cx, cy);
|
|
|
|
} // end CAllServerServersPage::OnSize
|
|
|
|
|
|
static ColumnDef ServerColumns[] = {
|
|
CD_SERVER,
|
|
CD_TCPADDRESS,
|
|
CD_IPXADDRESS,
|
|
CD_NUM_SESSIONS
|
|
};
|
|
|
|
#define NUM_AS_SERVER_COLUMNS sizeof(ServerColumns)/sizeof(ColumnDef)
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::OnInitialUpdate
|
|
//
|
|
void CAllServerServersPage::OnInitialUpdate()
|
|
{
|
|
CFormView::OnInitialUpdate();
|
|
|
|
BuildImageList(); // builds the image list for the list control
|
|
|
|
CString columnString;
|
|
|
|
for(int col = 0; col < NUM_AS_SERVER_COLUMNS; col++) {
|
|
columnString.LoadString(ServerColumns[col].stringID);
|
|
m_ServerList.InsertColumn(col, columnString, ServerColumns[col].format, ServerColumns[col].width, col);
|
|
}
|
|
|
|
m_CurrentSortColumn = SERVERS_COL_SERVER;
|
|
|
|
} // end CAllServerServersPage::OnInitialUpdate
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerServersPage::BuildImageList
|
|
//
|
|
// - calls m_ImageList.Create(..) to create the image list
|
|
// - calls AddIconToImageList(..) to add the icons themselves and save
|
|
// off their indices
|
|
// - attaches the image list to the list ctrl
|
|
//
|
|
void CAllServerServersPage::BuildImageList()
|
|
{
|
|
m_ImageList.Create(16, 16, TRUE, 4, 0);
|
|
|
|
m_idxServer = AddIconToImageList(IDI_SERVER);
|
|
m_idxCurrentServer = AddIconToImageList(IDI_CURRENT_SERVER);
|
|
m_idxNotSign = AddIconToImageList(IDI_NOTSIGN);
|
|
m_idxQuestion = AddIconToImageList(IDI_QUESTIONMARK);
|
|
|
|
m_ImageList.SetOverlayImage(m_idxNotSign, 1);
|
|
m_ImageList.SetOverlayImage(m_idxQuestion, 2);
|
|
|
|
m_ServerList.SetImageList(&m_ImageList, LVSIL_SMALL);
|
|
|
|
} // end CAllServerServersPage::BuildImageList
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAllServerServersPage::AddIconToImageList
|
|
//
|
|
// - loads the appropriate icon, adds it to m_ImageList, and returns
|
|
// the newly-added icon's index in the image list
|
|
//
|
|
int CAllServerServersPage::AddIconToImageList(int iconID)
|
|
{
|
|
HICON hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(iconID));
|
|
return m_ImageList.Add(hIcon);
|
|
|
|
} // end CAllServerServersPage::AddIconToImageList
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::Reset
|
|
//
|
|
void CAllServerServersPage::Reset(void *p)
|
|
{
|
|
CTreeNode *pT = ( CTreeNode * )p;
|
|
|
|
if( pT != NULL )
|
|
{
|
|
DisplayServers( pT->GetNodeType( ) );
|
|
}
|
|
else
|
|
{
|
|
DisplayServers( NODE_NONE );
|
|
}
|
|
|
|
} // end CAllServerServersPage::Reset
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::AddServer
|
|
//
|
|
void CAllServerServersPage::AddServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// We have to make sure the server isn't already in the list
|
|
// Add the server to the list
|
|
if(AddServerToList(pServer)) {
|
|
// Tell the list to sort itself
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_SERVERS, &m_ServerList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
}
|
|
|
|
} // end CAllServerServersPage::AddServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::RemoveServer
|
|
//
|
|
void CAllServerServersPage::RemoveServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
LockListControl();
|
|
// Find out how many items in the list
|
|
int ItemCount = m_ServerList.GetItemCount();
|
|
|
|
// Go through the items are remove this server
|
|
for(int item = 0; item < ItemCount; item++) {
|
|
CServer *pListServer = (CServer*)m_ServerList.GetItemData(item);
|
|
|
|
if(pListServer == pServer) {
|
|
m_ServerList.DeleteItem(item);
|
|
pServer->ClearAllSelected();
|
|
break;
|
|
}
|
|
}
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerServersPage::RemoveServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::UpdateServer
|
|
//
|
|
void CAllServerServersPage::UpdateServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// If we aren't connected to the server anymore, remove it from the list control
|
|
if(pServer->IsState(SS_NOT_CONNECTED)) {
|
|
RemoveServer(pServer);
|
|
return;
|
|
}
|
|
|
|
// If we just connected to this server, add it to the list control
|
|
if(pServer->IsState(SS_GOOD)) {
|
|
AddServer(pServer);
|
|
return;
|
|
}
|
|
|
|
LockListControl();
|
|
// Find the Server in the list
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.lParam = (LPARAM)pServer;
|
|
|
|
// Find the Server in our list
|
|
int item = m_ServerList.FindItem(&FindInfo, -1);
|
|
if(item != -1) {
|
|
// Change the icon overlay
|
|
USHORT NewState;
|
|
// Change the icon/overlay for the server
|
|
// If the server isn't sane, put a not sign over the icon
|
|
if(!pServer->IsServerSane()) NewState = STATE_NOT;
|
|
// If we aren't done getting all the information about this server,
|
|
// put a question mark over the icon
|
|
else if(!pServer->IsState(SS_GOOD)) NewState = STATE_QUESTION;
|
|
// If it is fine, we want to remove any overlays from the icon
|
|
else NewState = STATE_NORMAL;
|
|
|
|
// Set the tree item to the new state
|
|
m_ServerList.SetItemState(item, NewState, 0x0F00);
|
|
|
|
ExtServerInfo *pExtServerInfo = pServer->GetExtendedInfo();
|
|
|
|
// TCP Address
|
|
m_ServerList.SetItemText(item, SERVERS_COL_TCPADDRESS, pExtServerInfo->TcpAddress);
|
|
|
|
// IPX Address
|
|
m_ServerList.SetItemText(item, SERVERS_COL_IPXADDRESS, pExtServerInfo->IpxAddress);
|
|
|
|
CString NumString;
|
|
if(pExtServerInfo && (pExtServerInfo->Flags & ESF_WINFRAME)) {
|
|
NumString.Format(TEXT("%lu"), pExtServerInfo->ServerTotalInUse);
|
|
} else {
|
|
NumString.LoadString(IDS_NOT_APPLICABLE);
|
|
}
|
|
|
|
m_ServerList.SetItemText(item, SERVERS_COL_NUMWINSTATIONS, NumString);
|
|
}
|
|
|
|
// Tell the list to sort itself
|
|
if(m_CurrentSortColumn == SERVERS_COL_NUMWINSTATIONS
|
|
|| m_CurrentSortColumn == SERVERS_COL_TCPADDRESS
|
|
|| m_CurrentSortColumn == SERVERS_COL_IPXADDRESS)
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_SERVERS, &m_ServerList, m_CurrentSortColumn, m_bSortAscending);
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerServersPage::UpdateServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::AddServerToList
|
|
//
|
|
BOOL CAllServerServersPage::AddServerToList(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// If we aren't currently connected to the server, don't display it
|
|
if(!pServer->IsState(SS_GOOD)) return FALSE;
|
|
|
|
LockListControl();
|
|
|
|
// Find the Server in the list
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.lParam = (LPARAM)pServer;
|
|
|
|
// Find the Server in our list
|
|
int item = m_ServerList.FindItem(&FindInfo, -1);
|
|
if(item != -1) return FALSE;
|
|
|
|
//////////////////////
|
|
// Fill in the columns
|
|
//////////////////////
|
|
// Name - put at the end of the list
|
|
item = m_ServerList.InsertItem(m_ServerList.GetItemCount(), pServer->GetName(),
|
|
pServer->IsCurrentServer() ? m_idxCurrentServer : m_idxServer);
|
|
|
|
// If the server isn't sane, put a not sign over the icon
|
|
if(!pServer->IsServerSane()) m_ServerList.SetItemState(item, STATE_NOT, 0x0F00);
|
|
// If we aren't done getting all the information about this server,
|
|
// put a question mark over the icon
|
|
else if(!pServer->IsState(SS_GOOD)) m_ServerList.SetItemState(item, STATE_QUESTION, 0x0F00);
|
|
|
|
ExtServerInfo *pExtServerInfo = pServer->GetExtendedInfo();
|
|
|
|
// TCP Address
|
|
m_ServerList.SetItemText(item, SERVERS_COL_TCPADDRESS, pExtServerInfo->TcpAddress);
|
|
|
|
// IPX Address
|
|
m_ServerList.SetItemText(item, SERVERS_COL_IPXADDRESS, pExtServerInfo->IpxAddress);
|
|
|
|
// Connected
|
|
CString NumString;
|
|
if(pExtServerInfo && (pExtServerInfo->Flags & ESF_WINFRAME)) {
|
|
NumString.Format(TEXT("%lu"), pExtServerInfo->ServerTotalInUse);
|
|
} else {
|
|
NumString.LoadString(IDS_NOT_APPLICABLE);
|
|
}
|
|
|
|
m_ServerList.SetItemText(item, SERVERS_COL_NUMWINSTATIONS, NumString);
|
|
|
|
m_ServerList.SetItemData(item, (DWORD_PTR)pServer);
|
|
|
|
UnlockListControl();
|
|
|
|
return TRUE;
|
|
|
|
} // end CAllServerServersPage::AddServerToList
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerServersPage::DisplayServers
|
|
//
|
|
void CAllServerServersPage::DisplayServers( NODETYPE ntType )
|
|
{
|
|
LockListControl();
|
|
|
|
// Clear out the list control
|
|
m_ServerList.DeleteAllItems();
|
|
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *doc = (CWinAdminDoc*)GetDocument();
|
|
|
|
// Get a pointer to the list of servers
|
|
doc->LockServerList();
|
|
CObList *pServerList = doc->GetServerList();
|
|
|
|
// Iterate through the Server list
|
|
POSITION pos = pServerList->GetHeadPosition();
|
|
|
|
while(pos)
|
|
{
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos);
|
|
|
|
// check to see if its just for favorites
|
|
if( ntType == NODE_FAV_LIST )
|
|
{
|
|
if( pServer->GetTreeItemFromFav() != NULL )
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
}
|
|
else if( ntType == NODE_THIS_COMP )
|
|
{
|
|
if( pServer->GetTreeItemFromThisComputer( ) != NULL )
|
|
{
|
|
AddServerToList( pServer );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
|
|
} // end while(pos)
|
|
|
|
doc->UnlockServerList();
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerServersPage::DisplayServers
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::OnServerItemChanged
|
|
//
|
|
void CAllServerServersPage::OnServerItemChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW *pLV = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
CServer *pServer = (CServer*)m_ServerList.GetItemData(pLV->iItem);
|
|
|
|
if(pLV->uNewState & LVIS_SELECTED) {
|
|
pServer->SetSelected();
|
|
}
|
|
|
|
if(pLV->uOldState & LVIS_SELECTED && !(pLV->uNewState & LVIS_SELECTED)) {
|
|
pServer->ClearSelected();
|
|
}
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerServersPage::OnServerItemChanged
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::OnColumnclick
|
|
//
|
|
void CAllServerServersPage::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
// If the sort column hasn't changed, flip the ascending mode.
|
|
if(m_CurrentSortColumn == pNMListView->iSubItem)
|
|
m_bSortAscending = !m_bSortAscending;
|
|
else // New sort column, start in ascending mode
|
|
m_bSortAscending = TRUE;
|
|
|
|
m_CurrentSortColumn = pNMListView->iSubItem;
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_SERVERS, &m_ServerList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerServersPage::OnColumnclick
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerServersPage::OnContextMenu
|
|
//
|
|
void CAllServerServersPage::OnContextMenu(CWnd* pWnd, CPoint ptScreen)
|
|
{
|
|
// TODO: Add your message handler code here
|
|
UINT flags;
|
|
UINT Item;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
// If we got here from the keyboard,
|
|
if(ptScreen.x == -1 && ptScreen.y == -1) {
|
|
|
|
UINT iCount = m_ServerList.GetItemCount( );
|
|
|
|
RECT rc;
|
|
|
|
for( Item = 0 ; Item < iCount ; Item++ )
|
|
{
|
|
if( m_ServerList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
m_ServerList.GetItemRect( Item , &rc , LVIR_ICON );
|
|
|
|
ptScreen.x = rc.left;
|
|
|
|
ptScreen.y = rc.bottom + 5;
|
|
|
|
ClientToScreen( &ptScreen );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ptScreen.x == -1 && ptScreen.y == -1)
|
|
{
|
|
return;
|
|
}
|
|
/*
|
|
RECT rect;
|
|
m_ServerList.GetClientRect(&rect);
|
|
ptScreen.x = (rect.right - rect.left) / 2;
|
|
ptScreen.y = (rect.bottom - rect.top) / 2;
|
|
ClientToScreen(&ptScreen);
|
|
*/
|
|
}
|
|
else {
|
|
Item = m_ServerList.HitTest(ptClient, &flags);
|
|
if((Item == 0xFFFFFFFF) || !(flags & LVHT_ONITEM))
|
|
return;
|
|
}
|
|
|
|
CMenu menu;
|
|
menu.LoadMenu(IDR_SERVER_POPUP);
|
|
// set the temp selected item so that handler doesn't think
|
|
// this came from the tree
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *doc = (CWinAdminDoc*)GetDocument();
|
|
doc->SetTreeTemp(NULL, NODE_NONE);
|
|
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON |
|
|
TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
menu.DestroyMenu();
|
|
|
|
} // end CAllServerServersPage::OnContextMenu
|
|
|
|
|
|
////////////////////////////////
|
|
// MESSAGE MAP: CAllServerUsersPage
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAllServerUsersPage, CFormView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAllServerUsersPage, CFormView)
|
|
//{{AFX_MSG_MAP(CAllServerUsersPage)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_USER_LIST, OnColumnclick)
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_USER_LIST, OnUserItemChanged)
|
|
ON_WM_CONTEXTMENU()
|
|
ON_NOTIFY(NM_SETFOCUS, IDC_USER_LIST, OnSetfocusUserList)
|
|
//ON_NOTIFY( NM_KILLFOCUS , IDC_USER_LIST , OnKillfocusUserList )
|
|
// ON_WM_SETFOCUS( )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerUsersPage ctor
|
|
//
|
|
CAllServerUsersPage::CAllServerUsersPage()
|
|
: CAdminPage(CAllServerUsersPage::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAllServerUsersPage)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bSortAscending = TRUE;
|
|
|
|
} // end CAllServerUsersPage ctor
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerUsersPage dtor
|
|
//
|
|
CAllServerUsersPage::~CAllServerUsersPage()
|
|
{
|
|
} // end CAllServerUsersPage dtor
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::DoDataExchange
|
|
//
|
|
void CAllServerUsersPage::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAllServerUsersPage)
|
|
DDX_Control(pDX, IDC_USER_LIST, m_UserList);
|
|
//}}AFX_DATA_MAP
|
|
|
|
} // end CAllServerUsersPage::DoDataExchange
|
|
|
|
|
|
#ifdef _DEBUG
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::AssertValid
|
|
//
|
|
void CAllServerUsersPage::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
|
|
} // end CAllServerUsersPage::AssertValid
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::Dump
|
|
//
|
|
void CAllServerUsersPage::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
|
|
} // end CAllServerUsersPage::Dump
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::OnSize
|
|
//
|
|
void CAllServerUsersPage::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
|
|
rect.top += LIST_TOP_OFFSET;
|
|
|
|
if(m_UserList.GetSafeHwnd())
|
|
m_UserList.MoveWindow(&rect, TRUE);
|
|
|
|
// CFormView::OnSize(nType, cx, cy);
|
|
} // end CAllServerUsersPage::OnSize
|
|
|
|
|
|
static ColumnDef UserColumns[] = {
|
|
CD_SERVER,
|
|
CD_USER3,
|
|
CD_SESSION,
|
|
CD_ID,
|
|
CD_STATE,
|
|
CD_IDLETIME,
|
|
CD_LOGONTIME
|
|
};
|
|
|
|
#define NUM_AS_USER_COLUMNS sizeof(UserColumns)/sizeof(ColumnDef)
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::OnInitialUpdate
|
|
//
|
|
void CAllServerUsersPage::OnInitialUpdate()
|
|
{
|
|
CFormView::OnInitialUpdate();
|
|
|
|
BuildImageList(); // builds the image list for the list control
|
|
|
|
CString columnString;
|
|
|
|
for(int col = 0; col < NUM_AS_USER_COLUMNS; col++) {
|
|
columnString.LoadString(UserColumns[col].stringID);
|
|
m_UserList.InsertColumn(col, columnString, UserColumns[col].format, UserColumns[col].width, col);
|
|
}
|
|
|
|
m_CurrentSortColumn = AS_USERS_COL_SERVER;
|
|
|
|
} // end CAllServerUsersPage::OnInitialUpdate
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::OnUserItemChanged
|
|
//
|
|
void CAllServerUsersPage::OnUserItemChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW *pLV = (NM_LISTVIEW*)pNMHDR;
|
|
|
|
if(pLV->uNewState & LVIS_SELECTED)
|
|
{
|
|
CWinStation *pWinStation = (CWinStation*)m_UserList.GetItemData(pLV->iItem);
|
|
pWinStation->SetSelected();
|
|
}
|
|
|
|
if(pLV->uOldState & LVIS_SELECTED && !(pLV->uNewState & LVIS_SELECTED))
|
|
{
|
|
CWinStation *pWinStation = (CWinStation*)m_UserList.GetItemData(pLV->iItem);
|
|
pWinStation->ClearSelected();
|
|
}
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerUsersPage::OnUserItemChanged
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::BuildImageList
|
|
//
|
|
// - calls m_ImageList.Create(..) to create the image list
|
|
// - calls AddIconToImageList(..) to add the icons themselves and save
|
|
// off their indices
|
|
// - attaches the image list to the list ctrl
|
|
//
|
|
void CAllServerUsersPage::BuildImageList()
|
|
{
|
|
m_ImageList.Create(16, 16, TRUE, 2, 0);
|
|
|
|
m_idxUser = AddIconToImageList(IDI_USER);
|
|
m_idxCurrentUser = AddIconToImageList(IDI_CURRENT_USER);
|
|
|
|
m_UserList.SetImageList(&m_ImageList, LVSIL_SMALL);
|
|
|
|
} // end CAllServerUsersPage::BuildImageList
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::AddIconToImageList
|
|
//
|
|
// - loads the appropriate icon, adds it to m_ImageList, and returns
|
|
// the newly-added icon's index in the image list
|
|
//
|
|
int CAllServerUsersPage::AddIconToImageList(int iconID)
|
|
{
|
|
HICON hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(iconID));
|
|
return m_ImageList.Add(hIcon);
|
|
|
|
} // end CAllServerUsersPage::AddIconToImageList
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::Reset
|
|
//
|
|
void CAllServerUsersPage::Reset(void *p)
|
|
{
|
|
CTreeNode *pT = ( CTreeNode * )p;
|
|
|
|
if( pT != NULL )
|
|
{
|
|
DisplayUsers( pT->GetNodeType() );
|
|
}
|
|
else
|
|
{
|
|
DisplayUsers( NODE_NONE );
|
|
}
|
|
|
|
} // end CAllServerUsersPage::Reset
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::AddServer
|
|
//
|
|
void CAllServerUsersPage::AddServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// Add the server's users to the list
|
|
if(AddServerToList(pServer)) {
|
|
// Sort the list
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_USERS, &m_UserList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
}
|
|
|
|
} // end CAllServerUsersPage::AddServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::RemoveServer
|
|
//
|
|
void CAllServerUsersPage::RemoveServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
LockListControl();
|
|
|
|
int ItemCount = m_UserList.GetItemCount();
|
|
|
|
// We need to go through the list backward so that we can remove
|
|
// more than one item without the item numbers getting messed up
|
|
for(int item = ItemCount; item; item--) {
|
|
CWinStation *pWinStation = (CWinStation*)m_UserList.GetItemData(item-1);
|
|
CServer *pListServer = pWinStation->GetServer();
|
|
|
|
if(pListServer == pServer) {
|
|
m_UserList.DeleteItem(item-1);
|
|
pServer->ClearAllSelected();
|
|
}
|
|
}
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerUsersPage::RemoveServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::UpdateServer
|
|
//
|
|
void CAllServerUsersPage::UpdateServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
if(pServer->IsState(SS_DISCONNECTING))
|
|
RemoveServer(pServer);
|
|
|
|
} // end CAllServerUsersPage::UpdateServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::UpdateWinStations
|
|
//
|
|
void CAllServerUsersPage::UpdateWinStations(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)((CWinAdminApp*)AfxGetApp())->GetDocument();
|
|
BOOL bAnyChanged = FALSE;
|
|
BOOL bAnyAdded = FALSE;
|
|
|
|
// Loop through the WinStations
|
|
pServer->LockWinStationList();
|
|
CObList *pWinStationList = pServer->GetWinStationList();
|
|
|
|
POSITION pos = pWinStationList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CWinStation *pWinStation = (CWinStation*)pWinStationList->GetNext(pos);
|
|
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.lParam = (LPARAM)pWinStation;
|
|
|
|
// Find the WinStation in our list
|
|
int item = m_UserList.FindItem(&FindInfo, -1);
|
|
|
|
// If the WinStation is new and isn't currently in the list,
|
|
// add it to the list
|
|
if(pWinStation->IsNew() && pWinStation->HasUser() && item == -1) {
|
|
|
|
AddUserToList(pWinStation);
|
|
bAnyAdded = TRUE;
|
|
continue;
|
|
}
|
|
|
|
// If the WinStation is no longer current,
|
|
// remove it from the list
|
|
if((!pWinStation->IsCurrent() || !pWinStation->HasUser()) && item != -1) {
|
|
// Remove the WinStation from the list
|
|
m_UserList.DeleteItem(item);
|
|
pWinStation->ClearSelected();
|
|
continue;
|
|
}
|
|
|
|
// If the WinStation info has changed, change
|
|
// it's info in our tree
|
|
if(pWinStation->IsChanged() && item != -1) {
|
|
// change the user name
|
|
m_UserList.SetItemText(item, AS_USERS_COL_USER, pWinStation->GetUserName());
|
|
// change the WinStation Name
|
|
if(pWinStation->GetName()[0])
|
|
m_UserList.SetItemText(item, AS_USERS_COL_WINSTATION, pWinStation->GetName());
|
|
else {
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_UserList.SetItemText(item, AS_USERS_COL_WINSTATION, NameString);
|
|
}
|
|
|
|
|
|
// change the Connect State
|
|
m_UserList.SetItemText(item, AS_USERS_COL_STATE, StrConnectState(pWinStation->GetState(), FALSE));
|
|
// change the Idle Time
|
|
TCHAR IdleTimeString[MAX_ELAPSED_TIME_LENGTH];
|
|
|
|
ELAPSEDTIME IdleTime = pWinStation->GetIdleTime();
|
|
|
|
if(IdleTime.days || IdleTime.hours || IdleTime.minutes || IdleTime.seconds)
|
|
{
|
|
ElapsedTimeString( &IdleTime, FALSE, IdleTimeString);
|
|
}
|
|
else wcscpy(IdleTimeString, TEXT("."));
|
|
|
|
m_UserList.SetItemText(item, AS_USERS_COL_IDLETIME, IdleTimeString);
|
|
// change the Logon Time
|
|
TCHAR LogonTimeString[MAX_DATE_TIME_LENGTH];
|
|
// We don't want to pass a 0 logon time to DateTimeString()
|
|
// It will blow up if the timezone is GMT
|
|
if(pWinStation->GetState() == State_Active && pWinStation->GetLogonTime().QuadPart) {
|
|
DateTimeString(&(pWinStation->GetLogonTime()), LogonTimeString);
|
|
pDoc->FixUnknownString(LogonTimeString);
|
|
}
|
|
else LogonTimeString[0] = '\0';
|
|
// change the
|
|
|
|
m_UserList.SetItemText(item, AS_USERS_COL_LOGONTIME, LogonTimeString);
|
|
|
|
if(m_CurrentSortColumn != AS_USERS_COL_ID)
|
|
bAnyChanged = TRUE;
|
|
|
|
continue;
|
|
}
|
|
|
|
// If the WinStation is not in the list but now has a user, add it to the list
|
|
if(item == -1 && pWinStation->IsCurrent() && pWinStation->HasUser()) {
|
|
AddUserToList(pWinStation);
|
|
bAnyAdded = TRUE;
|
|
}
|
|
}
|
|
|
|
pServer->UnlockWinStationList();
|
|
|
|
if(bAnyChanged || bAnyAdded) SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_USERS, &m_UserList, m_CurrentSortColumn, m_bSortAscending);
|
|
|
|
} // end CAllServerUsersPage::UpdateWinStations
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::AddUserToList
|
|
//
|
|
int CAllServerUsersPage::AddUserToList(CWinStation *pWinStation)
|
|
{
|
|
ASSERT(pWinStation);
|
|
|
|
CServer *pServer = pWinStation->GetServer();
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)((CWinAdminApp*)AfxGetApp())->GetDocument();
|
|
|
|
LockListControl();
|
|
//////////////////////
|
|
// Fill in the columns
|
|
//////////////////////
|
|
// Server - put at the end of the list
|
|
int item = m_UserList.InsertItem(m_UserList.GetItemCount(), pServer->GetName(),
|
|
pWinStation->IsCurrentUser() ? m_idxCurrentUser : m_idxUser);
|
|
|
|
// User
|
|
m_UserList.SetItemText(item, AS_USERS_COL_USER, pWinStation->GetUserName());
|
|
|
|
// WinStation Name
|
|
if(pWinStation->GetName()[0])
|
|
m_UserList.SetItemText(item, AS_USERS_COL_WINSTATION, pWinStation->GetName());
|
|
else {
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_UserList.SetItemText(item, AS_USERS_COL_WINSTATION, NameString);
|
|
}
|
|
|
|
// Logon ID
|
|
CString ColumnString;
|
|
ColumnString.Format(TEXT("%lu"), pWinStation->GetLogonId());
|
|
m_UserList.SetItemText(item, AS_USERS_COL_ID, ColumnString);
|
|
|
|
// Connect State
|
|
m_UserList.SetItemText(item, AS_USERS_COL_STATE, StrConnectState(pWinStation->GetState(), FALSE));
|
|
|
|
// Idle Time
|
|
TCHAR IdleTimeString[MAX_ELAPSED_TIME_LENGTH];
|
|
|
|
ELAPSEDTIME IdleTime = pWinStation->GetIdleTime();
|
|
|
|
if(IdleTime.days || IdleTime.hours || IdleTime.minutes || IdleTime.seconds)
|
|
{
|
|
ElapsedTimeString( &IdleTime, FALSE, IdleTimeString);
|
|
}
|
|
else wcscpy(IdleTimeString, TEXT("."));
|
|
|
|
m_UserList.SetItemText(item, AS_USERS_COL_IDLETIME, IdleTimeString);
|
|
|
|
// Logon Time
|
|
TCHAR LogonTimeString[MAX_DATE_TIME_LENGTH];
|
|
// We don't want to pass a 0 logon time to DateTimeString()
|
|
// It will blow up if the timezone is GMT
|
|
if(pWinStation->GetState() == State_Active && pWinStation->GetLogonTime().QuadPart) {
|
|
DateTimeString(&(pWinStation->GetLogonTime()), LogonTimeString);
|
|
pDoc->FixUnknownString(LogonTimeString);
|
|
}
|
|
else LogonTimeString[0] = '\0';
|
|
|
|
m_UserList.SetItemText(item, AS_USERS_COL_LOGONTIME, LogonTimeString);
|
|
|
|
// Attach a pointer to the CWinStation structure to the list item
|
|
m_UserList.SetItemData(item, (DWORD_PTR)pWinStation);
|
|
|
|
//bug #191727
|
|
//m_UserList.SetItemState( 0 , LVIS_FOCUSED | LVIS_SELECTED , LVIS_FOCUSED | LVIS_SELECTED );
|
|
|
|
UnlockListControl();
|
|
|
|
return item;
|
|
|
|
} // end CAllServerUsersPage::AddUserToList
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::AddServerToList
|
|
//
|
|
BOOL CAllServerUsersPage::AddServerToList(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
pServer->LockWinStationList();
|
|
// Get a pointer to this server's list of WinStations
|
|
CObList *pWinStationList = pServer->GetWinStationList();
|
|
|
|
// Iterate through the WinStation list
|
|
POSITION pos = pWinStationList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CWinStation *pWinStation = (CWinStation*)pWinStationList->GetNext(pos);
|
|
|
|
// only show the WinStation if it has a user
|
|
if(pWinStation->HasUser()) {
|
|
AddUserToList(pWinStation);
|
|
}
|
|
} // end while(pos)
|
|
|
|
pServer->UnlockWinStationList();
|
|
|
|
return TRUE;
|
|
|
|
} // end CAllServerUsersPage::AddServerToList
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::OnColumnclick
|
|
//
|
|
void CAllServerUsersPage::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
// If the sort column hasn't changed, flip the ascending mode.
|
|
if(m_CurrentSortColumn == pNMListView->iSubItem)
|
|
m_bSortAscending = !m_bSortAscending;
|
|
else // New sort column, start in ascending mode
|
|
m_bSortAscending = TRUE;
|
|
|
|
m_CurrentSortColumn = pNMListView->iSubItem;
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_USERS, &m_UserList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerUsersPage::OnColumnclick
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerUsersPage::OnContextMenu
|
|
//
|
|
void CAllServerUsersPage::OnContextMenu(CWnd* pWnd, CPoint ptScreen)
|
|
{
|
|
// TODO: Add your message handler code here
|
|
UINT flags;
|
|
UINT Item;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
// If we got here from the keyboard,
|
|
if(ptScreen.x == -1 && ptScreen.y == -1) {
|
|
|
|
UINT iCount = m_UserList.GetItemCount( );
|
|
|
|
RECT rc;
|
|
|
|
for( Item = 0 ; Item < iCount ; Item++ )
|
|
{
|
|
if( m_UserList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
m_UserList.GetItemRect( Item , &rc , LVIR_ICON );
|
|
|
|
ptScreen.x = rc.left;
|
|
|
|
ptScreen.y = rc.bottom + 5;
|
|
|
|
ClientToScreen( &ptScreen );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ptScreen.x == -1 && ptScreen.y == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
RECT rect;
|
|
m_UserList.GetClientRect(&rect);
|
|
ptScreen.x = (rect.right - rect.left) / 2;
|
|
ptScreen.y = (rect.bottom - rect.top) / 2;
|
|
ClientToScreen(&ptScreen);
|
|
*/
|
|
}
|
|
else {
|
|
Item = m_UserList.HitTest(ptClient, &flags);
|
|
if((Item == 0xFFFFFFFF) || !(flags & LVHT_ONITEM))
|
|
{
|
|
//
|
|
// ListView HitTest bug? return -1 but item display as selected.
|
|
// workaround for now, Al can fix this later
|
|
//
|
|
UINT iCount = m_UserList.GetItemCount( );
|
|
RECT rc;
|
|
|
|
for( Item = 0 ; Item < iCount ; Item++ )
|
|
{
|
|
if( m_UserList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( Item >= iCount )
|
|
{
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// NM_RCLICK (WM_NOTIFY) then WM_CNTEXTMENU but no NM_ITEMCHANGED message
|
|
// manually set it to selected state
|
|
//
|
|
CWinStation *pWinStation = (CWinStation*)m_UserList.GetItemData(Item);
|
|
|
|
if( !pWinStation )
|
|
return;
|
|
|
|
if( m_UserList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
pWinStation->SetSelected();
|
|
}
|
|
}
|
|
|
|
CMenu menu;
|
|
|
|
menu.LoadMenu(IDR_USER_POPUP);
|
|
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON |
|
|
TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
menu.DestroyMenu();
|
|
|
|
} // end CAllServerUsersPage::OnContextMenu
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::DisplayUsers
|
|
//
|
|
void CAllServerUsersPage::DisplayUsers( NODETYPE ntType )
|
|
{
|
|
LockListControl();
|
|
|
|
// Clear out the list control
|
|
m_UserList.DeleteAllItems();
|
|
|
|
// Get a pointer to the document's list of servers
|
|
CObList* pServerList = ((CWinAdminDoc*)GetDocument())->GetServerList();
|
|
|
|
((CWinAdminDoc*)GetDocument())->LockServerList();
|
|
// Iterate through the server list
|
|
POSITION pos2 = pServerList->GetHeadPosition();
|
|
|
|
while(pos2)
|
|
{
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos2);
|
|
|
|
if( ntType == NODE_FAV_LIST )
|
|
{
|
|
if( pServer->GetTreeItemFromFav() != NULL )
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
}
|
|
else if( ntType == NODE_THIS_COMP )
|
|
{
|
|
if( pServer->GetTreeItemFromThisComputer() != NULL )
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddServerToList( pServer );
|
|
}
|
|
} // end while(pos2)
|
|
|
|
((CWinAdminDoc*)GetDocument())->UnlockServerList();
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerUsersPage::DisplayUsers
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerUsersPage::ClearSelections
|
|
//
|
|
void CAllServerUsersPage::ClearSelections()
|
|
{
|
|
|
|
if(m_UserList.m_hWnd != NULL)
|
|
{
|
|
POSITION pos = m_UserList.GetFirstSelectedItemPosition();
|
|
while (pos)
|
|
{
|
|
int nItem = m_UserList.GetNextSelectedItem(pos);
|
|
// you could do your own processing on nItem here
|
|
m_UserList.SetItemState(nItem,0,LVIS_SELECTED);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////
|
|
// MESSAGE MAP: CAllServerWinStationsPage
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAllServerWinStationsPage, CFormView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAllServerWinStationsPage, CFormView)
|
|
//{{AFX_MSG_MAP(CAllServerWinStationsPage)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_WINSTATION_LIST, OnColumnclick)
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_WINSTATION_LIST, OnWinStationItemChanged)
|
|
ON_WM_CONTEXTMENU()
|
|
ON_NOTIFY(NM_SETFOCUS, IDC_WINSTATION_LIST, OnSetfocusWinstationList)
|
|
//ON_NOTIFY( NM_KILLFOCUS , IDC_WINSTATION_LIST , OnKillfocusWinstationList )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerWinStationsPage ctor
|
|
//
|
|
CAllServerWinStationsPage::CAllServerWinStationsPage()
|
|
: CAdminPage(CAllServerWinStationsPage::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAllServerWinStationsPage)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bSortAscending = TRUE;
|
|
|
|
} // end CAllServerWinStationsPage ctor
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerWinStationsPage dtor
|
|
//
|
|
CAllServerWinStationsPage::~CAllServerWinStationsPage()
|
|
{
|
|
|
|
} // end CAllServerWinStationsPage dtor
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::DoDataExchange
|
|
//
|
|
void CAllServerWinStationsPage::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAllServerWinStationsPage)
|
|
DDX_Control(pDX, IDC_WINSTATION_LIST, m_StationList);
|
|
//}}AFX_DATA_MAP
|
|
|
|
} // end CAllServerWinStationsPage::DoDataExchange
|
|
|
|
|
|
#ifdef _DEBUG
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::AssertValid
|
|
//
|
|
void CAllServerWinStationsPage::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
|
|
} // end CAllServerWinStationsPage::AssertValid
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::Dump
|
|
//
|
|
void CAllServerWinStationsPage::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
|
|
} // end CAllServerWinStationsPage::Dump
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::OnWinStationItemChanged
|
|
//
|
|
void CAllServerWinStationsPage::OnWinStationItemChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW *pLV = (NM_LISTVIEW*)pNMHDR;
|
|
|
|
|
|
if(pLV->uNewState & LVIS_SELECTED)
|
|
{
|
|
CWinStation *pWinStation = (CWinStation*)m_StationList.GetItemData(pLV->iItem);
|
|
pWinStation->SetSelected();
|
|
}
|
|
if(pLV->uOldState & LVIS_SELECTED && !(pLV->uNewState & LVIS_SELECTED))
|
|
{
|
|
CWinStation *pWinStation = (CWinStation*)m_StationList.GetItemData(pLV->iItem);
|
|
pWinStation->ClearSelected();
|
|
}
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerWinStationsPage::OnWinStationItemChanged
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::OnSize
|
|
//
|
|
void CAllServerWinStationsPage::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
|
|
rect.top += LIST_TOP_OFFSET;
|
|
|
|
if(m_StationList.GetSafeHwnd())
|
|
m_StationList.MoveWindow(&rect, TRUE);
|
|
|
|
// CFormView::OnSize(nType, cx, cy);
|
|
|
|
} // end CAllServerWinStationsPage::OnSize
|
|
|
|
|
|
static ColumnDef WinsColumns[] = {
|
|
CD_SERVER,
|
|
CD_SESSION2,
|
|
CD_USER2,
|
|
CD_ID,
|
|
CD_STATE,
|
|
CD_TYPE,
|
|
CD_CLIENT_NAME,
|
|
CD_IDLETIME,
|
|
CD_LOGONTIME,
|
|
CD_COMMENT
|
|
};
|
|
|
|
#define NUM_AS_WINS_COLUMNS sizeof(WinsColumns)/sizeof(ColumnDef)
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::OnInitialUpdate
|
|
//
|
|
void CAllServerWinStationsPage::OnInitialUpdate()
|
|
{
|
|
// Call the parent class
|
|
CFormView::OnInitialUpdate();
|
|
|
|
// builds the image list for the list control
|
|
BuildImageList();
|
|
|
|
// Add the column headings
|
|
CString columnString;
|
|
|
|
for(int col = 0; col < NUM_AS_WINS_COLUMNS; col++) {
|
|
columnString.LoadString(WinsColumns[col].stringID);
|
|
m_StationList.InsertColumn(col, columnString, WinsColumns[col].format, WinsColumns[col].width, col);
|
|
}
|
|
|
|
m_CurrentSortColumn = AS_WS_COL_SERVER;
|
|
|
|
} // end CAllServerWinStationsPage::OnInitialUpdate
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::BuildImageList
|
|
//
|
|
// - calls m_ImageList.Create(..) to create the image list
|
|
// - calls AddIconToImageList(..) to add the icons themselves and save
|
|
// off their indices
|
|
// - attaches the image list to the list ctrl
|
|
//
|
|
void CAllServerWinStationsPage::BuildImageList()
|
|
{
|
|
m_ImageList.Create(16, 16, TRUE, 11, 0);
|
|
|
|
m_idxBlank = AddIconToImageList(IDI_BLANK);
|
|
m_idxCitrix = AddIconToImageList(IDR_MAINFRAME);
|
|
m_idxServer = AddIconToImageList(IDI_SERVER);
|
|
m_idxConsole = AddIconToImageList(IDI_CONSOLE);
|
|
m_idxNet = AddIconToImageList(IDI_NET);
|
|
m_idxAsync = AddIconToImageList(IDI_ASYNC);
|
|
m_idxCurrentConsole = AddIconToImageList(IDI_CURRENT_CONSOLE);
|
|
m_idxCurrentNet = AddIconToImageList(IDI_CURRENT_NET);
|
|
m_idxCurrentAsync = AddIconToImageList(IDI_CURRENT_ASYNC);
|
|
m_idxDirectAsync = AddIconToImageList(IDI_DIRECT_ASYNC);
|
|
m_idxCurrentDirectAsync = AddIconToImageList(IDI_CURRENT_DIRECT_ASYNC);
|
|
|
|
m_StationList.SetImageList(&m_ImageList, LVSIL_SMALL);
|
|
|
|
} // end CAllServerWinStationsPage::BuildImageList
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::AddIconToImageList
|
|
//
|
|
// - loads the appropriate icon, adds it to m_ImageList, and returns
|
|
// the newly-added icon's index in the image list
|
|
//
|
|
int CAllServerWinStationsPage::AddIconToImageList(int iconID)
|
|
{
|
|
HICON hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(iconID));
|
|
return m_ImageList.Add(hIcon);
|
|
|
|
} // end CAllServerWinStationsPage::AddIconToImageList
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::Reset
|
|
//
|
|
void CAllServerWinStationsPage::Reset(void *p)
|
|
{
|
|
CTreeNode *pT = ( CTreeNode * )p;
|
|
|
|
if( pT != NULL )
|
|
{
|
|
DisplayStations( pT->GetNodeType( ) );
|
|
}
|
|
else
|
|
{
|
|
DisplayStations( NODE_NONE );
|
|
}
|
|
|
|
} // end CAllServerWinStationsPage::Reset
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::AddServer
|
|
//
|
|
void CAllServerWinStationsPage::AddServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// Add server's WinStations to the list
|
|
if(AddServerToList(pServer)) {
|
|
// Sort the list
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_WINSTATIONS, &m_StationList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
}
|
|
|
|
} // end CAllServerWinStationsPage::AddServer
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::RemoveServer
|
|
//
|
|
void CAllServerWinStationsPage::RemoveServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
LockListControl();
|
|
|
|
int ItemCount = m_StationList.GetItemCount();
|
|
|
|
// We need to go through the list backward so that we can remove
|
|
// more than one item without the item numbers getting messed up
|
|
for(int item = ItemCount; item; item--) {
|
|
CWinStation *pWinStation = (CWinStation*)m_StationList.GetItemData(item-1);
|
|
CServer *pListServer = pWinStation->GetServer();
|
|
|
|
if(pListServer == pServer) {
|
|
m_StationList.DeleteItem(item-1);
|
|
pServer->ClearAllSelected();
|
|
}
|
|
}
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerWinStationsPage::RemoveServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::UpdateServer
|
|
//
|
|
void CAllServerWinStationsPage::UpdateServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
if(pServer->IsState(SS_DISCONNECTING))
|
|
RemoveServer(pServer);
|
|
|
|
} // end CAllServerWinStationsPage::UpdateServer
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::UpdateWinStations
|
|
//
|
|
void CAllServerWinStationsPage::UpdateWinStations(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)((CWinAdminApp*)AfxGetApp())->GetDocument();
|
|
BOOL bAnyChanged = FALSE;
|
|
BOOL bAnyAdded = FALSE;
|
|
|
|
// Loop through the WinStations
|
|
pServer->LockWinStationList();
|
|
CObList *pWinStationList = pServer->GetWinStationList();
|
|
|
|
POSITION pos = pWinStationList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CWinStation *pWinStation = (CWinStation*)pWinStationList->GetNext(pos);
|
|
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.lParam = (LPARAM)pWinStation;
|
|
|
|
// Find the WinStation in our list
|
|
int item = m_StationList.FindItem(&FindInfo, -1);
|
|
|
|
// If the process is new and isn't currently in the list,
|
|
// add it to the list
|
|
if(pWinStation->IsNew() && item == -1) {
|
|
|
|
AddWinStationToList(pWinStation);
|
|
bAnyAdded = TRUE;
|
|
continue;
|
|
}
|
|
|
|
// If the WinStation is no longer current,
|
|
// remove it from the list
|
|
if(!pWinStation->IsCurrent() && item != -1) {
|
|
// Remove the WinStation from the list
|
|
m_StationList.DeleteItem(item);
|
|
pWinStation->ClearSelected();
|
|
continue;
|
|
}
|
|
|
|
// If the WinStation info has changed, change
|
|
// it's info in our tree
|
|
if(pWinStation->IsChanged() && item != -1) {
|
|
// Figure out which icon to use
|
|
int WhichIcon = m_idxBlank;
|
|
BOOL CurrentWinStation = pWinStation->IsCurrentWinStation();
|
|
|
|
if(pWinStation->GetState() != State_Disconnected
|
|
&& pWinStation->GetState() != State_Idle) {
|
|
switch(pWinStation->GetSdClass()) {
|
|
case SdAsync:
|
|
if(pWinStation->IsDirectAsync())
|
|
WhichIcon = CurrentWinStation ? m_idxCurrentDirectAsync : m_idxDirectAsync;
|
|
else
|
|
WhichIcon = CurrentWinStation ? m_idxCurrentAsync : m_idxAsync;
|
|
break;
|
|
|
|
case SdNetwork:
|
|
WhichIcon = CurrentWinStation ? m_idxCurrentNet : m_idxNet;
|
|
break;
|
|
|
|
default:
|
|
WhichIcon = CurrentWinStation ? m_idxCurrentConsole : m_idxConsole;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_StationList.SetItem(item, 0, LVIF_IMAGE, 0, WhichIcon, 0, 0, 0L);
|
|
|
|
// WinStation Name
|
|
if(pWinStation->GetName()[0])
|
|
m_StationList.SetItemText(item, AS_WS_COL_WINSTATION, pWinStation->GetName());
|
|
else {
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_StationList.SetItemText(item, AS_WS_COL_WINSTATION, NameString);
|
|
}
|
|
|
|
// User
|
|
m_StationList.SetItemText(item, AS_WS_COL_USER, pWinStation->GetUserName());
|
|
|
|
// Logon ID
|
|
CString ColumnString;
|
|
ColumnString.Format(TEXT("%lu"), pWinStation->GetLogonId());
|
|
m_StationList.SetItemText(item, AS_WS_COL_ID, ColumnString);
|
|
|
|
// Connect State
|
|
m_StationList.SetItemText(item, AS_WS_COL_STATE, StrConnectState(pWinStation->GetState(), FALSE));
|
|
|
|
// Type
|
|
m_StationList.SetItemText(item, AS_WS_COL_TYPE, pWinStation->GetWdName());
|
|
|
|
// Client Name
|
|
m_StationList.SetItemText(item, AS_WS_COL_CLIENTNAME, pWinStation->GetClientName());
|
|
|
|
// Idle Time
|
|
TCHAR IdleTimeString[MAX_ELAPSED_TIME_LENGTH];
|
|
|
|
ELAPSEDTIME IdleTime = pWinStation->GetIdleTime();
|
|
|
|
if(IdleTime.days || IdleTime.hours || IdleTime.minutes || IdleTime.seconds)
|
|
{
|
|
ElapsedTimeString( &IdleTime, FALSE, IdleTimeString);
|
|
}
|
|
else wcscpy(IdleTimeString, TEXT("."));
|
|
|
|
m_StationList.SetItemText(item, AS_WS_COL_IDLETIME, IdleTimeString);
|
|
|
|
// Logon Time
|
|
TCHAR LogonTimeString[MAX_DATE_TIME_LENGTH];
|
|
// We don't want to pass a 0 logon time to DateTimeString()
|
|
// It will blow up if the timezone is GMT
|
|
if(pWinStation->GetState() == State_Active && pWinStation->GetLogonTime().QuadPart) {
|
|
DateTimeString(&(pWinStation->GetLogonTime()), LogonTimeString);
|
|
pDoc->FixUnknownString(LogonTimeString);
|
|
}
|
|
else LogonTimeString[0] = '\0';
|
|
|
|
m_StationList.SetItemText(item, AS_WS_COL_LOGONTIME, LogonTimeString);
|
|
|
|
// Comment
|
|
m_StationList.SetItemText(item, AS_WS_COL_COMMENT, pWinStation->GetComment());
|
|
|
|
if(m_CurrentSortColumn != AS_WS_COL_ID)
|
|
bAnyChanged = TRUE;
|
|
}
|
|
}
|
|
|
|
pServer->UnlockWinStationList();
|
|
|
|
if(bAnyChanged || bAnyAdded) SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_WINSTATIONS, &m_StationList, m_CurrentSortColumn, m_bSortAscending);
|
|
|
|
} // end CAllServerWinStationsPage::UpdateWinStations
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::AddWinStationToList
|
|
//
|
|
int CAllServerWinStationsPage::AddWinStationToList(CWinStation *pWinStation)
|
|
{
|
|
ASSERT(pWinStation);
|
|
|
|
CServer *pServer = pWinStation->GetServer();
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)((CWinAdminApp*)AfxGetApp())->GetDocument();
|
|
|
|
// Figure out which icon to use
|
|
int WhichIcon = m_idxBlank;
|
|
BOOL bCurrentWinStation = pWinStation->IsCurrentWinStation();
|
|
|
|
if(pWinStation->GetState() != State_Disconnected
|
|
&& pWinStation->GetState() != State_Idle) {
|
|
switch(pWinStation->GetSdClass()) {
|
|
case SdAsync:
|
|
if(pWinStation->IsDirectAsync())
|
|
WhichIcon = bCurrentWinStation ? m_idxCurrentDirectAsync : m_idxDirectAsync;
|
|
else
|
|
WhichIcon = bCurrentWinStation ? m_idxCurrentAsync : m_idxAsync;
|
|
break;
|
|
|
|
case SdNetwork:
|
|
WhichIcon = bCurrentWinStation ? m_idxCurrentNet : m_idxNet;
|
|
break;
|
|
|
|
default:
|
|
WhichIcon = bCurrentWinStation ? m_idxCurrentConsole : m_idxConsole;
|
|
break;
|
|
}
|
|
}
|
|
|
|
LockListControl();
|
|
//////////////////////
|
|
// Fill in the columns
|
|
//////////////////////
|
|
|
|
// Server Name
|
|
int item = m_StationList.InsertItem(m_StationList.GetItemCount(), pServer->GetName(), WhichIcon);
|
|
// WinStation Name
|
|
if(pWinStation->GetName()[0])
|
|
m_StationList.SetItemText(item, AS_WS_COL_WINSTATION, pWinStation->GetName());
|
|
else {
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_StationList.SetItemText(item, AS_WS_COL_WINSTATION, NameString);
|
|
}
|
|
|
|
// User
|
|
m_StationList.SetItemText(item, AS_WS_COL_USER, pWinStation->GetUserName());
|
|
|
|
// Logon ID
|
|
CString ColumnString;
|
|
ColumnString.Format(TEXT("%lu"), pWinStation->GetLogonId());
|
|
m_StationList.SetItemText(item, AS_WS_COL_ID, ColumnString);
|
|
|
|
// Connect State
|
|
m_StationList.SetItemText(item, AS_WS_COL_STATE, StrConnectState(pWinStation->GetState(), FALSE));
|
|
|
|
// Type
|
|
m_StationList.SetItemText(item, AS_WS_COL_TYPE, pWinStation->GetWdName());
|
|
|
|
// Client Name
|
|
m_StationList.SetItemText(item, AS_WS_COL_CLIENTNAME, pWinStation->GetClientName());
|
|
|
|
// Idle Time
|
|
TCHAR IdleTimeString[MAX_ELAPSED_TIME_LENGTH];
|
|
if(pWinStation->GetState() == State_Active
|
|
&& pWinStation->GetLastInputTime().QuadPart <= pWinStation->GetCurrentTime().QuadPart)
|
|
{
|
|
LARGE_INTEGER DiffTime = CalculateDiffTime(pWinStation->GetLastInputTime(), pWinStation->GetCurrentTime());
|
|
|
|
ULONG_PTR d_time = ( ULONG_PTR )DiffTime.QuadPart;
|
|
|
|
ELAPSEDTIME IdleTime;
|
|
// Calculate the days, hours, minutes, seconds since specified time.
|
|
IdleTime.days = (USHORT)(d_time / 86400L); // days since
|
|
d_time = d_time % 86400L; // seconds => partial day
|
|
IdleTime.hours = (USHORT)(d_time / 3600L); // hours since
|
|
d_time = d_time % 3600L; // seconds => partial hour
|
|
IdleTime.minutes = (USHORT)(d_time / 60L); // minutes since
|
|
IdleTime.seconds = (USHORT)(d_time % 60L);// seconds remaining
|
|
|
|
ElapsedTimeString( &IdleTime, FALSE, IdleTimeString);
|
|
pWinStation->SetIdleTime(IdleTime);
|
|
}
|
|
else wcscpy(IdleTimeString, TEXT("."));
|
|
|
|
m_StationList.SetItemText(item, AS_WS_COL_IDLETIME, IdleTimeString);
|
|
|
|
// Logon Time
|
|
TCHAR LogonTimeString[MAX_DATE_TIME_LENGTH];
|
|
// We don't want to pass a 0 logon time to DateTimeString()
|
|
// It will blow up if the timezone is GMT
|
|
|
|
if(pWinStation->GetState() == State_Active && pWinStation->GetLogonTime().QuadPart)
|
|
{
|
|
DateTimeString(&(pWinStation->GetLogonTime()), LogonTimeString);
|
|
|
|
if( LogonTimeString[0] != 0 )
|
|
{
|
|
pDoc->FixUnknownString(LogonTimeString);
|
|
}
|
|
}
|
|
else LogonTimeString[0] = '\0';
|
|
|
|
m_StationList.SetItemText(item, AS_WS_COL_LOGONTIME, LogonTimeString);
|
|
|
|
// Comment
|
|
m_StationList.SetItemText(item, AS_WS_COL_COMMENT, pWinStation->GetComment());
|
|
|
|
// Attach a pointer to the CWinStation structure to the list item
|
|
m_StationList.SetItemData(item, (DWORD_PTR)pWinStation);
|
|
|
|
//bug #191727
|
|
//m_StationList.SetItemState( 0 , LVIS_FOCUSED | LVIS_SELECTED , LVIS_FOCUSED | LVIS_SELECTED );
|
|
|
|
UnlockListControl();
|
|
|
|
return item;
|
|
|
|
} // end CAllServerWinStationsPage::AddWinStationToList
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::AddServerToList
|
|
//
|
|
BOOL CAllServerWinStationsPage::AddServerToList(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
pServer->LockWinStationList();
|
|
// Get a pointer to this server's list of WinStations
|
|
CObList *pWinStationList = pServer->GetWinStationList();
|
|
|
|
// Iterate through the WinStation list
|
|
POSITION pos = pWinStationList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CWinStation *pWinStation = (CWinStation*)pWinStationList->GetNext(pos);
|
|
AddWinStationToList(pWinStation);
|
|
}
|
|
|
|
pServer->UnlockWinStationList();
|
|
|
|
return TRUE;
|
|
|
|
} // end CAllServerWinStationsPage::AddServerToList
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::DisplayStations
|
|
//
|
|
void CAllServerWinStationsPage::DisplayStations( NODETYPE ntType )
|
|
{
|
|
// Clear out the list control
|
|
m_StationList.DeleteAllItems();
|
|
|
|
// Get a pointer to the document's list of servers
|
|
CObList* pServerList = ((CWinAdminDoc*)GetDocument())->GetServerList();
|
|
|
|
((CWinAdminDoc*)GetDocument())->LockServerList();
|
|
// Iterate through the server list
|
|
POSITION pos = pServerList->GetHeadPosition();
|
|
|
|
while(pos)
|
|
{
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos);
|
|
|
|
if( ntType == NODE_FAV_LIST )
|
|
{
|
|
if( pServer->GetTreeItemFromFav() != NULL )
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
}
|
|
else if( ntType == NODE_THIS_COMP )
|
|
{
|
|
if( pServer->GetTreeItemFromThisComputer() != NULL )
|
|
{
|
|
AddServerToList(pServer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddServerToList( pServer );
|
|
}
|
|
}
|
|
|
|
((CWinAdminDoc*)GetDocument())->UnlockServerList();
|
|
|
|
} // end CAllServerWinStationsPage::DisplayStations
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::OnColumnclick
|
|
//
|
|
void CAllServerWinStationsPage::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
// If the sort column hasn't changed, flip the ascending mode.
|
|
if(m_CurrentSortColumn == pNMListView->iSubItem)
|
|
m_bSortAscending = !m_bSortAscending;
|
|
else // New sort column, start in ascending mode
|
|
m_bSortAscending = TRUE;
|
|
|
|
m_CurrentSortColumn = pNMListView->iSubItem;
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_WINSTATIONS, &m_StationList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerWinStationsPage::OnColumnclick
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::OnContextMenu
|
|
//
|
|
void CAllServerWinStationsPage::OnContextMenu(CWnd* pWnd, CPoint ptScreen)
|
|
{
|
|
// TODO: Add your message handler code here
|
|
UINT flags;
|
|
UINT Item;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
// If we got here from the keyboard,
|
|
if(ptScreen.x == -1 && ptScreen.y == -1) {
|
|
|
|
UINT iCount = m_StationList.GetItemCount( );
|
|
|
|
RECT rc;
|
|
|
|
for( Item = 0 ; Item < iCount ; Item++ )
|
|
{
|
|
if( m_StationList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
m_StationList.GetItemRect( Item , &rc , LVIR_ICON );
|
|
|
|
ptScreen.x = rc.left;
|
|
|
|
ptScreen.y = rc.bottom + 5;
|
|
|
|
ClientToScreen( &ptScreen );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ptScreen.x == -1 && ptScreen.y == -1)
|
|
{
|
|
return;
|
|
}
|
|
/*
|
|
RECT rect;
|
|
m_StationList.GetClientRect(&rect);
|
|
ptScreen.x = (rect.right - rect.left) / 2;
|
|
ptScreen.y = (rect.bottom - rect.top) / 2;
|
|
ClientToScreen(&ptScreen);
|
|
*/
|
|
}
|
|
else {
|
|
Item = m_StationList.HitTest(ptClient, &flags);
|
|
if((Item == 0xFFFFFFFF) || !(flags & LVHT_ONITEM))
|
|
return;
|
|
}
|
|
|
|
CMenu menu;
|
|
menu.LoadMenu(IDR_WINSTATION_POPUP);
|
|
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON |
|
|
TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
menu.DestroyMenu();
|
|
|
|
} // end CAllServerWinStationsPage::OnContextMenu
|
|
|
|
|
|
//////////////////////////////////
|
|
// MESSAGE MAP: CAllServerProcessesPage
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAllServerProcessesPage, CFormView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAllServerProcessesPage, CFormView)
|
|
//{{AFX_MSG_MAP(CAllServerProcessesPage)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_PROCESS_LIST, OnColumnclick)
|
|
ON_NOTIFY(LVN_ITEMCHANGED, IDC_PROCESS_LIST, OnProcessItemChanged)
|
|
ON_WM_CONTEXTMENU()
|
|
ON_NOTIFY(NM_SETFOCUS, IDC_PROCESS_LIST, OnSetfocusProcessList)
|
|
//ON_NOTIFY( NM_KILLFOCUS , IDC_PROCESS_LIST , OnKillfocusProcessList )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
///////////////////////////////
|
|
// F'N: CAllServerProcessesPage ctor
|
|
//
|
|
CAllServerProcessesPage::CAllServerProcessesPage()
|
|
: CAdminPage(CAllServerProcessesPage::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAllServerProcessesPage)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bSortAscending = TRUE;
|
|
|
|
} // end CAllServerProcessesPage ctor
|
|
|
|
|
|
///////////////////////////////
|
|
// F'N: CAllServerProcessesPage dtor
|
|
//
|
|
CAllServerProcessesPage::~CAllServerProcessesPage()
|
|
{
|
|
} // end CAllServerProcessesPage dtor
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::DoDataExchange
|
|
//
|
|
void CAllServerProcessesPage::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAllServerProcessesPage)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
DDX_Control(pDX, IDC_PROCESS_LIST, m_ProcessList);
|
|
//}}AFX_DATA_MAP
|
|
|
|
} // end CAllServerProcessesPage::DoDataExchange
|
|
|
|
|
|
#ifdef _DEBUG
|
|
///////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::AssertValid
|
|
//
|
|
void CAllServerProcessesPage::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
|
|
} // end CAllServerProcessesPage::AssertValid
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::Dump
|
|
//
|
|
void CAllServerProcessesPage::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
|
|
} // end CAllServerProcessesPage::Dump
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::OnSize
|
|
//
|
|
void CAllServerProcessesPage::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
|
|
rect.top += LIST_TOP_OFFSET;
|
|
|
|
if(m_ProcessList.GetSafeHwnd())
|
|
m_ProcessList.MoveWindow(&rect, TRUE);
|
|
|
|
// CFormView::OnSize(nType, cx, cy);
|
|
|
|
} // end CAllServerProcessesPage::OnSize
|
|
|
|
static ColumnDef ProcColumns[] = {
|
|
CD_SERVER,
|
|
CD_USER,
|
|
CD_SESSION,
|
|
CD_PROC_ID,
|
|
CD_PROC_PID,
|
|
CD_PROC_IMAGE
|
|
};
|
|
|
|
#define NUM_AS_PROC_COLUMNS sizeof(ProcColumns)/sizeof(ColumnDef)
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::OnInitialUpdate
|
|
//
|
|
void CAllServerProcessesPage::OnInitialUpdate()
|
|
{
|
|
CFormView::OnInitialUpdate();
|
|
|
|
// Add the column headings
|
|
CString columnString;
|
|
|
|
for(int col = 0; col < NUM_AS_PROC_COLUMNS; col++) {
|
|
columnString.LoadString(ProcColumns[col].stringID);
|
|
m_ProcessList.InsertColumn(col, columnString, ProcColumns[col].format, ProcColumns[col].width, col);
|
|
}
|
|
|
|
m_CurrentSortColumn = AS_PROC_COL_SERVER;
|
|
|
|
} // end CAllServerProcessesPage::OnInitialUpdate
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::Reset
|
|
//
|
|
void CAllServerProcessesPage::Reset(void *)
|
|
{
|
|
// We don't want to display processes until the user clicks
|
|
// on the "Processes" tab
|
|
|
|
} // end CAllServerProcessesPage::Reset
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::AddServer
|
|
//
|
|
void CAllServerProcessesPage::AddServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// Add the Server's processes to the list
|
|
if(AddServerToList(pServer)) {
|
|
// Sort the list
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_PROCESSES, &m_ProcessList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
}
|
|
|
|
} // end CAllServerProcessesPage::AddServer
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::RemoveServer
|
|
//
|
|
void CAllServerProcessesPage::RemoveServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
LockListControl();
|
|
|
|
int ItemCount = m_ProcessList.GetItemCount();
|
|
|
|
// We need to go through the list backward so that we can remove
|
|
// more than one item without the item numbers getting messed up
|
|
for(int item = ItemCount; item; item--) {
|
|
CProcess *pProcess = (CProcess*)m_ProcessList.GetItemData(item-1);
|
|
CServer *pListServer = pProcess->GetServer();
|
|
|
|
if(pListServer == pServer) {
|
|
m_ProcessList.DeleteItem(item-1);
|
|
pServer->ClearAllSelected();
|
|
}
|
|
}
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerProcessesPage::RemoveServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerProcessesPage::UpdateServer
|
|
//
|
|
void CAllServerProcessesPage::UpdateServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
if(pServer->IsState(SS_DISCONNECTING))
|
|
RemoveServer(pServer);
|
|
|
|
} // end CAllServerProcessesPage::UpdateServer
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::UpdateProcesses
|
|
//
|
|
void CAllServerProcessesPage::UpdateProcesses(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
CWinAdminApp *pApp = (CWinAdminApp*)AfxGetApp();
|
|
BOOL bAnyChanged = FALSE;
|
|
BOOL bAnyAdded = FALSE;
|
|
|
|
// Loop through the processes
|
|
pServer->LockProcessList();
|
|
CObList *pProcessList = pServer->GetProcessList();
|
|
|
|
POSITION pos = pProcessList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CProcess *pProcess = (CProcess*)pProcessList->GetNext(pos);
|
|
|
|
// If this is a 'system' process and we aren't currently showing them,
|
|
// go to the next process
|
|
if(pProcess->IsSystemProcess() && !pApp->ShowSystemProcesses())
|
|
continue;
|
|
|
|
// If this user is not an Admin, don't show him someone else's processes unless it
|
|
// is a System process
|
|
if(!pApp->IsUserAdmin() && !pProcess->IsCurrentUsers() && !pProcess->IsSystemProcess())
|
|
continue;
|
|
|
|
// If the process is new, add it to the list
|
|
if(pProcess->IsNew()) {
|
|
|
|
if(AddProcessToList(pProcess) != -1)
|
|
bAnyAdded = TRUE;
|
|
continue;
|
|
}
|
|
|
|
LV_FINDINFO FindInfo;
|
|
FindInfo.flags = LVFI_PARAM;
|
|
FindInfo.lParam = (LPARAM)pProcess;
|
|
|
|
// Find the Process in our list
|
|
int item = m_ProcessList.FindItem(&FindInfo, -1);
|
|
|
|
// If the process is no longer current,
|
|
// remove it from the list
|
|
if(!pProcess->IsCurrent() && item != -1) {
|
|
// Remove the Process from the list
|
|
m_ProcessList.DeleteItem(item);
|
|
pProcess->ClearSelected();
|
|
}
|
|
|
|
// If the process info has changed, change
|
|
// it's info in our tree
|
|
if(pProcess->IsChanged() && item != -1)
|
|
{
|
|
// WinStation Name
|
|
CWinStation *pWinStation = pProcess->GetWinStation();
|
|
if(pWinStation)
|
|
{
|
|
if(pWinStation->GetName()[0])
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_WINSTATION, pWinStation->GetName());
|
|
else
|
|
{
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_WINSTATION, NameString);
|
|
}
|
|
}
|
|
if(m_CurrentSortColumn == AS_PROC_COL_WINSTATION)
|
|
bAnyChanged = TRUE;
|
|
}
|
|
}
|
|
|
|
pServer->UnlockProcessList();
|
|
|
|
if(bAnyChanged || bAnyAdded) {
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_PROCESSES, &m_ProcessList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
}
|
|
|
|
} // end CAllServerProcessesPage::UpdateProcesses
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::RemoveProcess
|
|
//
|
|
void CAllServerProcessesPage::RemoveProcess(CProcess *pProcess)
|
|
{
|
|
ASSERT(pProcess);
|
|
|
|
LockListControl();
|
|
|
|
// Find out how many items in the list
|
|
int ItemCount = m_ProcessList.GetItemCount();
|
|
|
|
// Go through the items and remove this process
|
|
for(int item = 0; item < ItemCount; item++) {
|
|
CProcess *pListProcess = (CProcess*)m_ProcessList.GetItemData(item);
|
|
|
|
if(pListProcess == pProcess) {
|
|
m_ProcessList.DeleteItem(item);
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnlockListControl();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::AddProcessToList
|
|
//
|
|
int CAllServerProcessesPage::AddProcessToList(CProcess *pProcess)
|
|
{
|
|
ASSERT(pProcess);
|
|
|
|
CWinAdminApp *pApp = (CWinAdminApp*)AfxGetApp();
|
|
CServer *pServer = pProcess->GetServer();
|
|
|
|
LockListControl();
|
|
// Server - put at end of list
|
|
int item = m_ProcessList.InsertItem(m_ProcessList.GetItemCount(), pProcess->GetServer()->GetName(), NULL);
|
|
|
|
// User
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_USER, pProcess->GetUserName());
|
|
|
|
// WinStation Name
|
|
CWinStation *pWinStation = pProcess->GetWinStation();
|
|
if(pWinStation) {
|
|
|
|
if(pWinStation->GetName()[0])
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_WINSTATION, pWinStation->GetName());
|
|
else {
|
|
CString NameString(" ");
|
|
if(pWinStation->GetState() == State_Disconnected) NameString.LoadString(IDS_DISCONNECTED);
|
|
if(pWinStation->GetState() == State_Idle) NameString.LoadString(IDS_IDLE);
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_WINSTATION, NameString);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
// ID
|
|
CString ProcString;
|
|
ProcString.Format(TEXT("%lu"), pProcess->GetLogonId());
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_ID, ProcString);
|
|
|
|
// PID
|
|
ProcString.Format(TEXT("%lu"), pProcess->GetPID());
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_PID, ProcString);
|
|
|
|
// Image
|
|
m_ProcessList.SetItemText(item, AS_PROC_COL_IMAGE, pProcess->GetImageName());
|
|
m_ProcessList.SetItemData(item, (DWORD_PTR)pProcess);
|
|
|
|
m_ProcessList.SetItemState( 0 , LVIS_FOCUSED | LVIS_SELECTED , LVIS_SELECTED | LVIS_FOCUSED );
|
|
|
|
UnlockListControl();
|
|
|
|
return item;
|
|
|
|
} // end CAllServerProcessesPage::AddProcessToList
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::AddServerToList
|
|
//
|
|
BOOL CAllServerProcessesPage::AddServerToList(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
CWinAdminApp *pApp = (CWinAdminApp*)AfxGetApp();
|
|
|
|
pServer->EnumerateProcesses();
|
|
CObList *pProcessList = pServer->GetProcessList();
|
|
pServer->LockProcessList();
|
|
|
|
POSITION pos = pProcessList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CProcess *pProcess = (CProcess*)pProcessList->GetNext(pos);
|
|
|
|
// If this is a 'system' process and we aren't currently showing them,
|
|
// go to the next process
|
|
if(pProcess->IsSystemProcess() && !pApp->ShowSystemProcesses())
|
|
continue;
|
|
|
|
// If this user is not an Admin, don't show him someone else's processes unless it
|
|
// is a System process
|
|
if(!pApp->IsUserAdmin() && !pProcess->IsCurrentUsers() && !pProcess->IsSystemProcess())
|
|
continue;
|
|
|
|
AddProcessToList(pProcess);
|
|
}
|
|
|
|
pServer->UnlockProcessList();
|
|
|
|
return TRUE;
|
|
|
|
} // end CAllServerProcessesPage::AddServerToList
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::DisplayProcesses
|
|
//
|
|
void CAllServerProcessesPage::DisplayProcesses( NODETYPE ntType )
|
|
{
|
|
CWaitCursor Nikki;
|
|
|
|
LockListControl();
|
|
|
|
// Clear out the list control
|
|
m_ProcessList.DeleteAllItems();
|
|
|
|
// Get a pointer to the document's list of servers
|
|
CObList* pServerList = ((CWinAdminDoc*)GetDocument())->GetServerList();
|
|
|
|
((CWinAdminDoc*)GetDocument())->LockServerList();
|
|
// Iterate through the server list
|
|
POSITION pos = pServerList->GetHeadPosition();
|
|
|
|
CServer *pTempServer;
|
|
|
|
while(pos)
|
|
{
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos);
|
|
|
|
pTempServer = NULL;
|
|
|
|
if( ntType == NODE_FAV_LIST )
|
|
{
|
|
if( pServer->GetTreeItemFromFav() != NULL )
|
|
{
|
|
|
|
pTempServer = pServer;
|
|
}
|
|
}
|
|
else if( ntType == NODE_THIS_COMP )
|
|
{
|
|
if( pServer->GetTreeItemFromThisComputer( ) != NULL )
|
|
{
|
|
pTempServer = pServer;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pTempServer = pServer;
|
|
}
|
|
|
|
if( pTempServer != NULL && pTempServer->IsServerSane())
|
|
{
|
|
AddServerToList( pTempServer );
|
|
} // end if(pServer->IsServerSane())
|
|
} // end while(pos)
|
|
|
|
((CWinAdminDoc*)GetDocument())->UnlockServerList();
|
|
|
|
UnlockListControl();
|
|
|
|
} // end CAllServerProcessesPage::DisplayProcesses
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::OnProcessItemChanged
|
|
//
|
|
void CAllServerProcessesPage::OnProcessItemChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW *pLV = (NM_LISTVIEW*)pNMHDR;
|
|
|
|
if(pLV->uNewState & LVIS_SELECTED) {
|
|
CProcess *pProcess = (CProcess*)m_ProcessList.GetItemData(pLV->iItem);
|
|
pProcess->SetSelected();
|
|
}
|
|
|
|
if(pLV->uOldState & LVIS_SELECTED && !(pLV->uNewState & LVIS_SELECTED)) {
|
|
CProcess *pProcess = (CProcess*)m_ProcessList.GetItemData(pLV->iItem);
|
|
pProcess->ClearSelected();
|
|
}
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerProcessesPage::OnProcessItemChanged
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::OnColumnclick
|
|
//
|
|
void CAllServerProcessesPage::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
// If the sort column hasn't changed, flip the ascending mode.
|
|
if(m_CurrentSortColumn == pNMListView->iSubItem)
|
|
m_bSortAscending = !m_bSortAscending;
|
|
else // New sort column, start in ascending mode
|
|
m_bSortAscending = TRUE;
|
|
|
|
m_CurrentSortColumn = pNMListView->iSubItem;
|
|
LockListControl();
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_PROCESSES, &m_ProcessList, m_CurrentSortColumn, m_bSortAscending);
|
|
UnlockListControl();
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerProcessesPage::OnColumnclick
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// F'N: CAllServerProcessesPage::OnContextMenu
|
|
//
|
|
void CAllServerProcessesPage::OnContextMenu(CWnd* pWnd, CPoint ptScreen)
|
|
{
|
|
// TODO: Add your message handler code here
|
|
UINT flags;
|
|
UINT Item;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
// If we got here from the keyboard,
|
|
if(ptScreen.x == -1 && ptScreen.y == -1) {
|
|
|
|
UINT iCount = m_ProcessList.GetItemCount( );
|
|
|
|
RECT rc;
|
|
|
|
for( Item = 0 ; Item < iCount ; Item++ )
|
|
{
|
|
if( m_ProcessList.GetItemState( Item , LVIS_SELECTED ) == LVIS_SELECTED )
|
|
{
|
|
m_ProcessList.GetItemRect( Item , &rc , LVIR_ICON );
|
|
|
|
ptScreen.x = rc.left;
|
|
|
|
ptScreen.y = rc.bottom + 5;
|
|
|
|
ClientToScreen( &ptScreen );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ptScreen.x == -1 && ptScreen.y == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
RECT rect;
|
|
m_ProcessList.GetClientRect(&rect);
|
|
ptScreen.x = (rect.right - rect.left) / 2;
|
|
ptScreen.y = (rect.bottom - rect.top) / 2;
|
|
ClientToScreen(&ptScreen);
|
|
*/
|
|
}
|
|
else {
|
|
Item = m_ProcessList.HitTest(ptClient, &flags);
|
|
if((Item == 0xFFFFFFFF) || !(flags & LVHT_ONITEM))
|
|
return;
|
|
}
|
|
|
|
CMenu menu;
|
|
menu.LoadMenu(IDR_PROCESS_POPUP);
|
|
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON |
|
|
TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
menu.DestroyMenu();
|
|
|
|
} // end CAllServerProcessesPage::OnContextMenu
|
|
|
|
|
|
////////////////////////////////
|
|
// MESSAGE MAP: CAllServerLicensesPage
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAllServerLicensesPage, CFormView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAllServerLicensesPage, CFormView)
|
|
//{{AFX_MSG_MAP(CAllServerLicensesPage)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY(LVN_COLUMNCLICK, IDC_LICENSE_LIST, OnColumnclick)
|
|
ON_NOTIFY(NM_SETFOCUS, IDC_LICENSE_LIST, OnSetfocusLicenseList)
|
|
//ON_NOTIFY( NM_KILLFOCUS , IDC_LICENSE_LIST , OnKillfocusLicenseList )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerLicensesPage ctor
|
|
//
|
|
CAllServerLicensesPage::CAllServerLicensesPage()
|
|
: CAdminPage(CAllServerLicensesPage::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CAllServerLicensesPage)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bSortAscending = TRUE;
|
|
|
|
} // end CAllServerLicensesPage ctor
|
|
|
|
|
|
/////////////////////////////
|
|
// F'N: CAllServerLicensesPage dtor
|
|
//
|
|
CAllServerLicensesPage::~CAllServerLicensesPage()
|
|
{
|
|
|
|
} // end CAllServerLicensesPage dtor
|
|
|
|
|
|
////////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::DoDataExchange
|
|
//
|
|
void CAllServerLicensesPage::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAllServerLicensesPage)
|
|
DDX_Control(pDX, IDC_LICENSE_LIST, m_LicenseList);
|
|
//}}AFX_DATA_MAP
|
|
|
|
} // end CAllServerLicensesPage::DoDataExchange
|
|
|
|
|
|
#ifdef _DEBUG
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::AssertValid
|
|
//
|
|
void CAllServerLicensesPage::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
|
|
} // end CAllServerLicensesPage::AssertValid
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerLicensesPage::Dump
|
|
//
|
|
void CAllServerLicensesPage::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
|
|
} // end CAllServerLicensesPage::Dump
|
|
#endif //_DEBUG
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::OnSize
|
|
//
|
|
void CAllServerLicensesPage::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
RECT rect;
|
|
GetWindowRect(&rect);
|
|
|
|
CWnd *pWnd = GetDlgItem(IDC_LOCAL_AVAILABLE);
|
|
if(pWnd) {
|
|
RECT rect2;
|
|
pWnd->GetWindowRect(&rect2);
|
|
rect.top = rect2.bottom + 5;
|
|
}
|
|
|
|
ScreenToClient(&rect);
|
|
|
|
if(m_LicenseList.GetSafeHwnd())
|
|
m_LicenseList.MoveWindow(&rect, TRUE);
|
|
|
|
// CFormView::OnSize(nType, cx, cy);
|
|
|
|
} // end CAllServerLicensesPage::OnSize
|
|
|
|
|
|
static ColumnDef LicenseColumns[] = {
|
|
CD_SERVER,
|
|
CD_LICENSE_DESC,
|
|
CD_LICENSE_REG,
|
|
CD_USERCOUNT,
|
|
CD_POOLCOUNT,
|
|
CD_LICENSE_NUM
|
|
};
|
|
|
|
#define NUM_AS_LICENSE_COLUMNS sizeof(LicenseColumns)/sizeof(ColumnDef)
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::OnInitialUpdate
|
|
//
|
|
void CAllServerLicensesPage::OnInitialUpdate()
|
|
{
|
|
CFormView::OnInitialUpdate();
|
|
|
|
BuildImageList(); // builds the image list for the list control
|
|
|
|
CString columnString;
|
|
|
|
for(int col = 0; col < NUM_AS_LICENSE_COLUMNS; col++) {
|
|
columnString.LoadString(LicenseColumns[col].stringID);
|
|
m_LicenseList.InsertColumn(col, columnString, LicenseColumns[col].format, LicenseColumns[col].width, col);
|
|
}
|
|
|
|
m_CurrentSortColumn = AS_LICENSE_COL_SERVER;
|
|
|
|
} // end CAllServerLicensesPage::OnInitialUpdate
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensePage::BuildImageList
|
|
//
|
|
// - calls m_ImageList.Create(..) to create the image list
|
|
// - calls AddIconToImageList(..) to add the icons themselves and save
|
|
// off their indices
|
|
// - attaches the image list to the list ctrl
|
|
//
|
|
void CAllServerLicensesPage::BuildImageList()
|
|
{
|
|
m_ImageList.Create(16, 16, TRUE, 5, 0);
|
|
|
|
m_idxBase = AddIconToImageList(IDI_BASE);
|
|
m_idxBump = AddIconToImageList(IDI_BUMP);
|
|
m_idxEnabler = AddIconToImageList(IDI_ENABLER);
|
|
m_idxUnknown = AddIconToImageList(IDI_UNKNOWN);
|
|
|
|
m_LicenseList.SetImageList(&m_ImageList, LVSIL_SMALL);
|
|
|
|
} // end CAllServerLicensesPage::BuildImageList
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::AddIconToImageList
|
|
//
|
|
// - loads the appropriate icon, adds it to m_ImageList, and returns
|
|
// the newly-added icon's index in the image list
|
|
//
|
|
int CAllServerLicensesPage::AddIconToImageList(int iconID)
|
|
{
|
|
HICON hIcon = ::LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(iconID));
|
|
|
|
return m_ImageList.Add(hIcon);
|
|
|
|
} // end CAllServerLicensesPage::AddIconToImageList
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::Reset
|
|
//
|
|
void CAllServerLicensesPage::Reset(void *p)
|
|
{
|
|
DisplayLicenses();
|
|
DisplayLicenseCounts();
|
|
|
|
} // end CAllServerLicensesPage::Reset
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::AddServer
|
|
//
|
|
void CAllServerLicensesPage::AddServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
// Add the Server's licenses to the list
|
|
if(AddServerToList(pServer)) {
|
|
// Sort the list
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_LICENSES, &m_LicenseList, m_CurrentSortColumn, m_bSortAscending);
|
|
}
|
|
|
|
} // end F'N: CAllServerLicensesPage::AddServer
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::RemoveServer
|
|
//
|
|
void CAllServerLicensesPage::RemoveServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
int ItemCount = m_LicenseList.GetItemCount();
|
|
|
|
// We need to go through the list backward so that we can remove
|
|
// more than one item without the item numbers getting messed up
|
|
for(int item = ItemCount; item; item--) {
|
|
CLicense *pLicense = (CLicense*)m_LicenseList.GetItemData(item-1);
|
|
CServer *pListServer = pLicense->GetServer();
|
|
|
|
if(pListServer == pServer) {
|
|
m_LicenseList.DeleteItem(item-1);
|
|
pServer->ClearAllSelected();
|
|
}
|
|
}
|
|
|
|
} // end CAllServerLicensesPage::RemoveServer
|
|
|
|
|
|
//////////////////////////////
|
|
// F'N: CAllServerLicensesPage::UpdateServer
|
|
//
|
|
void CAllServerLicensesPage::UpdateServer(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
if(pServer->IsState(SS_DISCONNECTING))
|
|
RemoveServer(pServer);
|
|
|
|
if(pServer->IsState(SS_GOOD))
|
|
AddServer(pServer);
|
|
|
|
} // end CAllServerLicensesPage::UpdateServer
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::AddServerToList
|
|
//
|
|
BOOL CAllServerLicensesPage::AddServerToList(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
int item;
|
|
|
|
pServer->LockLicenseList();
|
|
|
|
// Get a pointer to the Server's list of licenses
|
|
CObList *pLicenseList = pServer->GetLicenseList();
|
|
|
|
// Iterate through the License list
|
|
POSITION pos = pLicenseList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CLicense *pLicense = (CLicense*)pLicenseList->GetNext(pos);
|
|
|
|
//////////////////////
|
|
// Fill in the columns
|
|
//////////////////////
|
|
int WhichIcon;
|
|
|
|
switch(pLicense->GetClass()) {
|
|
case LicenseBase:
|
|
WhichIcon = m_idxBase;
|
|
break;
|
|
case LicenseBump:
|
|
WhichIcon = m_idxBump;
|
|
break;
|
|
case LicenseEnabler:
|
|
WhichIcon = m_idxEnabler;
|
|
break;
|
|
case LicenseUnknown:
|
|
WhichIcon = m_idxUnknown;
|
|
break;
|
|
}
|
|
|
|
// Server Name
|
|
item = m_LicenseList.InsertItem(m_LicenseList.GetItemCount(), pServer->GetName(), WhichIcon);
|
|
|
|
// Description
|
|
m_LicenseList.SetItemText(item, AS_LICENSE_COL_DESCRIPTION, pLicense->GetDescription());
|
|
|
|
// Registered
|
|
CString RegString;
|
|
RegString.LoadString(pLicense->IsRegistered() ? IDS_YES : IDS_NO);
|
|
m_LicenseList.SetItemText(item, AS_LICENSE_COL_REGISTERED, RegString);
|
|
|
|
BOOL bUnlimited = (pLicense->GetClass() == LicenseBase
|
|
&& pLicense->GetTotalCount() == 4095
|
|
&& pServer->GetCTXVersionNum() == 0x00000040);
|
|
|
|
// User (Total) Count
|
|
CString CountString;
|
|
if(bUnlimited)
|
|
CountString.LoadString(IDS_UNLIMITED);
|
|
else
|
|
CountString.Format(TEXT("%lu"), pLicense->GetTotalCount());
|
|
m_LicenseList.SetItemText(item, AS_LICENSE_COL_USERCOUNT, CountString);
|
|
|
|
// Pool Count
|
|
if(bUnlimited)
|
|
CountString.LoadString(IDS_NOT_APPLICABLE);
|
|
else
|
|
CountString.Format(TEXT("%lu"), pLicense->GetPoolCount());
|
|
m_LicenseList.SetItemText(item, AS_LICENSE_COL_POOLCOUNT, CountString);
|
|
|
|
// License Number
|
|
m_LicenseList.SetItemText(item, AS_LICENSE_COL_NUMBER, pLicense->GetLicenseNumber());
|
|
|
|
m_LicenseList.SetItemData(item, (DWORD_PTR)pLicense);
|
|
} // end while(pos)
|
|
|
|
pServer->UnlockLicenseList();
|
|
|
|
return TRUE;
|
|
|
|
} // end CAllServerLicensesPage::AddServerToList
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::DisplayLicenseCounts
|
|
//
|
|
void CAllServerLicensesPage::DisplayLicenseCounts()
|
|
{
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
ExtGlobalInfo *pExtGlobalInfo = pDoc->GetExtGlobalInfo();
|
|
|
|
if(pExtGlobalInfo) {
|
|
BOOL bUnlimited = (pExtGlobalInfo->NetworkLocalAvailable == 32767);
|
|
|
|
CString LicenseString;
|
|
|
|
if(bUnlimited) {
|
|
LicenseString.LoadString(IDS_UNLIMITED);
|
|
SetDlgItemText(IDC_LOCAL_INSTALLED, LicenseString);
|
|
SetDlgItemText(IDC_LOCAL_AVAILABLE, LicenseString);
|
|
SetDlgItemText(IDC_TOTAL_INSTALLED, LicenseString);
|
|
SetDlgItemText(IDC_TOTAL_AVAILABLE, LicenseString);
|
|
|
|
} else {
|
|
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkLocalInstalled);
|
|
SetDlgItemText(IDC_LOCAL_INSTALLED, LicenseString);
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkLocalAvailable);
|
|
SetDlgItemText(IDC_LOCAL_AVAILABLE, LicenseString);
|
|
LicenseString.Format(TEXT("%lu"),
|
|
pExtGlobalInfo->NetworkPoolInstalled + pExtGlobalInfo->NetworkLocalInstalled);
|
|
SetDlgItemText(IDC_TOTAL_INSTALLED, LicenseString);
|
|
|
|
LicenseString.Format(TEXT("%lu"),
|
|
pExtGlobalInfo->NetworkPoolAvailable + pExtGlobalInfo->NetworkLocalAvailable);
|
|
SetDlgItemText(IDC_TOTAL_AVAILABLE, LicenseString);
|
|
|
|
}
|
|
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkLocalInUse);
|
|
SetDlgItemText(IDC_LOCAL_INUSE, LicenseString);
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkPoolInstalled);
|
|
SetDlgItemText(IDC_POOL_INSTALLED, LicenseString);
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkPoolInUse);
|
|
SetDlgItemText(IDC_POOL_INUSE, LicenseString);
|
|
LicenseString.Format(TEXT("%lu"), pExtGlobalInfo->NetworkPoolAvailable);
|
|
SetDlgItemText(IDC_POOL_AVAILABLE, LicenseString);
|
|
|
|
LicenseString.Format(TEXT("%lu"),
|
|
pExtGlobalInfo->NetworkPoolInUse + pExtGlobalInfo->NetworkLocalInUse);
|
|
SetDlgItemText(IDC_TOTAL_INUSE, LicenseString);
|
|
}
|
|
|
|
} // end CAllServerLicensesPage::DisplayLicenseCounts
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::DisplayLicenses
|
|
//
|
|
void CAllServerLicensesPage::DisplayLicenses()
|
|
{
|
|
// Clear out the list control
|
|
m_LicenseList.DeleteAllItems();
|
|
|
|
// Get a pointer to the document's list of servers
|
|
CObList* pServerList = ((CWinAdminDoc*)GetDocument())->GetServerList();
|
|
|
|
((CWinAdminDoc*)GetDocument())->LockServerList();
|
|
// Iterate through the server list
|
|
POSITION pos = pServerList->GetHeadPosition();
|
|
|
|
while(pos) {
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos);
|
|
AddServerToList(pServer);
|
|
}
|
|
|
|
((CWinAdminDoc*)GetDocument())->UnlockServerList();
|
|
|
|
} // end CAllServerLicensesPage::DisplayLicenses
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerLicensesPage::OnColumnclick
|
|
//
|
|
void CAllServerLicensesPage::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
|
|
// TODO: Add your control notification handler code here
|
|
|
|
// If the sort column hasn't changed, flip the ascending mode.
|
|
if(m_CurrentSortColumn == pNMListView->iSubItem)
|
|
m_bSortAscending = !m_bSortAscending;
|
|
else // New sort column, start in ascending mode
|
|
m_bSortAscending = TRUE;
|
|
|
|
m_CurrentSortColumn = pNMListView->iSubItem;
|
|
SortByColumn(VIEW_ALL_SERVERS, PAGE_AS_LICENSES, &m_LicenseList, m_CurrentSortColumn, m_bSortAscending);
|
|
|
|
*pResult = 0;
|
|
|
|
} // end CAllServerLicensesPage::OnColumnclick
|
|
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerUsersPage::OnKillfocusUserList(NMHDR* , LRESULT* pResult)
|
|
{
|
|
m_UserList.Invalidate( );
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CAllServerUsersPage::OnSetfocusUserList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ODS( L" CAllServerUsersPage::OnSetfocusUserList\n" );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
|
|
m_UserList.Invalidate( );
|
|
|
|
/*
|
|
int nItem;
|
|
|
|
int nCount = m_UserList.GetSelectedCount();
|
|
|
|
if( nCount == 0 )
|
|
{
|
|
m_UserList.SetItemState( 0 , LVIS_SELECTED , LVIS_SELECTED );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < nCount; +++i )
|
|
{
|
|
nItem = m_UserList.GetNextItem( -1 , LVNI_FOCUSED );
|
|
|
|
m_UserList.Update( nItem );
|
|
}
|
|
}
|
|
*/
|
|
pDoc->RegisterLastFocus( PAGED_ITEM );
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerProcessesPage::OnKillfocusProcessList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
m_ProcessList.Invalidate( );
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CAllServerProcessesPage::OnSetfocusProcessList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ODS( L" CAllServerProcessesPage::OnSetfocusProcessList\n" );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
|
|
m_ProcessList.Invalidate();
|
|
/*
|
|
int nItem;
|
|
|
|
int nCount = m_ProcessList.GetSelectedCount();
|
|
|
|
if( nCount == 0 )
|
|
{
|
|
m_ProcessList.SetItemState( 0 , LVIS_SELECTED , LVIS_SELECTED );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < nCount; +++i )
|
|
{
|
|
nItem = m_ProcessList.GetNextItem( -1 , LVNI_FOCUSED );
|
|
|
|
m_ProcessList.Update( nItem );
|
|
}
|
|
}
|
|
*/
|
|
pDoc->RegisterLastFocus( PAGED_ITEM );
|
|
|
|
*pResult = 0;
|
|
|
|
}
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerWinStationsPage::OnKillfocusWinstationList(NMHDR* , LRESULT* pResult)
|
|
{
|
|
m_StationList.Invalidate( );
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerWinStationsPage::OnSetfocusWinstationList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ODS( L"CAllServerWinStationsPage::OnSetfocusWinstationList\n" );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
|
|
m_StationList.Invalidate();
|
|
|
|
/*
|
|
int nItem;
|
|
|
|
int nCount = m_StationList.GetSelectedCount();
|
|
|
|
if( nCount == 0 )
|
|
{
|
|
m_StationList.SetItemState( 0 , LVIS_SELECTED , LVIS_SELECTED );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < nCount; +++i )
|
|
{
|
|
nItem = m_StationList.GetNextItem( -1 , LVNI_FOCUSED );
|
|
|
|
m_StationList.Update( nItem );
|
|
}
|
|
}
|
|
*/
|
|
pDoc->RegisterLastFocus( PAGED_ITEM );
|
|
|
|
*pResult = 0;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAllServerWinStationsPage::ClearSelections
|
|
//
|
|
void CAllServerWinStationsPage::ClearSelections()
|
|
{
|
|
|
|
if(m_StationList.m_hWnd != NULL)
|
|
{
|
|
POSITION pos = m_StationList.GetFirstSelectedItemPosition();
|
|
while (pos)
|
|
{
|
|
int nItem = m_StationList.GetNextSelectedItem(pos);
|
|
// you could do your own processing on nItem here
|
|
m_StationList.SetItemState(nItem,0,LVIS_SELECTED);
|
|
}
|
|
}
|
|
}
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerServersPage::OnKillfocusServerList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
m_ServerList.Invalidate();
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CAllServerServersPage::OnSetfocusServerList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ODS( L"CAllServerServersPage::OnSetfocusServerList\n" );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
/*
|
|
int nItem;
|
|
|
|
int nCount = m_ServerList.GetSelectedCount();
|
|
|
|
if( nCount == 0 )
|
|
{
|
|
m_ServerList.SetItemState( 0 , LVIS_SELECTED , LVIS_SELECTED );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < nCount; +++i )
|
|
{
|
|
nItem = m_ServerList.GetNextItem( -1 , LVNI_FOCUSED );
|
|
|
|
m_ServerList.Update( nItem );
|
|
}
|
|
}
|
|
*/
|
|
m_ServerList.Invalidate();
|
|
|
|
pDoc->RegisterLastFocus( PAGED_ITEM );
|
|
|
|
*pResult = 0;
|
|
|
|
}
|
|
|
|
//=-----------------------------------------------------------------------------------------
|
|
void CAllServerLicensesPage::OnKillfocusLicenseList(NMHDR*, LRESULT* pResult)
|
|
{
|
|
m_LicenseList.Invalidate();
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CAllServerLicensesPage::OnSetfocusLicenseList(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ODS( L"CAllServerLicensesPage::OnSetfocusLicenseList\n" );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
|
|
m_LicenseList.Invalidate();
|
|
|
|
/*
|
|
int nItem;
|
|
|
|
int nCount = m_LicenseList.GetSelectedCount();
|
|
|
|
if( nCount == 0 )
|
|
{
|
|
m_LicenseList.SetItemState( 0 , LVIS_SELECTED , LVIS_SELECTED );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < nCount; +++i )
|
|
{
|
|
nItem = m_LicenseList.GetNextItem( -1 , LVNI_FOCUSED );
|
|
|
|
m_LicenseList.Update( nItem );
|
|
}
|
|
}
|
|
*/
|
|
pDoc->RegisterLastFocus( PAGED_ITEM );
|
|
|
|
*pResult = 0;
|
|
|
|
|
|
}
|