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.
2342 lines
69 KiB
2342 lines
69 KiB
/*******************************************************************************
|
|
*
|
|
* treeview.cpp
|
|
*
|
|
* implementation of the CAdminTreeView class
|
|
*
|
|
* 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\treeview.cpp $
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
#include "winadmin.h"
|
|
#include "admindoc.h"
|
|
#include "treeview.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
extern DWORD g_dwTreeViewExpandedStates;
|
|
|
|
#define DISPLAY_NAME_SIZE 128
|
|
|
|
/////////////////////////////
|
|
// MESSAGE MAP: CAdminTreeView
|
|
//
|
|
IMPLEMENT_DYNCREATE(CAdminTreeView, CBaseTreeView)
|
|
|
|
BEGIN_MESSAGE_MAP(CAdminTreeView, CBaseTreeView)
|
|
//{{AFX_MSG_MAP(CAdminTreeView)
|
|
ON_MESSAGE(WM_ADMIN_ADD_SERVER, OnAdminAddServer)
|
|
ON_MESSAGE(WM_ADMIN_REMOVE_SERVER, OnAdminRemoveServer)
|
|
ON_MESSAGE(WM_ADMIN_UPDATE_SERVER, OnAdminUpdateServer)
|
|
ON_MESSAGE(WM_ADMIN_ADD_WINSTATION, OnAdminAddWinStation)
|
|
ON_MESSAGE(WM_ADMIN_UPDATE_WINSTATION, OnAdminUpdateWinStation)
|
|
ON_MESSAGE(WM_ADMIN_REMOVE_WINSTATION, OnAdminRemoveWinStation)
|
|
ON_MESSAGE(WM_ADMIN_UPDATE_DOMAIN, OnAdminUpdateDomain)
|
|
ON_MESSAGE(WM_ADMIN_ADD_DOMAIN, OnAdminAddDomain)
|
|
ON_MESSAGE(WM_ADMIN_VIEWS_READY, OnAdminViewsReady)
|
|
ON_MESSAGE( WM_ADMIN_ADDSERVERTOFAV , OnAdminAddServerToFavs )
|
|
ON_MESSAGE( WM_ADMIN_REMOVESERVERFROMFAV , OnAdminRemoveServerFromFavs )
|
|
ON_MESSAGE( WM_ADMIN_GOTO_SERVER , OnAdminGotoServer )
|
|
ON_MESSAGE( WM_ADMIN_DELTREE_NODE , OnAdminDelFavServer )
|
|
ON_MESSAGE( WM_ADMIN_GET_TV_STATES , OnGetTVStates )
|
|
ON_MESSAGE( WM_ADMIN_UPDATE_TVSTATE , OnUpdateTVState )
|
|
ON_MESSAGE( IDM_ALLSERVERS_EMPTYFAVORITES , OnEmptyFavorites )
|
|
ON_MESSAGE( WM_ISFAVLISTEMPTY , OnIsFavListEmpty )
|
|
ON_MESSAGE( WM_ADMIN_CONNECT_TO_SERVER, OnAdminConnectToServer )
|
|
ON_MESSAGE( WM_ADMIN_FORCE_SEL_CHANGE, OnAdminForceSelChange )
|
|
ON_WM_CONTEXTMENU()
|
|
|
|
/*
|
|
ON_WM_LBUTTONUP( )
|
|
ON_WM_MOUSEMOVE( )
|
|
ON_WM_TIMER( )
|
|
ON_NOTIFY( TVN_BEGINDRAG , AFX_IDW_PANE_FIRST , OnBeginDrag )
|
|
*/
|
|
|
|
|
|
ON_NOTIFY( NM_RCLICK , AFX_IDW_PANE_FIRST , OnRClick )
|
|
|
|
ON_WM_LBUTTONDBLCLK()
|
|
ON_COMMAND( ID_ENTER , OnEnterKey )
|
|
ON_WM_SETFOCUS( )
|
|
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
//////////////////////////
|
|
// F'N: CAdminTreeView ctor
|
|
//
|
|
CAdminTreeView::CAdminTreeView()
|
|
{
|
|
m_pimgDragList = NULL;
|
|
m_hDragItem = NULL;
|
|
|
|
} // end CAdminTreeView ctor
|
|
|
|
|
|
//////////////////////////
|
|
// F'N: CAdminTreeView dtor
|
|
//
|
|
CAdminTreeView::~CAdminTreeView()
|
|
{
|
|
|
|
} // end CAdminTreeView dtor
|
|
|
|
#ifdef _DEBUG
|
|
//////////////////////////////////
|
|
// F'N: CAdminTreeView::AssertValid
|
|
//
|
|
void CAdminTreeView::AssertValid() const
|
|
{
|
|
CBaseTreeView::AssertValid();
|
|
|
|
} // end CAdminTreeView::AssertValid
|
|
|
|
|
|
///////////////////////////
|
|
// F'N: CAdminTreeView::Dump
|
|
//
|
|
void CAdminTreeView::Dump(CDumpContext& dc) const
|
|
{
|
|
CBaseTreeView::Dump(dc);
|
|
|
|
} // end CAdminTreeView::Dump
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////
|
|
// F'N: CAdminTreeView::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 CTreeCtrl
|
|
//
|
|
void CAdminTreeView::BuildImageList()
|
|
{
|
|
m_ImageList.Create(16, 16, TRUE, 19, 0);
|
|
|
|
m_idxBlank = AddIconToImageList(IDI_BLANK);
|
|
m_idxCitrix = AddIconToImageList(IDI_WORLD);
|
|
m_idxServer = AddIconToImageList(IDI_SERVER);
|
|
m_idxConsole = AddIconToImageList(IDI_CONSOLE);
|
|
m_idxNet = AddIconToImageList(IDI_NET);
|
|
m_idxNotSign = AddIconToImageList(IDI_NOTSIGN);
|
|
m_idxQuestion = AddIconToImageList(IDI_QUESTIONMARK);
|
|
m_idxUser = AddIconToImageList(IDI_USER);
|
|
m_idxAsync = AddIconToImageList(IDI_ASYNC);
|
|
m_idxCurrentServer = AddIconToImageList(IDI_CURRENT_SERVER);
|
|
m_idxCurrentNet = AddIconToImageList(IDI_CURRENT_NET);
|
|
m_idxCurrentConsole = AddIconToImageList(IDI_CURRENT_CONSOLE);
|
|
m_idxCurrentAsync = AddIconToImageList(IDI_CURRENT_ASYNC);
|
|
m_idxDirectAsync = AddIconToImageList(IDI_DIRECT_ASYNC);
|
|
m_idxCurrentDirectAsync = AddIconToImageList(IDI_CURRENT_DIRECT_ASYNC);
|
|
m_idxDomain = AddIconToImageList(IDI_DOMAIN);
|
|
m_idxCurrentDomain = AddIconToImageList(IDI_CURRENT_DOMAIN);
|
|
m_idxDomainNotConnected = AddIconToImageList(IDI_DOMAIN_NOT_CONNECTED);
|
|
m_idxServerNotConnected = AddIconToImageList(IDI_SERVER_NOT_CONNECTED);
|
|
|
|
// Overlay for Servers we can't talk to
|
|
m_ImageList.SetOverlayImage(m_idxNotSign, 1);
|
|
// Overlay for Servers we are currently gathering information about
|
|
m_ImageList.SetOverlayImage(m_idxQuestion, 2);
|
|
|
|
GetTreeCtrl().SetImageList(&m_ImageList, TVSIL_NORMAL);
|
|
|
|
} // end CAdminTreeView::BuildImageList
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::DetermineWinStationText
|
|
//
|
|
// determines the appropriate text to display for
|
|
// a WinStation in the tree
|
|
//
|
|
void CAdminTreeView::DetermineWinStationText(CWinStation *pWinStation, TCHAR *NameToDisplay)
|
|
{
|
|
ASSERT(pWinStation);
|
|
ASSERT(NameToDisplay);
|
|
|
|
CString NameString;
|
|
const TCHAR *pState = StrConnectState(pWinStation->GetState(), FALSE);
|
|
|
|
switch(pWinStation->GetState()) {
|
|
case State_Active: // user logged on to WinStation
|
|
case State_Connected: // WinStation connected to client
|
|
case State_ConnectQuery: // in the process of connecting to client
|
|
case State_Shadow: // shadowing another WinStation
|
|
if(wcslen(pWinStation->GetUserName())) {
|
|
NameString.Format(TEXT("%s (%s)"), pWinStation->GetName(), pWinStation->GetUserName());
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
}
|
|
else
|
|
{
|
|
if( pWinStation->GetState() == State_ConnectQuery )
|
|
{
|
|
CString ConnQ;
|
|
ConnQ.LoadString( IDS_CONNQ );
|
|
|
|
lstrcpyn(NameToDisplay , ConnQ, DISPLAY_NAME_SIZE);
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(NameToDisplay, pWinStation->GetName(), DISPLAY_NAME_SIZE);
|
|
}
|
|
}
|
|
break;
|
|
case State_Disconnected: // WinStation logged on without client
|
|
if(wcslen(pWinStation->GetUserName())) {
|
|
NameString.Format(TEXT("%s (%s)"), pState, pWinStation->GetUserName());
|
|
}
|
|
else NameString.Format(TEXT("%s (%lu)"), pState, pWinStation->GetLogonId());
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
break;
|
|
case State_Idle: // waiting for client to connect
|
|
if(pWinStation->GetServer()->GetCTXVersionNum() < 0x200) {
|
|
NameString.Format(TEXT("%s (%s)"), pWinStation->GetName(), pState);
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
} else {
|
|
NameString.Format(TEXT("%s (%lu)"), pState, pWinStation->GetLogonId());
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
}
|
|
break;
|
|
case State_Down: // WinStation is down due to error
|
|
NameString.Format(TEXT("%s (%lu)"), pState, pWinStation->GetLogonId());
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
break;
|
|
case State_Listen: // WinStation is listening for connection
|
|
{
|
|
CString ListenString;
|
|
ListenString.LoadString(IDS_LISTENER);
|
|
NameString.Format(TEXT("%s (%s)"), pWinStation->GetName(), ListenString);
|
|
lstrcpyn(NameToDisplay, NameString, DISPLAY_NAME_SIZE);
|
|
}
|
|
break;
|
|
case State_Reset: // WinStation is being reset
|
|
case State_Init: // WinStation in initialization
|
|
lstrcpyn(NameToDisplay, pWinStation->GetName(), DISPLAY_NAME_SIZE);
|
|
break;
|
|
}
|
|
|
|
} // end CAdminTreeView::DetermineWinStationText
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::DetermineWinStationIcon
|
|
//
|
|
// determines which icon to display for a WinStation
|
|
// in the tree
|
|
//
|
|
int CAdminTreeView::DetermineWinStationIcon(CWinStation *pWinStation)
|
|
{
|
|
ASSERT(pWinStation);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
return WhichIcon;
|
|
|
|
} // end CAdminTreeView::DetermineWinStationIcon
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::DetermineDomainIcon
|
|
//
|
|
// determines which icon to display for a Domain
|
|
// in the tree
|
|
//
|
|
int CAdminTreeView::DetermineDomainIcon(CDomain *pDomain)
|
|
{
|
|
ASSERT(pDomain);
|
|
|
|
int WhichIcon = m_idxDomain;
|
|
|
|
if(pDomain->IsCurrentDomain()) return m_idxCurrentDomain;
|
|
|
|
if(pDomain->GetState() != DS_ENUMERATING && pDomain->GetState() != DS_INITIAL_ENUMERATION)
|
|
WhichIcon = m_idxDomainNotConnected;
|
|
|
|
return WhichIcon;
|
|
|
|
} // end CAdminTreeView::DetermineDomainIcon
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::DetermineServerIcon
|
|
//
|
|
// determines which icon to display for a Server
|
|
// in the tree
|
|
//
|
|
int CAdminTreeView::DetermineServerIcon(CServer *pServer)
|
|
{
|
|
ASSERT(pServer);
|
|
|
|
int WhichIcon = m_idxServer;
|
|
|
|
// Is this the current server?
|
|
if(pServer->IsCurrentServer()) {
|
|
if(pServer->IsState(SS_NONE) || pServer->IsState(SS_NOT_CONNECTED))
|
|
WhichIcon = m_idxServerNotConnected;
|
|
else
|
|
WhichIcon = m_idxCurrentServer;
|
|
} else { // not the current server
|
|
if(pServer->IsState(SS_NONE) || pServer->IsState(SS_NOT_CONNECTED))
|
|
WhichIcon = m_idxServerNotConnected;
|
|
}
|
|
|
|
return WhichIcon;
|
|
|
|
} // end CAdminTreeView::DetermineServerIcon
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::AddServerChildren
|
|
//
|
|
// Adds the WinStations attached to a given Server
|
|
// to the tree
|
|
//
|
|
void CAdminTreeView::AddServerChildren(HTREEITEM hServer, CServer *pServer , NODETYPE nt)
|
|
{
|
|
ASSERT(hServer);
|
|
ASSERT(pServer);
|
|
|
|
if(pServer->IsServerSane()) {
|
|
|
|
LockTreeControl();
|
|
|
|
HTREEITEM hLastNode = hServer;
|
|
|
|
pServer->LockWinStationList();
|
|
|
|
// Get a pointer to the 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);
|
|
|
|
// Figure out which icon to use
|
|
int WhichIcon = DetermineWinStationIcon(pWinStation);
|
|
|
|
// Figure out what text to display
|
|
TCHAR NameToDisplay[DISPLAY_NAME_SIZE];
|
|
DetermineWinStationText(pWinStation, NameToDisplay);
|
|
|
|
CTreeNode *pNode = new CTreeNode(NODE_WINSTATION, pWinStation);
|
|
|
|
if( pNode != NULL )
|
|
{
|
|
pNode->SetSortOrder(pWinStation->GetSortOrder());
|
|
|
|
hLastNode = AddItemToTree(hServer, NameToDisplay, hLastNode, WhichIcon, (LPARAM)pNode);
|
|
|
|
if( hLastNode == NULL )
|
|
{
|
|
delete pNode;
|
|
}
|
|
}
|
|
|
|
// The WinStation wants to know his tree item handle
|
|
|
|
if( nt == NODE_FAV_LIST )
|
|
{
|
|
pWinStation->SetTreeItemForFav(hLastNode);
|
|
}
|
|
else if( nt == NODE_SERVER )
|
|
{
|
|
pWinStation->SetTreeItem(hLastNode);
|
|
}
|
|
else if( nt == NODE_THIS_COMP )
|
|
{
|
|
pWinStation->SetTreeItemForThisComputer( hLastNode );
|
|
}
|
|
}
|
|
|
|
pServer->UnlockWinStationList();
|
|
|
|
UnlockTreeControl();
|
|
|
|
} // end if(pServer->IsServerSane())
|
|
|
|
|
|
} // end CAdminTreeView::AddServerChildren
|
|
|
|
|
|
/////////////////////////////////////////
|
|
// F'N: CAdminTreeView::AddDomainToTree
|
|
//
|
|
// Adds a domain to the tree
|
|
//
|
|
HTREEITEM CAdminTreeView::AddDomainToTree(CDomain *pDomain)
|
|
{
|
|
ASSERT(pDomain);
|
|
|
|
LockTreeControl();
|
|
|
|
HTREEITEM hDomain = NULL;
|
|
|
|
// this points to this computer root
|
|
HTREEITEM hR2 = GetTreeCtrl().GetRootItem();
|
|
|
|
// this points to favorite list
|
|
hR2 = GetTreeCtrl().GetNextItem( hR2 , TVGN_NEXT );
|
|
|
|
// this points to All servers
|
|
HTREEITEM hRoot = GetTreeCtrl().GetNextItem( hR2 , TVGN_NEXT );
|
|
// Add the domain to the tree
|
|
// Create a CTreeNode object with info about this tree node
|
|
CTreeNode* pNode = new CTreeNode(NODE_DOMAIN, pDomain);
|
|
if(pNode) {
|
|
hDomain = AddItemToTree(hRoot, pDomain->GetName(), TVI_SORT, DetermineDomainIcon(pDomain), (LPARAM)pNode);
|
|
if(!hDomain) delete pNode;
|
|
// Change the icon/overlay for the domain
|
|
if(pDomain->GetState() == DS_INITIAL_ENUMERATION)
|
|
GetTreeCtrl().SetItemState(hDomain, STATE_QUESTION, 0x0F00);
|
|
|
|
// The domain wants to know his tree item handle
|
|
pDomain->SetTreeItem(hDomain);
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
return(hDomain);
|
|
|
|
} // end CAdminTreeView::AddDomainToTree
|
|
|
|
|
|
//////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminViewsReady
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminViewsReady(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LockTreeControl();
|
|
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *doc = (CWinAdminDoc*)GetDocument();
|
|
|
|
// We want to remember the tree item of the current server for later
|
|
HTREEITEM hCurrentServer = NULL;
|
|
|
|
HTREEITEM hThisComputerRootItem = NULL;
|
|
HTREEITEM hThisComputer = NULL;
|
|
HTREEITEM hFavRoot = NULL;
|
|
|
|
// add enum for fav node
|
|
CString cstrThisComputer;
|
|
CString cstrFavSrv;
|
|
|
|
CNodeType *pNodeType = new CNodeType( NODE_THIS_COMP );
|
|
|
|
// ok to pass in null
|
|
|
|
CTreeNode *pThisComp = new CTreeNode( NODE_THIS_COMP , pNodeType );
|
|
|
|
if( pThisComp != NULL )
|
|
{
|
|
cstrThisComputer.LoadString( IDS_THISCOMPUTER );
|
|
|
|
hThisComputerRootItem = AddItemToTree( NULL , cstrThisComputer , TVI_ROOT , m_idxDomain , ( LPARAM )pThisComp );
|
|
}
|
|
|
|
// ok to overrun
|
|
|
|
pNodeType = new CNodeType( NODE_FAV_LIST );
|
|
|
|
// it's ok to pass null here
|
|
|
|
CTreeNode *pFavNode = new CTreeNode( NODE_FAV_LIST , pNodeType );
|
|
|
|
if( pFavNode != NULL )
|
|
{
|
|
cstrFavSrv.LoadString( IDS_FAVSERVERS );
|
|
|
|
hFavRoot = AddItemToTree( NULL , cstrFavSrv , TVI_ROOT , m_idxCitrix, ( LPARAM )pFavNode );
|
|
}
|
|
|
|
// add the root to the tree
|
|
CString citrix;
|
|
citrix.LoadString(IDS_TREEROOT);
|
|
CTreeNode* pRootNode = new CTreeNode(NODE_ALL_SERVERS, NULL);
|
|
if(!pRootNode) {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
HTREEITEM hRoot = AddItemToTree(NULL, citrix, TVI_ROOT, m_idxCitrix, (LPARAM)pRootNode);
|
|
|
|
if(!hRoot) delete pRootNode;
|
|
|
|
// set up some 'placeholder'-style vars
|
|
HTREEITEM hCurrParent = hRoot;
|
|
HTREEITEM hLastConnection = hRoot;
|
|
HTREEITEM hLastNode = hRoot;
|
|
HTREEITEM hDomain = NULL;
|
|
|
|
// Get a pointer to the list of domains
|
|
CObList *pDomainList = doc->GetDomainList();
|
|
POSITION dpos = pDomainList->GetHeadPosition();
|
|
|
|
while(dpos) {
|
|
CDomain *pDomain = (CDomain*)pDomainList->GetNext(dpos);
|
|
AddDomainToTree(pDomain);
|
|
}
|
|
|
|
// Get a pointer to the list of servers
|
|
doc->LockServerList();
|
|
CObList *pServerList = doc->GetServerList();
|
|
|
|
// Iterate through the server list
|
|
POSITION pos = pServerList->GetHeadPosition();
|
|
|
|
CServer *pCurrentServer;
|
|
|
|
while(pos) {
|
|
// Go to the next server in the list
|
|
CServer *pServer = (CServer*)pServerList->GetNext(pos);
|
|
|
|
if( pServer == NULL )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// If this Server's domain isn't in the tree, add it
|
|
CDomain *pDomain = pServer->GetDomain();
|
|
if(pDomain != NULL )
|
|
{
|
|
hDomain = pDomain->GetTreeItem();
|
|
ASSERT(hDomain);
|
|
}
|
|
else
|
|
{
|
|
// server is not in a domain
|
|
hDomain = hRoot;
|
|
}
|
|
|
|
// Add the server to the tree
|
|
// Create a CTreeNode object with info about this tree node
|
|
CTreeNode* pNode = new CTreeNode(NODE_SERVER, pServer);
|
|
if(pNode) {
|
|
|
|
if( !pServer->IsCurrentServer() )
|
|
{
|
|
// If the server is the current server, use a different icon
|
|
hLastConnection = AddItemToTree(hDomain,
|
|
pServer->GetName(),
|
|
hLastConnection,
|
|
DetermineServerIcon(pServer),
|
|
(LPARAM)pNode);
|
|
if(!hLastConnection) delete pNode;
|
|
// The server wants to know his tree item handle
|
|
pServer->SetTreeItem(hLastConnection);
|
|
// If the server isn't sane, put a not sign over the icon
|
|
if(!pServer->IsServerSane()) GetTreeCtrl().SetItemState(hLastConnection, 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_GETTING_INFO)) GetTreeCtrl().SetItemState(hLastConnection, STATE_QUESTION, 0x0F00);
|
|
|
|
AddServerChildren(hLastConnection, pServer , NODE_SERVER );
|
|
}
|
|
|
|
// Remember if this is the current server
|
|
else
|
|
{
|
|
hCurrentServer = hLastConnection;
|
|
|
|
/* Add this item under the this computer root */
|
|
|
|
hThisComputer = AddItemToTree( hThisComputerRootItem ,
|
|
pServer->GetName() ,
|
|
TVI_FIRST ,
|
|
DetermineServerIcon(pServer),
|
|
(LPARAM)pNode );
|
|
|
|
CTreeNode* pItem = new CTreeNode(NODE_SERVER, pServer);
|
|
|
|
// uncomment this line if you want this computer to be part of the domain tree list
|
|
/*
|
|
hLastConnection = AddItemToTree( hDomain,
|
|
pServer->GetName(),
|
|
hLastConnection,
|
|
DetermineServerIcon(pServer),
|
|
(LPARAM)pItem);
|
|
*/
|
|
|
|
pServer->SetTreeItemForThisComputer( hThisComputer );
|
|
|
|
// uncomment this line if you want this computer to be part of the domain tree list
|
|
// pServer->SetTreeItem( hLastConnection );
|
|
|
|
if( !pServer->IsServerSane() )
|
|
{
|
|
GetTreeCtrl().SetItemState(hThisComputer, STATE_NOT, 0x0F00);
|
|
// uncomment this line if you want this computer to be part of the domain tree list
|
|
// GetTreeCtrl().SetItemState(hLastConnection, STATE_NOT, 0x0F00);
|
|
}
|
|
|
|
// uncomment this line if you want this computer to be part of the domain tree list
|
|
// AddServerChildren( hLastConnection, pServer , NODE_SERVER );
|
|
|
|
AddServerChildren( hThisComputer , pServer , NODE_SERVER );
|
|
}
|
|
|
|
}
|
|
} // end while(pos)
|
|
|
|
doc->UnlockServerList();
|
|
|
|
// We want to show the main server in this computer node
|
|
|
|
//GetTreeCtrl().Expand(hRoot, TVE_EXPAND);
|
|
|
|
GetTreeCtrl().Expand( hThisComputerRootItem , TVE_COLLAPSE );
|
|
|
|
/*
|
|
LRESULT lResult = 0xc0;
|
|
// We want to default to having the current server being the
|
|
// currently selected item in the tree and be expanded
|
|
|
|
if( hThisComputerRootItem != NULL && ( g_dwTreeViewExpandedStates & TV_THISCOMP ) )
|
|
{
|
|
if( hThisComputer != NULL )
|
|
{
|
|
GetTreeCtrl().SelectItem(hThisComputer);
|
|
GetTreeCtrl().Expand(hThisComputer, TVE_EXPAND);
|
|
// GetTreeCtrl().Expand(hDomain, TVE_EXPAND);
|
|
//lResult = 0xc0;
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
}
|
|
|
|
if( hFavRoot != NULL && ( g_dwTreeViewExpandedStates & TV_FAVS ) )
|
|
{
|
|
GetTreeCtrl().SelectItem( hFavRoot );
|
|
GetTreeCtrl().Expand( hFavRoot , TVE_EXPAND );
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
|
|
if( hRoot != NULL && ( g_dwTreeViewExpandedStates & TV_ALLSERVERS ) )
|
|
{
|
|
GetTreeCtrl().SelectItem( hRoot );
|
|
GetTreeCtrl().Expand( hRoot , TVE_EXPAND );
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
|
|
*/
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminViewsReady
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminAddServer
|
|
//
|
|
// Message Handler to add a Server to the tree
|
|
// Pointer to CServer to add is in lParam
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminAddServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
CServer *pServer = (CServer*)lParam;
|
|
|
|
LockTreeControl();
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
// If this Server's domain isn't in the tree, add it
|
|
HTREEITEM hDomain = NULL;
|
|
CDomain *pDomain = pServer->GetDomain();
|
|
if(pDomain) {
|
|
hDomain = pDomain->GetTreeItem();
|
|
ASSERT(hDomain);
|
|
} else {
|
|
// server is not in a domain
|
|
hDomain = tree.GetRootItem();
|
|
}
|
|
|
|
// First make sure the server isn't already in the tree
|
|
// Get the first server under the domain
|
|
HTREEITEM hItem = tree.GetNextItem(hDomain, TVGN_CHILD);
|
|
while(hItem) {
|
|
// Get the data attached to the tree item
|
|
CTreeNode *node = (CTreeNode*)tree.GetItemData(hItem);
|
|
if(node) {
|
|
// Is this the server we want to add
|
|
CServer *pNewServer = (CServer*)node->GetTreeObject();
|
|
if(pNewServer == (CServer*)lParam) {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
}
|
|
hItem = tree.GetNextItem(hItem, TVGN_NEXT);
|
|
}
|
|
|
|
// Add the server to the tree
|
|
// Create a CTreeNode object with info about this tree node
|
|
CTreeNode* pNode = new CTreeNode(NODE_SERVER, pServer);
|
|
if(pNode)
|
|
{
|
|
// If the server is the current server, use a different icon
|
|
|
|
HTREEITEM hServer = AddItemToTree(hDomain, pServer->GetName(), (HTREEITEM)wParam,
|
|
DetermineServerIcon(pServer), (LPARAM)pNode);
|
|
if( !hServer )
|
|
{
|
|
delete pNode;
|
|
}
|
|
// The server wants to know his tree item handle
|
|
pServer->SetTreeItem(hServer);
|
|
// If the server isn't sane, put a not sign over the icon
|
|
if( !pServer->IsServerSane() )
|
|
{
|
|
tree.SetItemState(hServer, 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_GETTING_INFO))
|
|
{
|
|
tree.SetItemState(hServer, STATE_QUESTION, 0x0F00);
|
|
}
|
|
|
|
AddServerChildren(hServer, pServer , NODE_SERVER );
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminAddServer
|
|
|
|
//----------------------------------------------------------------------
|
|
// ok if you traced me to here you are almost there
|
|
// 1) now we need to update the server item and place it under the favorites
|
|
// folder
|
|
// 2) inform the server child items that it will have a new parent
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminAddServerToFavs( WPARAM wp , LPARAM lp )
|
|
{
|
|
CServer *pServer = ( CServer* )lp;
|
|
|
|
if( pServer == NULL )
|
|
{
|
|
ODS( L"CAdminTreeView::OnAdminAddServerToFavs invalid arg\n");
|
|
return ( LRESULT )-1;
|
|
}
|
|
|
|
LockTreeControl( );
|
|
|
|
if( pServer->IsServerInactive() || pServer->IsState( SS_DISCONNECTING ) )
|
|
{
|
|
UnlockTreeControl( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
HTREEITEM hFavs = GetTreeCtrl().GetRootItem( );
|
|
HTREEITEM hItem;
|
|
|
|
hFavs = tree.GetNextItem( hFavs , TVGN_NEXT );
|
|
|
|
hItem = tree.GetNextItem( hFavs , TVGN_CHILD );
|
|
|
|
|
|
// check for duplicate entry
|
|
|
|
while( hItem != NULL )
|
|
{
|
|
// Get the data attached to the tree item
|
|
CTreeNode *pTreenode = (CTreeNode*)tree.GetItemData( hItem );
|
|
|
|
if( pTreenode != NULL )
|
|
{
|
|
// Is this the server we want to add
|
|
CServer *pSvr = (CServer*)pTreenode->GetTreeObject();
|
|
|
|
if( pSvr == pServer )
|
|
{
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
hItem = tree.GetNextItem(hItem, TVGN_NEXT);
|
|
}
|
|
|
|
CTreeNode* pNode = new CTreeNode(NODE_SERVER, pServer);
|
|
|
|
if( pNode != NULL )
|
|
{
|
|
HTREEITEM hServer = AddItemToTree( hFavs,
|
|
pServer->GetName(),
|
|
TVI_SORT,
|
|
DetermineServerIcon(pServer),
|
|
(LPARAM)pNode);
|
|
|
|
|
|
if( hServer == NULL )
|
|
{
|
|
delete pNode;
|
|
}
|
|
|
|
// The server wants to know his tree item handle
|
|
pServer->SetTreeItemForFav( hServer );
|
|
|
|
// If the server isn't sane, put a not sign over the icon
|
|
if( !pServer->IsServerSane() )
|
|
{
|
|
tree.SetItemState(hServer, 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_GETTING_INFO ) )
|
|
{
|
|
tree.SetItemState(hServer, STATE_QUESTION, 0x0F00);
|
|
}
|
|
|
|
AddServerChildren( hServer , pServer , NODE_FAV_LIST );
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
tree.Invalidate( );
|
|
|
|
return 0;
|
|
}
|
|
//=----------------------------------------------------------------------------------
|
|
LRESULT CAdminTreeView::OnAdminRemoveServerFromFavs( WPARAM wp , LPARAM lp )
|
|
{
|
|
LockTreeControl();
|
|
|
|
CServer *pServer = ( CServer* )lp;
|
|
|
|
DBGMSG( L"CAdminTreeView::OnAdminRemoveServerFromFavs -- %s\n" , pServer->GetName( ) );
|
|
|
|
HTREEITEM hFavServer = pServer->GetTreeItemFromFav();
|
|
|
|
#ifdef _STRESS_BUILD
|
|
DBGMSG( L"Handle to hFavServer 0x%x\n" , hFavServer );
|
|
#endif
|
|
|
|
if( hFavServer == NULL )
|
|
{
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Get the data attached to this tree node
|
|
|
|
|
|
CTreeNode *pNode = (CTreeNode*)GetTreeCtrl().GetItemData( hFavServer );
|
|
|
|
if( pNode != NULL && pNode->GetNodeType( ) == NODE_SERVER )
|
|
{
|
|
// Is this the server we want to update
|
|
CServer *pTreeServer = ( CServer* )pNode->GetTreeObject();
|
|
|
|
if( pTreeServer != pServer)
|
|
{
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Loop through it's children and delete their data
|
|
|
|
pServer->LockWinStationList( );
|
|
|
|
HTREEITEM hChild = GetTreeCtrl().GetNextItem( hFavServer , TVGN_CHILD );
|
|
|
|
while( hChild != NULL )
|
|
{
|
|
CTreeNode *pChildNode = ( CTreeNode* )GetTreeCtrl().GetItemData( hChild );
|
|
|
|
if( pChildNode != NULL && pChildNode->GetNodeType( ) == NODE_WINSTATION )
|
|
{
|
|
// Tell the WinStation it is no longer in the tree
|
|
CWinStation *pWinStation = ( CWinStation* )pChildNode->GetTreeObject();
|
|
|
|
if( pWinStation != NULL )
|
|
{
|
|
pWinStation->SetTreeItemForFav(NULL);
|
|
}
|
|
|
|
delete pChildNode;
|
|
}
|
|
|
|
hChild = GetTreeCtrl().GetNextItem( hChild , TVGN_NEXT );
|
|
}
|
|
|
|
// Delete the data attached to the tree item
|
|
delete pNode;
|
|
|
|
// Let the server know he is no longer in the tree
|
|
pServer->SetTreeItemForFav(NULL);
|
|
|
|
GetTreeCtrl().DeleteItem( hFavServer );
|
|
|
|
pServer->UnlockWinStationList( );
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminRemoveServer
|
|
//
|
|
// Message Handler to remove a Server from the tree
|
|
// Pointer to CServer of server to remove is in lParam
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminRemoveServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
CServer *pServer = (CServer*)lParam;
|
|
|
|
HTREEITEM hServer = pServer->GetTreeItem();
|
|
if(!hServer) return 0;
|
|
|
|
LockTreeControl();
|
|
|
|
// Get the data attached to this tree node
|
|
CTreeNode *node = (CTreeNode*)GetTreeCtrl().GetItemData(hServer);
|
|
if(node) {
|
|
// Is this the server we want to update
|
|
CServer *pTreeServer = (CServer*)node->GetTreeObject();
|
|
// Make sure the tree node is correct
|
|
if(pTreeServer != pServer) {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
// Loop through it's children and delete their data
|
|
HTREEITEM hChild = GetTreeCtrl().GetNextItem(hServer, TVGN_CHILD);
|
|
while(hChild) {
|
|
CTreeNode *ChildNode = (CTreeNode*)GetTreeCtrl().GetItemData(hChild);
|
|
if(ChildNode) {
|
|
// Tell the WinStation it is no longer in the tree
|
|
CWinStation *pWinStation = (CWinStation*)ChildNode->GetTreeObject();
|
|
if(pWinStation)
|
|
pWinStation->SetTreeItem(NULL);
|
|
delete ChildNode;
|
|
}
|
|
hChild = GetTreeCtrl().GetNextItem(hChild, TVGN_NEXT);
|
|
}
|
|
|
|
// Delete the data attached to the tree item
|
|
delete node;
|
|
// Let the server know he is no longer in the tree
|
|
pServer->SetTreeItem(NULL);
|
|
// Remove the server from the tree
|
|
// This SHOULD remove all it's children
|
|
GetTreeCtrl().DeleteItem(hServer);
|
|
|
|
|
|
// TODO
|
|
// if this means that CServer does not exist we need to remove this from the favorite list
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminRemoveServer
|
|
|
|
|
|
/*=--------------------------------------------------------------------------------------
|
|
OnAdminUpdateServer
|
|
|
|
Message handler to update a Server in the tree
|
|
Pointer to CServer to update is in lParam
|
|
|
|
Updates server item in favorites folder
|
|
and if server item is this computer it gets updated as well.
|
|
|
|
*=------------------------------------------------------------------------------------*/
|
|
LRESULT CAdminTreeView::OnAdminUpdateServer(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
LockTreeControl( );
|
|
// If favorite folders is expanded don't forget to update the tree item
|
|
|
|
CServer *pServer = (CServer*)lParam;
|
|
|
|
HTREEITEM hServer = pServer->GetTreeItem();
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
UpdateServerTreeNodeState( hServer , pServer , NODE_SERVER );
|
|
}
|
|
|
|
hServer = pServer->GetTreeItemFromFav( );
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
UpdateServerTreeNodeState( hServer , pServer , NODE_FAV_LIST );
|
|
}
|
|
|
|
hServer = pServer->GetTreeItemFromThisComputer( );
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
UpdateServerTreeNodeState( hServer , pServer , NODE_THIS_COMP );
|
|
}
|
|
|
|
UnlockTreeControl( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=--------------------------------------------------------------------------------------
|
|
|
|
UpdateServerTreeNodeState
|
|
|
|
hServer -- tree item that needs updating
|
|
pServer -- server object
|
|
|
|
*=------------------------------------------------------------------------------------*/
|
|
LRESULT CAdminTreeView::UpdateServerTreeNodeState( HTREEITEM hServer , CServer *pServer , NODETYPE nt )
|
|
{
|
|
LockTreeControl( );
|
|
|
|
if( hServer == NULL )
|
|
{
|
|
UnlockTreeControl( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Get the data attached to this tree node
|
|
|
|
CTreeNode *node = (CTreeNode*)GetTreeCtrl().GetItemData(hServer);
|
|
if( node != NULL && node->GetNodeType( ) == NODE_SERVER )
|
|
{
|
|
// Is this the server we want to update
|
|
CServer *pTreeServer = (CServer*)node->GetTreeObject();
|
|
// Make sure the tree node is correct
|
|
if(pTreeServer != pServer)
|
|
{
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
}
|
|
|
|
UINT NewState;
|
|
// Remember the previous state
|
|
UINT PreviousState = GetTreeCtrl().GetItemState(hServer, 0x0F00);
|
|
// 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_GETTING_INFO)) 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
|
|
GetTreeCtrl().SetItemState(hServer, NewState, 0x0F00);
|
|
|
|
// If this Server was not opened and now is GOOD,
|
|
// add it's children to the tree
|
|
if(PreviousState != STATE_NORMAL && pServer->IsState(SS_GOOD)) {
|
|
int ServerIcon = DetermineServerIcon(pServer);
|
|
GetTreeCtrl().SetItemImage(hServer, ServerIcon, ServerIcon);
|
|
AddServerChildren(hServer, pServer , nt );
|
|
// If this server is the server the user is sitting at and is
|
|
// the currently selected tree item, expand it
|
|
if(hServer == GetTreeCtrl().GetSelectedItem() && pServer->IsCurrentServer()) {
|
|
GetTreeCtrl().Expand(hServer, TVE_EXPAND);
|
|
}
|
|
}
|
|
else if(pServer->GetPreviousState() == SS_DISCONNECTING && pServer->IsState(SS_NOT_CONNECTED)) {
|
|
int ServerIcon = DetermineServerIcon(pServer);
|
|
GetTreeCtrl().SetItemImage(hServer, ServerIcon, ServerIcon);
|
|
}
|
|
|
|
// If we changed the state of this server and it is the currently
|
|
// selected node in the tree, we need to send a message to change
|
|
// the view
|
|
if(NewState != PreviousState && hServer == GetTreeCtrl().GetSelectedItem()) {
|
|
ForceSelChange();
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminUpdateServer
|
|
|
|
|
|
LRESULT CAdminTreeView::OnAdminAddWinStation(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
ODS( L"**CAdminTreeView::OnAdminAddWinStation\n" );
|
|
|
|
CWinStation *pWinStation = (CWinStation*)lParam;
|
|
|
|
|
|
// Get the HTREEITEM of the Server this WinStation is attached to
|
|
// TODO:
|
|
// update the server item in the favorite list
|
|
|
|
HTREEITEM hServer = pWinStation->GetServer()->GetTreeItem();
|
|
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
AddWinStation( pWinStation , hServer , ( BOOL )wParam , NODE_NONE );
|
|
}
|
|
|
|
hServer = pWinStation->GetServer( )->GetTreeItemFromFav( );
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
AddWinStation( pWinStation , hServer , ( BOOL )wParam , NODE_FAV_LIST );
|
|
}
|
|
|
|
hServer = pWinStation->GetServer( )->GetTreeItemFromThisComputer( );
|
|
|
|
if( hServer != NULL )
|
|
{
|
|
AddWinStation( pWinStation , hServer , ( BOOL )wParam , NODE_THIS_COMP );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminAddWinStation
|
|
//
|
|
// Message handler to add a WinStation to the tree
|
|
// lParam = pointer to CWinStation to add
|
|
// wParam is TRUE if this is replacing a WinStation that was currently selected
|
|
//
|
|
LRESULT CAdminTreeView::AddWinStation( CWinStation * pWinStation , HTREEITEM hServer , BOOL bSel , NODETYPE nt )
|
|
{
|
|
ODS( L"**CAdminTreeView::AddWinStation\n" );
|
|
|
|
HTREEITEM hWinStation;
|
|
|
|
LockTreeControl();
|
|
|
|
// Figure out which icon to use
|
|
int WhichIcon = DetermineWinStationIcon(pWinStation);
|
|
|
|
// Figure out what text to display
|
|
TCHAR NameToDisplay[DISPLAY_NAME_SIZE];
|
|
DetermineWinStationText(pWinStation, NameToDisplay);
|
|
|
|
CTreeNode *pNode = new CTreeNode(NODE_WINSTATION, pWinStation);
|
|
if(pNode) {
|
|
pNode->SetSortOrder(pWinStation->GetSortOrder());
|
|
|
|
// We have to insert this WinStation in sorted order
|
|
// Get the first WinStation item attached to this server
|
|
HTREEITEM hChild = GetTreeCtrl().GetNextItem(hServer, TVGN_CHILD);
|
|
HTREEITEM hLastChild = TVI_FIRST;
|
|
BOOL bAdded = FALSE;
|
|
|
|
while(hChild)
|
|
{
|
|
CTreeNode *ChildNode = (CTreeNode*)GetTreeCtrl().GetItemData(hChild);
|
|
if(ChildNode)
|
|
{
|
|
// Does it belong before this tree node?
|
|
CWinStation *pTreeWinStation = (CWinStation*)ChildNode->GetTreeObject();
|
|
if((pTreeWinStation->GetSortOrder() > pWinStation->GetSortOrder())
|
|
|| ((pTreeWinStation->GetSortOrder() == pWinStation->GetSortOrder()) &&
|
|
(pTreeWinStation->GetSdClass() > pWinStation->GetSdClass())))
|
|
{
|
|
hWinStation = AddItemToTree(hServer, NameToDisplay, hLastChild, WhichIcon, (LPARAM)pNode);
|
|
|
|
if(!hWinStation)
|
|
{
|
|
delete pNode;
|
|
}
|
|
|
|
// The WinStation wants to know his tree item handle
|
|
|
|
if( nt == NODE_FAV_LIST )
|
|
{
|
|
pWinStation->SetTreeItemForFav( hWinStation );
|
|
}
|
|
else if( nt == NODE_THIS_COMP )
|
|
{
|
|
pWinStation->SetTreeItemForThisComputer( hWinStation );
|
|
}
|
|
else
|
|
{
|
|
pWinStation->SetTreeItem(hWinStation);
|
|
}
|
|
|
|
bAdded = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
hLastChild = hChild;
|
|
hChild = GetTreeCtrl().GetNextItem(hChild, TVGN_NEXT);
|
|
}
|
|
|
|
// If we didn't add it yet, add it at the end
|
|
if(!bAdded)
|
|
{
|
|
hWinStation = AddItemToTree(hServer, NameToDisplay, hLastChild, WhichIcon, (LPARAM)pNode);
|
|
|
|
if( hWinStation == NULL )
|
|
{
|
|
delete pNode;
|
|
}
|
|
|
|
// The WinStation wants to know his tree item handle
|
|
if( nt == NODE_FAV_LIST )
|
|
{
|
|
pWinStation->SetTreeItemForFav( hWinStation );
|
|
}
|
|
else if( nt == NODE_THIS_COMP )
|
|
{
|
|
pWinStation->SetTreeItemForThisComputer( hWinStation );
|
|
}
|
|
else
|
|
{
|
|
pWinStation->SetTreeItem(hWinStation);
|
|
}
|
|
|
|
}
|
|
|
|
// If this is replacing a WinStation in the tree that was the currently selected
|
|
// tree item, make this new item in the tree the currently selected item
|
|
if( bSel ) {
|
|
GetTreeCtrl().SelectItem(hWinStation);
|
|
}
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminAddWinStation
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminUpdateWinStation
|
|
//
|
|
// Message handler to update a WinStation in the tree
|
|
// lParam = pointer to CWinStation to update
|
|
//
|
|
|
|
LRESULT CAdminTreeView::OnAdminUpdateWinStation(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ODS( L"CAdminTreeView::OnAdminUpdateWinStation\n" );
|
|
|
|
ASSERT(lParam);
|
|
|
|
CWinStation *pWinStation = (CWinStation*)lParam;
|
|
|
|
|
|
HTREEITEM hWinStation = pWinStation->GetTreeItem();
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
UpdateWinStation( hWinStation , pWinStation );
|
|
}
|
|
|
|
hWinStation = pWinStation->GetTreeItemFromFav( );
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
UpdateWinStation( hWinStation , pWinStation );
|
|
}
|
|
|
|
hWinStation = pWinStation->GetTreeItemFromThisComputer( );
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
UpdateWinStation( hWinStation , pWinStation );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
LRESULT CAdminTreeView::UpdateWinStation( HTREEITEM hWinStation , CWinStation *pWinStation )
|
|
{
|
|
ODS( L"CAdminTreeView::UpdateWinStation\n" );
|
|
|
|
LockTreeControl();
|
|
|
|
// Get the data attached to this tree node
|
|
CTreeNode *node = (CTreeNode*)GetTreeCtrl().GetItemData(hWinStation);
|
|
if(node) {
|
|
// Is this the WinStation we want to update
|
|
CWinStation *pTreeWinStation = (CWinStation*)node->GetTreeObject();
|
|
// Make sure the tree node is correct
|
|
if(pTreeWinStation != pWinStation) {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
} else {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
// If the sort order of this WinStation has changed,
|
|
// we have to remove it from the tree and add it back in
|
|
if(node->GetSortOrder() != pWinStation->GetSortOrder())
|
|
{
|
|
OnAdminRemoveWinStation( 0 , ( LPARAM )pWinStation );
|
|
|
|
/*GetTreeCtrl().DeleteItem(hWinStation);
|
|
|
|
pWinStation->SetTreeItem(NULL);
|
|
*/
|
|
|
|
OnAdminAddWinStation((GetTreeCtrl().GetSelectedItem() == hWinStation), ( LPARAM )pWinStation );
|
|
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
int WhichIcon = DetermineWinStationIcon(pWinStation);
|
|
GetTreeCtrl().SetItemImage(hWinStation, WhichIcon, WhichIcon);
|
|
|
|
TCHAR NameToDisplay[DISPLAY_NAME_SIZE];
|
|
DetermineWinStationText(pWinStation, NameToDisplay);
|
|
GetTreeCtrl().SetItemText(hWinStation, NameToDisplay);
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminUpdateWinStation
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminRemoveWinStation
|
|
//
|
|
// Message handler to remove a WinStation from the tree
|
|
// lParam = pointer to CWinStation to remove
|
|
LRESULT CAdminTreeView::OnAdminRemoveWinStation(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ODS( L"CAdminTreeView::OnAdminRemoveWinStation\n" );
|
|
|
|
ASSERT(lParam);
|
|
|
|
//TODO:
|
|
// remove winstaion from favorite list
|
|
|
|
CWinStation *pWinStation = (CWinStation*)lParam;
|
|
|
|
HTREEITEM hWinStation;
|
|
|
|
hWinStation = pWinStation->GetTreeItem();
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
RemoveWinstation( hWinStation , pWinStation );
|
|
|
|
pWinStation->SetTreeItem( NULL );
|
|
}
|
|
|
|
hWinStation = pWinStation->GetTreeItemFromFav( );
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
RemoveWinstation( hWinStation , pWinStation );
|
|
|
|
pWinStation->SetTreeItemForFav( NULL );
|
|
}
|
|
|
|
hWinStation = pWinStation->GetTreeItemFromThisComputer( );
|
|
|
|
if( hWinStation != NULL )
|
|
{
|
|
RemoveWinstation( hWinStation , pWinStation );
|
|
|
|
pWinStation->SetTreeItemForThisComputer( NULL );
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
LRESULT CAdminTreeView::RemoveWinstation( HTREEITEM hWinStation , CWinStation *pWinStation )
|
|
{
|
|
BOOL CurrentInTree = FALSE;
|
|
|
|
LockTreeControl();
|
|
|
|
// Get the data attached to this tree node
|
|
CTreeNode *node = ( CTreeNode * )GetTreeCtrl().GetItemData(hWinStation);
|
|
|
|
if( node != NULL )
|
|
{
|
|
// Is this the WinStation we want to update
|
|
CWinStation *pTreeWinStation = (CWinStation*)node->GetTreeObject();
|
|
// Make sure the tree node is correct
|
|
if(pTreeWinStation != pWinStation)
|
|
{
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
// Delete the data attached to the tree item
|
|
delete node;
|
|
// Let the WinStation know he is no longer in the tree
|
|
|
|
// Is this WinStation currently selected in the tree?
|
|
CurrentInTree = ( GetTreeCtrl().GetSelectedItem() == hWinStation );
|
|
|
|
// Remove the WinStation from the tree
|
|
GetTreeCtrl().DeleteItem( hWinStation );
|
|
|
|
// If this WinStation is the currently selected node in the tree,
|
|
// make it not so
|
|
// This may not be necessary!
|
|
if( CurrentInTree )
|
|
{
|
|
((CWinAdminDoc*)GetDocument())->SetCurrentView(VIEW_CHANGING);
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminRemoveWinStation
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminUpdateDomain
|
|
//
|
|
// Message handler to update a Domain in the tree
|
|
// Pointer to CDomain to update is in lParam
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminUpdateDomain(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
CDomain *pDomain = (CDomain*)lParam;
|
|
|
|
HTREEITEM hDomain = pDomain->GetTreeItem();
|
|
if(!hDomain) return 0;
|
|
|
|
LockTreeControl();
|
|
|
|
// Get the data attached to this tree node
|
|
CTreeNode *node = (CTreeNode*)GetTreeCtrl().GetItemData(hDomain);
|
|
if(node) {
|
|
// Is this the domain we want to update
|
|
CDomain *pTreeDomain = (CDomain*)node->GetTreeObject();
|
|
// Make sure the tree node is correct
|
|
if(pTreeDomain != pDomain) {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
} else {
|
|
UnlockTreeControl();
|
|
return 0;
|
|
}
|
|
|
|
UINT NewState;
|
|
// Remember the previous state
|
|
UINT PreviousState = GetTreeCtrl().GetItemState(hDomain, 0x0F00);
|
|
// Change the icon/overlay for the domain
|
|
if(pDomain->GetState() == DS_INITIAL_ENUMERATION) 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
|
|
GetTreeCtrl().SetItemState(hDomain, NewState, 0x0F00);
|
|
|
|
// If the new state is STATE_NORMAL, change the icon
|
|
if(NewState == STATE_NORMAL) {
|
|
int DomainIcon = DetermineDomainIcon(pDomain);
|
|
GetTreeCtrl().SetItemImage(hDomain, DomainIcon, DomainIcon);
|
|
}
|
|
|
|
// If we changed the state of this domain and it is the currently
|
|
// selected node in the tree, we need to send a message to change
|
|
// the view
|
|
if(NewState != PreviousState && hDomain == GetTreeCtrl().GetSelectedItem()) {
|
|
ForceSelChange();
|
|
}
|
|
|
|
if(pDomain->GetState() == DS_ENUMERATING) GetTreeCtrl().Expand(hDomain, TVE_EXPAND);
|
|
|
|
UnlockTreeControl();
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminUpdateDomain
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnAdminAddDomain
|
|
//
|
|
// Message handler to update a Domain in the tree
|
|
// Pointer to CDomain to update is in lParam
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminAddDomain(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
ASSERT(lParam);
|
|
|
|
if(lParam)
|
|
{
|
|
CDomain *pDomain = (CDomain*)lParam;
|
|
return (LRESULT)AddDomainToTree(pDomain);
|
|
}
|
|
|
|
return 0;
|
|
|
|
} // end CAdminTreeView::OnAdminAddDomain
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnContextMenu
|
|
//
|
|
// Message handler called when user wants a context menu
|
|
// This happens when the user clicks the right mouse button,
|
|
// presses Shift-F10, or presses the menu key on a Windows keyboard
|
|
//
|
|
void CAdminTreeView::OnContextMenu(CWnd* pWnd, CPoint ptScreen)
|
|
{
|
|
LockTreeControl();
|
|
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *doc = (CWinAdminDoc*)GetDocument();
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
// TODO: Add your message handler code here
|
|
HTREEITEM hItem;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
// If we got here from the keyboard,
|
|
if(ptScreen.x == -1 && ptScreen.y == -1) {
|
|
hItem = tree.GetSelectedItem();
|
|
|
|
RECT rect;
|
|
tree.GetItemRect(hItem, &rect, TRUE);
|
|
|
|
ptScreen.x = rect.left + (rect.right - rect.left)/2;
|
|
ptScreen.y = rect.top + (rect.bottom - rect.top)/2;
|
|
|
|
tree.ClientToScreen(&ptScreen);
|
|
|
|
}
|
|
else {
|
|
// we shouldn't get here from the mouse
|
|
// but sometimes we do, so handle it gracefully
|
|
UnlockTreeControl();
|
|
return;
|
|
}
|
|
|
|
// Pop-up the menu for WinStations
|
|
CTreeNode *pNode = (CTreeNode*)tree.GetItemData(hItem);
|
|
((CWinAdminDoc*)GetDocument())->SetTreeTemp(pNode->GetTreeObject(), (pNode->GetNodeType()));
|
|
|
|
if(pNode) {
|
|
CMenu menu;
|
|
UINT nIDResource = 0;
|
|
|
|
switch(pNode->GetNodeType()) {
|
|
case NODE_ALL_SERVERS:
|
|
nIDResource = IDR_ALLSERVERS_POPUP;
|
|
break;
|
|
|
|
case NODE_DOMAIN:
|
|
nIDResource = IDR_DOMAIN_POPUP;
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
nIDResource = IDR_SERVER_POPUP;
|
|
break;
|
|
|
|
case NODE_WINSTATION:
|
|
nIDResource = IDR_WINSTATION_TREE_POPUP;
|
|
break;
|
|
}
|
|
|
|
if(nIDResource)
|
|
{
|
|
if(menu.LoadMenu(nIDResource))
|
|
{
|
|
CMenu *pMenu = menu.GetSubMenu(0);
|
|
|
|
pMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
}
|
|
}
|
|
|
|
} // end if(pNode)
|
|
|
|
UnlockTreeControl();
|
|
|
|
} // end CAdminTreeView::OnContextMenu
|
|
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnRClick
|
|
//
|
|
// The Tree Common Control sends a WM_NOTIFY of NM_RCLICK when
|
|
// the user presses the right mouse button in the tree
|
|
//
|
|
void CAdminTreeView::OnRClick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
CPoint ptScreen(::GetMessagePos());
|
|
|
|
LockTreeControl();
|
|
|
|
// Get a pointer to our document
|
|
CWinAdminDoc *doc = (CWinAdminDoc*)GetDocument();
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
// TODO: Add your message handler code here
|
|
UINT flags;
|
|
HTREEITEM hItem;
|
|
CPoint ptClient = ptScreen;
|
|
ScreenToClient(&ptClient);
|
|
|
|
hItem = tree.HitTest(ptClient, &flags);
|
|
if((NULL == hItem) || !(TVHT_ONITEM & flags)) {
|
|
UnlockTreeControl();
|
|
return;
|
|
}
|
|
|
|
// Pop-up the menu
|
|
CTreeNode *pNode = (CTreeNode*)tree.GetItemData(hItem);
|
|
((CWinAdminDoc*)GetDocument())->SetTreeTemp(pNode->GetTreeObject(), (pNode->GetNodeType()));
|
|
|
|
if(pNode) {
|
|
CMenu menu;
|
|
UINT nIDResource = 0;
|
|
|
|
tree.SelectItem( hItem );
|
|
|
|
switch(pNode->GetNodeType()) {
|
|
case NODE_ALL_SERVERS:
|
|
nIDResource = IDR_ALLSERVERS_POPUP;
|
|
break;
|
|
|
|
case NODE_DOMAIN:
|
|
nIDResource = IDR_DOMAIN_POPUP;
|
|
break;
|
|
|
|
case NODE_SERVER:
|
|
nIDResource = IDR_SERVER_POPUP;
|
|
break;
|
|
|
|
case NODE_WINSTATION:
|
|
nIDResource = IDR_WINSTATION_TREE_POPUP;
|
|
break;
|
|
}
|
|
|
|
if(menu.LoadMenu( nIDResource ) )
|
|
{
|
|
CMenu *pMenu = menu.GetSubMenu(0);
|
|
|
|
if( pMenu != NULL )
|
|
{
|
|
pMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y, AfxGetMainWnd());
|
|
}
|
|
}
|
|
|
|
|
|
} // end if(pNode)
|
|
|
|
UnlockTreeControl();
|
|
|
|
} // end CAdminTreeView::OnRClick
|
|
|
|
|
|
|
|
//A false result means the server is disconnected
|
|
BOOL CAdminTreeView::ConnectToServer(CTreeCtrl* tree, HTREEITEM* hItem)
|
|
{
|
|
CTreeNode *pNode = (CTreeNode*)tree->GetItemData(*hItem);
|
|
|
|
if(pNode != NULL && *hItem == tree->GetSelectedItem() )
|
|
{
|
|
if( pNode->GetNodeType() == NODE_SERVER)
|
|
{
|
|
// Is this server in the "just disconnected" state
|
|
CServer *pServer = (CServer*)pNode->GetTreeObject();
|
|
// If both previous state and state are SS_NOT_CONNECTED,
|
|
// we know the user just disconnected from this server
|
|
if(pServer != NULL)
|
|
{
|
|
if(pServer->IsState(SS_NOT_CONNECTED) ||
|
|
pServer->IsState(SS_BAD))
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
else if( pNode->GetNodeType( ) == NODE_DOMAIN )
|
|
{
|
|
CDomain *pDomain = ( CDomain * )pNode->GetTreeObject( );
|
|
|
|
if( pDomain != NULL && pDomain->GetThreadPointer() == NULL )
|
|
pDomain->StartEnumerating();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////
|
|
// F'N: CAdminTreeView::OnLButtonDown
|
|
//
|
|
void CAdminTreeView::OnLButtonDblClk(UINT nFlags, CPoint ptClient)
|
|
{
|
|
LockTreeControl();
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
UINT flags;
|
|
|
|
// Figure out what they clicked on
|
|
HTREEITEM hItem = tree.HitTest(ptClient, &flags);
|
|
if((NULL != hItem) && (TVHT_ONITEM & flags))
|
|
{
|
|
if (!ConnectToServer(&tree, &hItem))
|
|
{
|
|
LRESULT Result = 0xc0;
|
|
OnSelChange(NULL, &Result);
|
|
}
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
|
|
CTreeView::OnLButtonDblClk(nFlags, ptClient);
|
|
}
|
|
|
|
|
|
LRESULT CAdminTreeView::OnAdminConnectToServer( WPARAM wp , LPARAM lp )
|
|
{
|
|
OnEnterKey();
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CAdminTreeView::OnAdminForceSelChange( WPARAM wp , LPARAM lp )
|
|
{
|
|
ForceSelChange();
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CAdminTreeView::OnEnterKey( )
|
|
{
|
|
LockTreeControl();
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl();
|
|
|
|
// Figure out what's selected
|
|
HTREEITEM hItem = tree.GetSelectedItem( );
|
|
|
|
if (!ConnectToServer(&tree, &hItem))
|
|
{
|
|
LRESULT Result = 0xc0;
|
|
OnSelChange(NULL, &Result);
|
|
}
|
|
|
|
UnlockTreeControl();
|
|
}
|
|
|
|
void CAdminTreeView::OnSetFocus( CWnd *pOld )
|
|
{
|
|
CWnd::OnSetFocus( pOld );
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)GetDocument();
|
|
|
|
pDoc->RegisterLastFocus( TREE_VIEW );
|
|
|
|
}
|
|
|
|
//=---------------------------------------------------------------------------------------
|
|
// wp is the node type to expand on
|
|
// this computer
|
|
// favorite item
|
|
// domain item
|
|
|
|
LRESULT CAdminTreeView::OnAdminGotoServer( WPARAM wp , LPARAM lp )
|
|
{
|
|
// todo use wp correctly
|
|
|
|
CServer *pServer = ( CServer * )lp;
|
|
|
|
if( pServer == NULL )
|
|
{
|
|
ODS( L"CAdminTreeView::OnAdminGotoServer invalid server arg\n" );
|
|
return 0 ;
|
|
}
|
|
|
|
LockTreeControl( );
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl( );
|
|
|
|
HTREEITEM hTreeItem = pServer->GetTreeItem( );
|
|
|
|
if( hTreeItem != NULL )
|
|
{
|
|
ODS( L"CAdminTreeView!OnAdminGotoServer - Server treeitem was found\n" );
|
|
|
|
tree.SelectItem(hTreeItem);
|
|
|
|
tree.Expand(hTreeItem, TVE_EXPAND);
|
|
}
|
|
|
|
UnlockTreeControl( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
//=---------------------------------------------------------------------------------------
|
|
// wp and lp not used
|
|
//
|
|
LRESULT CAdminTreeView::OnAdminDelFavServer( WPARAM wp , LPARAM lp )
|
|
{
|
|
// get the current treenode
|
|
// determine if its a fav folder or if its parent a fav folder
|
|
// if so get the server and kill it
|
|
LockTreeControl( );
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl( );
|
|
|
|
HTREEITEM hTreeItem = tree.GetSelectedItem();
|
|
|
|
do
|
|
{
|
|
if( hTreeItem == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
HTREEITEM hTreeRoot = tree.GetRootItem( );
|
|
|
|
if( hTreeRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// get fav folder
|
|
|
|
HTREEITEM hTreeFavRoot = tree.GetNextItem( hTreeRoot , TVGN_NEXT );
|
|
|
|
if( hTreeFavRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
if( hTreeFavRoot == hTreeItem )
|
|
{
|
|
// not a cool thing here ignore
|
|
break;
|
|
}
|
|
|
|
hTreeRoot = tree.GetNextItem( hTreeItem , TVGN_PARENT );
|
|
|
|
if( hTreeFavRoot == hTreeRoot )
|
|
{
|
|
// yes we're talking about a fav node that the user wants to delete
|
|
|
|
CTreeNode *pNode = ( CTreeNode* )tree.GetItemData( hTreeItem );
|
|
|
|
if( pNode != NULL && pNode->GetNodeType() == NODE_SERVER )
|
|
{
|
|
CServer *pServer = ( CServer* )pNode->GetTreeObject();
|
|
|
|
// sanity check
|
|
if( pServer != NULL && pServer->GetTreeItemFromFav() == hTreeItem )
|
|
{
|
|
OnAdminRemoveServerFromFavs( 0 , ( LPARAM )pServer );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}while( 0 );
|
|
|
|
UnlockTreeControl( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
LRESULT CAdminTreeView::OnGetTVStates( WPARAM , LPARAM )
|
|
{
|
|
ODS( L"CAdminTreeView::OnGetTVStates\n" );
|
|
|
|
DWORD dwStates = 0;
|
|
|
|
// find out the tri-states
|
|
HTREEITEM hRoot;
|
|
|
|
LockTreeControl( );
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl( );
|
|
|
|
|
|
hRoot = tree.GetRootItem( ); // this computer
|
|
|
|
if( hRoot != NULL )
|
|
{
|
|
if( tree.GetItemState( hRoot , TVIS_EXPANDED ) & TVIS_EXPANDED )
|
|
{
|
|
dwStates = TV_THISCOMP;
|
|
}
|
|
|
|
hRoot = tree.GetNextItem( hRoot , TVGN_NEXT ); // favorites
|
|
|
|
if( hRoot != NULL && tree.GetItemState( hRoot , TVIS_EXPANDED ) & TVIS_EXPANDED )
|
|
{
|
|
dwStates |= TV_FAVS;
|
|
}
|
|
|
|
hRoot = tree.GetNextItem( hRoot , TVGN_NEXT ); // all servers
|
|
|
|
if( hRoot != NULL && tree.GetItemState( hRoot , TVIS_EXPANDED ) & TVIS_EXPANDED )
|
|
{
|
|
dwStates |= TV_ALLSERVERS;
|
|
}
|
|
}
|
|
|
|
UnlockTreeControl( );
|
|
|
|
return ( LRESULT )dwStates;
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
LRESULT CAdminTreeView::OnUpdateTVState( WPARAM , LPARAM )
|
|
{
|
|
LRESULT lResult = 0xc0;
|
|
HTREEITEM hThisComputerRootItem = GetTreeCtrl().GetRootItem( );
|
|
HTREEITEM hFavRoot = GetTreeCtrl().GetNextItem( hThisComputerRootItem , TVGN_NEXT );
|
|
HTREEITEM hRoot = GetTreeCtrl().GetNextItem( hFavRoot , TVGN_NEXT );
|
|
// We want to default to having the current server being the
|
|
// currently selected item in the tree and be expanded
|
|
|
|
if( hThisComputerRootItem != NULL && ( g_dwTreeViewExpandedStates & TV_THISCOMP ) )
|
|
{
|
|
HTREEITEM hThisComputer = GetTreeCtrl().GetNextItem( hThisComputerRootItem , TVGN_CHILD );
|
|
|
|
if( hThisComputer != NULL )
|
|
{
|
|
GetTreeCtrl().SelectItem(hThisComputer);
|
|
GetTreeCtrl().Expand(hThisComputer, TVE_EXPAND);
|
|
// GetTreeCtrl().Expand(hDomain, TVE_EXPAND);
|
|
//lResult = 0xc0;
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
}
|
|
|
|
if( hFavRoot != NULL && ( g_dwTreeViewExpandedStates & TV_FAVS ) )
|
|
{
|
|
GetTreeCtrl().SelectItem( hFavRoot );
|
|
GetTreeCtrl().Expand( hFavRoot , TVE_EXPAND );
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
|
|
if( hRoot != NULL && ( g_dwTreeViewExpandedStates & TV_ALLSERVERS ) )
|
|
{
|
|
GetTreeCtrl().SelectItem( hRoot );
|
|
GetTreeCtrl().Expand( hRoot , TVE_EXPAND );
|
|
OnSelChange( NULL , &lResult );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
void CAdminTreeView::OnBeginDrag( NMHDR *pNMHDR , LRESULT *pResult )
|
|
{
|
|
ODS( L"CAdminTreeView::OnBeginDrag\n" );
|
|
|
|
RECT rc;
|
|
|
|
NMTREEVIEW *pTV = ( NMTREEVIEW * )pNMHDR;
|
|
|
|
if( pTV != NULL )
|
|
{
|
|
|
|
if( m_pimgDragList != NULL )
|
|
{
|
|
// this should never happen
|
|
ODS( L"There is a possible leak CAdminTreeView!OnBeginDrag\n" );
|
|
|
|
delete m_pimgDragList;
|
|
|
|
m_pimgDragList = NULL;
|
|
}
|
|
|
|
if( pTV->itemNew.hItem != NULL )
|
|
{
|
|
m_pimgDragList = GetTreeCtrl().CreateDragImage( pTV->itemNew.hItem );
|
|
}
|
|
|
|
if( m_pimgDragList != NULL )
|
|
{
|
|
GetTreeCtrl().GetItemRect( pTV->itemNew.hItem , &rc , FALSE );
|
|
|
|
CPoint cp( pTV->ptDrag.x - rc.left , pTV->ptDrag.y - rc.top );
|
|
|
|
/*
|
|
HCURSOR hCursor = ::LoadCursor( NULL, IDC_CROSS );
|
|
|
|
ICONINFO iconinfo;
|
|
|
|
::GetIconInfo( ( HICON )hCursor , &iconinfo );
|
|
*/
|
|
|
|
|
|
m_pimgDragList->BeginDrag( 0 , CPoint( 0 , 0 ) );
|
|
|
|
/*
|
|
cp.x -= iconinfo.xHotspot;
|
|
cp.y -= iconinfo.yHotspot;
|
|
|
|
m_pimgDragList->SetDragCursorImage( 0 , cp );
|
|
*/
|
|
|
|
m_pimgDragList->DragEnter( &GetTreeCtrl( ) , cp );
|
|
|
|
SetCapture();
|
|
|
|
// this is for us to check when we're not in the client area
|
|
m_nTimer = SetTimer( 1 , 50 , NULL );
|
|
|
|
//ShowCursor( FALSE );
|
|
|
|
m_hDragItem = pTV->itemNew.hItem;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
void CAdminTreeView::OnTimer( UINT nIDEvent )
|
|
{
|
|
UINT uflags;
|
|
|
|
POINT pt;
|
|
|
|
CTreeCtrl &cTree = GetTreeCtrl( );
|
|
|
|
GetCursorPos(&pt);
|
|
|
|
cTree.ScreenToClient( &pt );
|
|
|
|
if( m_nTimer == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
HTREEITEM hItem;
|
|
|
|
HTREEITEM hTreeItem = cTree.HitTest( CPoint( pt.x , pt.y ) , &uflags );
|
|
|
|
if( uflags & TVHT_ABOVE )
|
|
{
|
|
ODS( L"scrolling up...\n" );
|
|
|
|
hItem = cTree.GetFirstVisibleItem( );
|
|
|
|
hItem = cTree.GetNextItem( hItem , TVGN_PREVIOUSVISIBLE );
|
|
|
|
if( hItem != NULL )
|
|
{
|
|
cTree.Invalidate( );
|
|
|
|
cTree.EnsureVisible( hItem );
|
|
}
|
|
|
|
}
|
|
else if( uflags & TVHT_BELOW )
|
|
{
|
|
ODS( L"scrolling down...\n" );
|
|
|
|
hItem = cTree.GetFirstVisibleItem( );
|
|
|
|
hItem = cTree.GetNextItem( hItem , TVGN_NEXT );
|
|
|
|
if( hItem != NULL )
|
|
{
|
|
cTree.EnsureVisible( hItem );
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
void CAdminTreeView::OnLButtonUp( UINT uFlags , CPoint cp )
|
|
{
|
|
ODS( L"CAdminTreeView::OnLButtonUp\n" );
|
|
|
|
if( m_hDragItem != NULL && m_pimgDragList != NULL )
|
|
{
|
|
m_pimgDragList->DragLeave( &GetTreeCtrl( ) );
|
|
|
|
m_pimgDragList->EndDrag( );
|
|
|
|
m_pimgDragList->DeleteImageList( );
|
|
|
|
delete m_pimgDragList;
|
|
|
|
m_pimgDragList = NULL;
|
|
|
|
KillTimer( m_nTimer );
|
|
|
|
m_nTimer = 0;
|
|
|
|
ReleaseCapture( );
|
|
|
|
Invalidate( );
|
|
|
|
// ShowCursor( TRUE );
|
|
}
|
|
}
|
|
|
|
|
|
//=-------------------------------------------------------------
|
|
void CAdminTreeView::OnMouseMove( UINT uFlags , CPoint cp )
|
|
{
|
|
if( m_pimgDragList != NULL )
|
|
{
|
|
UINT uflags;
|
|
|
|
HTREEITEM hTreeItem = GetTreeCtrl( ).HitTest( cp , &uflags );
|
|
|
|
if( hTreeItem != GetTreeCtrl( ).GetDropHilightItem( ) )
|
|
{
|
|
ODS( L"CAdminTreeView::OnMouseMove NOT!!\n");
|
|
m_pimgDragList->DragLeave( &GetTreeCtrl( ) );
|
|
|
|
GetTreeCtrl( ).SelectDropTarget( NULL );
|
|
GetTreeCtrl( ).SelectDropTarget( hTreeItem );
|
|
|
|
m_pimgDragList->DragEnter( &GetTreeCtrl( ) , cp );
|
|
}
|
|
else
|
|
{
|
|
m_pimgDragList->DragMove( cp );
|
|
}
|
|
}
|
|
}
|
|
|
|
//=-------------------------------------------------------------
|
|
LRESULT CAdminTreeView::OnEmptyFavorites( WPARAM wp, LPARAM )
|
|
{
|
|
ODS( L"CAdminTreeView!OnEmptyFavorites\n" );
|
|
|
|
// check to see if there are any items in the view
|
|
|
|
LockTreeControl( );
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl( );
|
|
|
|
int nRet;
|
|
|
|
HTREEITEM hTreeRoot = tree.GetRootItem( );
|
|
|
|
do
|
|
{
|
|
if( hTreeRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// get fav folder
|
|
|
|
HTREEITEM hTreeFavRoot = tree.GetNextItem( hTreeRoot , TVGN_NEXT );
|
|
|
|
if( hTreeFavRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
HTREEITEM hItem = tree.GetNextItem( hTreeFavRoot , TVGN_CHILD );
|
|
|
|
if( hItem == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// warn the user about losing the entire favorite list
|
|
|
|
CString cstrMsg;
|
|
CString cstrTitle;
|
|
|
|
cstrMsg.LoadString( IDS_EMPTYFOLDER );
|
|
cstrTitle.LoadString( AFX_IDS_APP_TITLE );
|
|
|
|
|
|
|
|
#ifdef _STRESS_BUILD
|
|
if( ( BOOL )wp != TRUE )
|
|
{
|
|
#endif
|
|
|
|
|
|
nRet = MessageBox( cstrMsg ,
|
|
cstrTitle ,
|
|
MB_YESNO | MB_ICONINFORMATION );
|
|
|
|
#ifdef _STRESS_BUILD
|
|
}
|
|
else
|
|
{
|
|
nRet = IDYES;
|
|
}
|
|
#endif
|
|
|
|
|
|
if( nRet == IDYES )
|
|
{
|
|
// loop through every item and remove the item
|
|
HTREEITEM hNextItem = hItem;
|
|
|
|
while( hItem != NULL )
|
|
{
|
|
CTreeNode *pNode = (CTreeNode*)tree.GetItemData(hItem);
|
|
|
|
hNextItem = tree.GetNextItem( hItem , TVGN_NEXT );
|
|
|
|
if( pNode != NULL )
|
|
{
|
|
// Is it the same item as is selected
|
|
if( pNode->GetNodeType() == NODE_SERVER )
|
|
{
|
|
CServer *pServer = (CServer*)pNode->GetTreeObject();
|
|
|
|
// skip this server if its being disconnected
|
|
|
|
if( !pServer->IsState( SS_DISCONNECTING ) )
|
|
{
|
|
SendMessage( WM_ADMIN_REMOVESERVERFROMFAV , 0 , ( LPARAM )pServer );
|
|
}
|
|
}
|
|
}
|
|
|
|
hItem = hNextItem;
|
|
}
|
|
}
|
|
|
|
}while( 0 );
|
|
|
|
UnlockTreeControl( );
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
//=----------------------------------------------------------------
|
|
LRESULT CAdminTreeView::OnIsFavListEmpty( WPARAM wp , LPARAM lp )
|
|
{
|
|
LockTreeControl( );
|
|
|
|
CTreeCtrl &tree = GetTreeCtrl( );
|
|
|
|
HTREEITEM hTreeRoot = tree.GetRootItem( );
|
|
|
|
BOOL bEmpty = TRUE;
|
|
|
|
do
|
|
{
|
|
if( hTreeRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// get fav folder
|
|
|
|
HTREEITEM hTreeFavRoot = tree.GetNextItem( hTreeRoot , TVGN_NEXT );
|
|
|
|
if( hTreeFavRoot == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
HTREEITEM hItem = tree.GetNextItem( hTreeFavRoot , TVGN_CHILD );
|
|
|
|
if( hItem == NULL )
|
|
{
|
|
break;
|
|
}
|
|
|
|
bEmpty = FALSE;
|
|
|
|
} while( 0 );
|
|
|
|
UnlockTreeControl( );
|
|
|
|
return ( LRESULT )bEmpty;
|
|
}
|
|
|
|
|