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.
2747 lines
74 KiB
2747 lines
74 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// TaskMan - NT TaskManager
|
|
// Copyright (C) Microsoft
|
|
//
|
|
// File: userpage.cpp
|
|
//
|
|
// History: 07-July-1999 BradG Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#include "precomp.h"
|
|
#include "userdlgs.h"
|
|
|
|
#define IsActiveConsoleSession() (USER_SHARED_DATA->ActiveConsoleId == NtCurrentPeb()->SessionId)
|
|
|
|
CUserColSelectDlg ColSelectDlg;
|
|
|
|
|
|
//
|
|
// The following arrays map WTS sessions state codes into strings
|
|
//
|
|
|
|
#define MAX_STAT_STRINGS 4
|
|
#define FIRST_STAT_STRING IDS_STAT_ACTIVE
|
|
|
|
LPTSTR g_pszStatString[MAX_STAT_STRINGS];
|
|
const int g_aWTSStateToString[] = {
|
|
(IDS_STAT_ACTIVE - FIRST_STAT_STRING), // WTSActive
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // WTSConnected
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // WTSConnectQuery
|
|
(IDS_STAT_SHADOW - FIRST_STAT_STRING), // WTSShadow
|
|
(IDS_STAT_DISCONNECT - FIRST_STAT_STRING), // WTSDisconnected
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // Waiting for client to connect
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // WinStation is listening for connection
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // WinStation is being reset
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING), // WinStation is down due to error
|
|
(IDS_STAT_UNKNOWN - FIRST_STAT_STRING) // WinStation in initialization
|
|
};
|
|
|
|
/*++ class CUserInfo
|
|
|
|
Class Description:
|
|
|
|
Represents the last known information about a running task
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
Mar-23-00 a-skuzin Revised
|
|
|
|
--*/
|
|
|
|
class CUserInfo
|
|
{
|
|
public:
|
|
|
|
DWORD m_dwSessionId;
|
|
BOOL m_fShowDomainName;
|
|
WCHAR m_szUserName[USERNAME_LENGTH + 1];
|
|
WCHAR m_szDomainName[DOMAIN_LENGTH + 1];
|
|
WCHAR m_szClientName[CLIENTNAME_LENGTH + 1 ];
|
|
LPTSTR m_pszWinStaName;
|
|
|
|
WTS_CONNECTSTATE_CLASS m_wtsState;
|
|
LARGE_INTEGER m_uPassCount;
|
|
|
|
//
|
|
// This is a union of which attribute is dirty. You can look at
|
|
// or set any particular column's bit, or just inspect m_fDirty
|
|
// to see if anyone at all is dirty. Used to optimize listview
|
|
// painting
|
|
//
|
|
|
|
#pragma warning(disable:4201) // Nameless struct or union
|
|
union
|
|
{
|
|
DWORD m_fDirty;
|
|
struct
|
|
{
|
|
DWORD m_fDirty_COL_USERNAME :1;
|
|
DWORD m_fDirty_COL_USERSESSIONID :1;
|
|
DWORD m_fDirty_COL_SESSIONSTATUS :1;
|
|
DWORD m_fDirty_COL_CLIENTNAME :1;
|
|
DWORD m_fDirty_COL_WINSTANAME :1;
|
|
};
|
|
};
|
|
#pragma warning(default:4201) // Nameless struct or union
|
|
|
|
HRESULT SetData(
|
|
LPTSTR lpszClientName,
|
|
LPTSTR lpszWinStaName,
|
|
WTS_CONNECTSTATE_CLASS wtsState,
|
|
BOOL fShowDomainName,
|
|
LARGE_INTEGER uPassCount,
|
|
BOOL fUpdateOnly);
|
|
|
|
CUserInfo()
|
|
{
|
|
ZeroMemory(this, sizeof(*this));
|
|
}
|
|
|
|
~CUserInfo()
|
|
{
|
|
if (m_pszWinStaName)
|
|
{
|
|
LocalFree(m_pszWinStaName);
|
|
m_pszWinStaName = NULL;
|
|
}
|
|
}
|
|
|
|
INT Compare(CUserInfo * pOther);
|
|
private:
|
|
//
|
|
// Column ID on which to sort in the listview, and for
|
|
// compares in general
|
|
//
|
|
static USERCOLUMNID m_iUserSortColumnID;
|
|
static INT m_iUserSortDirection; // 1 = asc, -1 = desc
|
|
public:
|
|
static void SetUserSortColumnID(USERCOLUMNID id)
|
|
{
|
|
m_iUserSortColumnID = id;
|
|
m_iUserSortDirection = 1;
|
|
}
|
|
|
|
static USERCOLUMNID GetUserSortColumnID()
|
|
{
|
|
return m_iUserSortColumnID;
|
|
}
|
|
|
|
static void SwitchUserSortDirection()
|
|
{
|
|
m_iUserSortDirection *= -1;
|
|
}
|
|
};
|
|
|
|
USERCOLUMNID CUserInfo::m_iUserSortColumnID = USR_COL_USERSNAME;
|
|
INT CUserInfo::m_iUserSortDirection = 1; // 1 = asc, -1 = desc
|
|
|
|
void Shadow(HWND, CUserInfo * );
|
|
|
|
/*++ class CUserInfo::Compare
|
|
|
|
Class Description:
|
|
|
|
Compares this CUserInfo object to another, and returns its ranking
|
|
based on the g_iUserSortColumnID field.
|
|
|
|
Arguments:
|
|
|
|
pOther - the CUserInfo object to compare this to
|
|
|
|
Return Value:
|
|
|
|
< 0 - This CUserInfo is "less" than the other
|
|
0 - Equal (Can't happen, since HWND is secondary sort)
|
|
> 0 - This CUserInfo is "greater" than the other
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
INT CUserInfo::Compare(CUserInfo * pOther)
|
|
{
|
|
INT iRet;
|
|
|
|
switch (m_iUserSortColumnID)
|
|
{
|
|
case USR_COL_USERSNAME:
|
|
if (g_Options.m_fShowDomainNames)
|
|
{
|
|
iRet = lstrcmpi(this->m_szDomainName, pOther->m_szDomainName);
|
|
if (iRet != 0)
|
|
break;
|
|
}
|
|
iRet = lstrcmpi(this->m_szUserName, pOther->m_szUserName);
|
|
break;
|
|
|
|
case USR_COL_USERSESSION_ID:
|
|
iRet = Compare64(this->m_dwSessionId, pOther->m_dwSessionId);
|
|
break;
|
|
|
|
case USR_COL_SESSION_STATUS:
|
|
Assert(g_pszStatString[g_aWTSStateToString[this->m_wtsState]]);
|
|
Assert(g_pszStatString[g_aWTSStateToString[pOther->m_wtsState]]);
|
|
|
|
iRet = lstrcmpi(
|
|
g_pszStatString[g_aWTSStateToString[this->m_wtsState]],
|
|
g_pszStatString[g_aWTSStateToString[pOther->m_wtsState]]
|
|
);
|
|
break;
|
|
|
|
case USR_COL_WINSTA_NAME:
|
|
iRet = lstrcmpi(
|
|
(this->m_pszWinStaName) ? this->m_pszWinStaName : TEXT(""),
|
|
(pOther->m_pszWinStaName) ? pOther->m_pszWinStaName : TEXT("")
|
|
);
|
|
break;
|
|
|
|
case USR_COL_CLIENT_NAME:
|
|
iRet = lstrcmpi(
|
|
(this->m_wtsState != WTSDisconnected) ? this->m_szClientName : TEXT(""),
|
|
(pOther->m_wtsState != WTSDisconnected) ? pOther->m_szClientName : TEXT("")
|
|
);
|
|
break;
|
|
|
|
default:
|
|
Assert(0 && "Invalid task sort column");
|
|
iRet = 0;
|
|
break;
|
|
}
|
|
|
|
return (iRet * m_iUserSortDirection);
|
|
}
|
|
|
|
/*++ InsertIntoSortedArray
|
|
|
|
Class Description:
|
|
|
|
Sticks a CUserInfo ptr into the ptrarray supplied at the
|
|
appropriate location based on the current sort column (which
|
|
is used by the Compare member function)
|
|
|
|
Arguments:
|
|
|
|
pArray - The CPtrArray to add to
|
|
pProc - The CUserInfo object to add to the array
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE if fails
|
|
|
|
Revision History:
|
|
|
|
Nov-20-95 BradG Created
|
|
|
|
--*/
|
|
|
|
BOOL InsertIntoSortedArray(CPtrArray * pArray, CUserInfo * pUser)
|
|
{
|
|
INT cItems = pArray->GetSize();
|
|
|
|
for (INT iIndex = 0; iIndex < cItems; iIndex++)
|
|
{
|
|
CUserInfo * pTmp = (CUserInfo *) pArray->GetAt(iIndex);
|
|
|
|
if (pUser->Compare(pTmp) < 0)
|
|
{
|
|
return pArray->InsertAt(iIndex, pUser);
|
|
}
|
|
}
|
|
|
|
return pArray->Add(pUser);
|
|
}
|
|
|
|
/*++ ResortUserArray
|
|
|
|
Function Description:
|
|
|
|
Creates a new ptr array sorted in the current sort order based
|
|
on the old array, and then replaces the old with the new
|
|
|
|
Arguments:
|
|
|
|
ppArray - The CPtrArray to resort
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE if fails
|
|
|
|
Revision History:
|
|
|
|
Nov-21-95 BradG Created
|
|
|
|
--*/
|
|
|
|
BOOL ResortUserArray(CPtrArray ** ppArray)
|
|
{
|
|
// Create a new array which will be sorted in the new
|
|
// order and used to replace the existing array
|
|
|
|
CPtrArray * pNew = new CPtrArray(GetProcessHeap());
|
|
if (NULL == pNew)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Insert each of the existing items in the old array into
|
|
// the new array in the correct spot
|
|
|
|
INT cItems = (*ppArray)->GetSize();
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
CUserInfo * pItem = (CUserInfo *) (*ppArray)->GetAt(i);
|
|
if (FALSE == InsertIntoSortedArray(pNew, pItem))
|
|
{
|
|
delete pNew;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Kill off the old array, replace it with the new
|
|
|
|
delete (*ppArray);
|
|
(*ppArray) = pNew;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
//*****************************************************************************
|
|
//class CUserPage
|
|
//*****************************************************************************
|
|
|
|
//
|
|
//
|
|
//
|
|
CUserPage::~CUserPage()
|
|
{
|
|
RemoveAllUsers();
|
|
delete m_pUserArray;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
void CUserPage::RemoveAllUsers()
|
|
{
|
|
if (m_pUserArray)
|
|
{
|
|
INT c = m_pUserArray->GetSize();
|
|
|
|
while (c)
|
|
{
|
|
delete (CUserInfo *) (m_pUserArray->GetAt(c - 1));
|
|
c--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*++ CUserPage::UpdateUserListview
|
|
|
|
Class Description:
|
|
|
|
Walks the listview and checks to see if each line in the
|
|
listview matches the corresponding entry in our process
|
|
array. Those which differe by HWND are replaced, and those
|
|
that need updating are updated.
|
|
|
|
Items are also added and removed to/from the tail of the
|
|
listview as required.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
HRESULT
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserPage::UpdateUserListview()
|
|
{
|
|
HWND hListView = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
|
|
//
|
|
// Stop repaints while we party on the listview
|
|
//
|
|
|
|
SendMessage(hListView, WM_SETREDRAW, FALSE, 0);
|
|
|
|
INT cListViewItems = ListView_GetItemCount(hListView);
|
|
INT CUserArrayItems = m_pUserArray->GetSize();
|
|
|
|
//
|
|
// Walk the existing lines in the listview and replace/update
|
|
// them as needed
|
|
//
|
|
for (INT iCurrent = 0;
|
|
iCurrent < cListViewItems && iCurrent < CUserArrayItems;
|
|
iCurrent++)
|
|
{
|
|
LV_ITEM lvitem = { 0 };
|
|
WCHAR szDisplayName[ USERNAME_LENGTH + 1 + DOMAIN_LENGTH + 1 ];
|
|
|
|
lvitem.mask = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
|
|
lvitem.iItem = iCurrent;
|
|
|
|
if (FALSE == ListView_GetItem(hListView, &lvitem))
|
|
{
|
|
SendMessage(hListView, WM_SETREDRAW, TRUE, 0);
|
|
return E_FAIL;
|
|
}
|
|
|
|
CUserInfo * pTmp = (CUserInfo *) lvitem.lParam;
|
|
CUserInfo * pUser = (CUserInfo *) m_pUserArray->GetAt(iCurrent);
|
|
|
|
if (pTmp != pUser || pUser->m_fDirty)
|
|
{
|
|
// If the objects aren't the same, we need to replace this line
|
|
|
|
if (g_Options.m_fShowDomainNames)
|
|
{
|
|
// UI only - don't care if it gets truncated.
|
|
StringCchCopy( szDisplayName, ARRAYSIZE(szDisplayName), pUser->m_szDomainName );
|
|
StringCchCat( szDisplayName, ARRAYSIZE(szDisplayName), L"\\" );
|
|
}
|
|
else
|
|
{
|
|
szDisplayName[ 0 ] = L'\0';
|
|
}
|
|
|
|
// UI only - don't care if it gets truncated.
|
|
StringCchCat( szDisplayName, ARRAYSIZE(szDisplayName), pUser->m_szUserName );
|
|
|
|
lvitem.pszText = szDisplayName;
|
|
lvitem.lParam = (LPARAM) pUser;
|
|
|
|
if (g_dwMySessionId == pUser->m_dwSessionId)
|
|
{
|
|
lvitem.iImage = m_iCurrentUserIcon;
|
|
}
|
|
else
|
|
{
|
|
lvitem.iImage = m_iUserIcon;
|
|
}
|
|
|
|
ListView_SetItem(hListView, &lvitem);
|
|
ListView_RedrawItems(hListView, iCurrent, iCurrent);
|
|
pUser->m_fDirty = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We've either run out of listview items or run out of User array
|
|
// entries, so remove/add to the listview as appropriate
|
|
//
|
|
|
|
while (iCurrent < cListViewItems)
|
|
{
|
|
// Extra items in the listview (processes gone away), so remove them
|
|
|
|
ListView_DeleteItem(hListView, iCurrent);
|
|
cListViewItems--;
|
|
}
|
|
|
|
while (iCurrent < CUserArrayItems)
|
|
{
|
|
// Need to add new items to the listview (new user appeared)
|
|
|
|
CUserInfo * pUser = (CUserInfo *)m_pUserArray->GetAt(iCurrent);
|
|
LV_ITEM lvitem = { 0 };
|
|
WCHAR szDisplayName[ USERNAME_LENGTH + 1 + DOMAIN_LENGTH + 1 ];
|
|
|
|
lvitem.mask = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
|
|
lvitem.iItem = iCurrent;
|
|
lvitem.lParam = (LPARAM) pUser;
|
|
|
|
if (g_Options.m_fShowDomainNames)
|
|
{
|
|
// UI only - don't care if it gets truncated.
|
|
StringCchCopy( szDisplayName, ARRAYSIZE(szDisplayName), pUser->m_szDomainName );
|
|
StringCchCat( szDisplayName, ARRAYSIZE(szDisplayName), L"\\" );
|
|
}
|
|
else
|
|
{
|
|
szDisplayName[0] = L'\0';
|
|
}
|
|
|
|
// UI only - don't care if it gets truncated.
|
|
StringCchCat( szDisplayName, ARRAYSIZE(szDisplayName), pUser->m_szUserName );
|
|
|
|
lvitem.pszText = szDisplayName;
|
|
|
|
if (g_dwMySessionId == pUser->m_dwSessionId)
|
|
{
|
|
lvitem.iImage = m_iCurrentUserIcon;
|
|
}
|
|
else
|
|
{
|
|
lvitem.iImage = m_iUserIcon;
|
|
}
|
|
|
|
// The first item added (actually, every 0 to 1 count transition) gets
|
|
// selected and focused
|
|
|
|
if (iCurrent == 0)
|
|
{
|
|
lvitem.state = LVIS_SELECTED | LVIS_FOCUSED;
|
|
lvitem.stateMask = lvitem.state;
|
|
lvitem.mask |= LVIF_STATE;
|
|
}
|
|
|
|
ListView_InsertItem(hListView, &lvitem);
|
|
pUser->m_fDirty = 0;
|
|
iCurrent++;
|
|
}
|
|
|
|
//
|
|
// Let the listview paint again
|
|
//
|
|
|
|
SendMessage(hListView, WM_SETREDRAW, TRUE, 0);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*++ CUserPage::GetSelectedUsers
|
|
|
|
Routine Description:
|
|
|
|
Returns a CPtrArray of the selected tasks
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
CPtrArray on success, NULL on failure
|
|
|
|
Revision History:
|
|
|
|
Dec-01-95 BradG Created
|
|
|
|
--*/
|
|
|
|
CPtrArray * CUserPage::GetSelectedUsers()
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
//
|
|
// Get the count of selected items
|
|
//
|
|
|
|
HWND hUserList = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
INT cItems = ListView_GetSelectedCount(hUserList);
|
|
if (0 == cItems)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Create a CPtrArray to hold the task items
|
|
//
|
|
|
|
CPtrArray * pArray = new CPtrArray(GetProcessHeap());
|
|
if (NULL == pArray)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
INT iLast = -1;
|
|
for (INT i = 0; i < cItems; i++)
|
|
{
|
|
//
|
|
// Get the Nth selected item
|
|
//
|
|
|
|
INT iItem = ListView_GetNextItem(hUserList, iLast, LVNI_SELECTED);
|
|
|
|
if (-1 == iItem)
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
|
|
iLast = iItem;
|
|
|
|
//
|
|
// Pull the item from the listview and add it to the selected array
|
|
//
|
|
|
|
LV_ITEM lvitem = { LVIF_PARAM };
|
|
lvitem.iItem = iItem;
|
|
|
|
if (ListView_GetItem(hUserList, &lvitem))
|
|
{
|
|
LPVOID pUser = (LPVOID) (lvitem.lParam);
|
|
if (FALSE == pArray->Add(pUser))
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Any errors, clean up the array and bail. We don't release the
|
|
// tasks in the array, since they are owned by the listview.
|
|
//
|
|
|
|
if (FALSE == fSuccess && NULL != pArray)
|
|
{
|
|
delete pArray;
|
|
return NULL;
|
|
}
|
|
|
|
return pArray;
|
|
}
|
|
|
|
|
|
/*++ CProcPage::HandleUserListContextMenu
|
|
|
|
Routine Description:
|
|
|
|
Handles right-clicks (context menu) in the task list
|
|
|
|
Arguments:
|
|
|
|
xPos, yPos - coords of where the click occurred
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Dec-01-95 BradG Created
|
|
|
|
--*/
|
|
|
|
void CUserPage::HandleUserListContextMenu(INT xPos, INT yPos)
|
|
{
|
|
HWND hUserList = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
|
|
CPtrArray * pArray = GetSelectedUsers();
|
|
|
|
if (pArray)
|
|
{
|
|
// If non-mouse-based context menu, use the currently selected
|
|
// item as the coords
|
|
|
|
if (0xFFFF == LOWORD(xPos) && 0xFFFF == LOWORD(yPos))
|
|
{
|
|
int iSel = ListView_GetNextItem(hUserList, -1, LVNI_SELECTED);
|
|
RECT rcItem;
|
|
ListView_GetItemRect(hUserList, iSel, &rcItem, LVIR_ICON);
|
|
MapWindowRect(hUserList, NULL, &rcItem);
|
|
xPos = rcItem.right;
|
|
yPos = rcItem.bottom;
|
|
}
|
|
|
|
HMENU hPopup = LoadPopupMenu(g_hInstance, IDR_USER_CONTEXT);
|
|
|
|
if (hPopup)
|
|
{
|
|
SetMenuDefaultItem(hPopup, IDM_SENDMESSAGE, FALSE);
|
|
|
|
//
|
|
//If our current session is a console session,
|
|
//we cannot do remote control
|
|
//
|
|
if(IsActiveConsoleSession())
|
|
{
|
|
EnableMenuItem(hPopup, IDM_REMOTECONTROL, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
}
|
|
|
|
//
|
|
// If multiple-selection, disable the items that require single
|
|
// selections to make sense
|
|
//
|
|
|
|
if (pArray->GetSize() > 1)
|
|
{
|
|
EnableMenuItem(hPopup, IDM_REMOTECONTROL, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
EnableMenuItem(hPopup, IDM_CONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
}
|
|
|
|
//
|
|
// See if we have our own session selected
|
|
//
|
|
for (int i = 0; i < pArray->GetSize(); i++)
|
|
{
|
|
CUserInfo * pUser = (CUserInfo *) pArray->GetAt(i);
|
|
if (g_dwMySessionId == pUser->m_dwSessionId)
|
|
{
|
|
//
|
|
// The current session is in the list
|
|
//
|
|
EnableMenuItem(hPopup, IDM_REMOTECONTROL, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
EnableMenuItem(hPopup, IDM_CONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
|
|
if (SHRestricted(REST_NODISCONNECT))
|
|
{
|
|
EnableMenuItem(hPopup, IDM_DISCONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
}
|
|
|
|
if (pArray->GetSize() == 1)
|
|
{
|
|
//
|
|
// My session is the only one selected
|
|
//
|
|
EnableMenuItem(hPopup, IDM_SENDMESSAGE, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
}
|
|
}
|
|
|
|
if (pUser->m_wtsState == WTSDisconnected)
|
|
{
|
|
// EnableMenuItem(hPopup, IDM_REMOTECONTROL, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
EnableMenuItem(hPopup, IDM_DISCONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND);
|
|
}
|
|
|
|
}
|
|
|
|
Pause();
|
|
g_fInPopup = TRUE;
|
|
TrackPopupMenuEx(hPopup, 0, xPos, yPos, m_hPage, NULL);
|
|
g_fInPopup = FALSE;
|
|
|
|
// Note that we don't "unpause" until one of the menu commands (incl CANCEL) is
|
|
// selected or the menu is dismissed
|
|
|
|
DestroyMenu(hPopup);
|
|
}
|
|
|
|
delete pArray;
|
|
}
|
|
else
|
|
{
|
|
// Nothing is selected
|
|
}
|
|
}
|
|
|
|
|
|
/*++ CUserPage::UpdateUIState
|
|
|
|
Routine Description:
|
|
|
|
Updates the enabled/disabled states, etc., of the task UI
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Dec-04-95 BradG Created
|
|
|
|
--*/
|
|
|
|
// Controls which are enabled only for any selection
|
|
|
|
static const UINT g_aUserSingleIDs[] =
|
|
{
|
|
IDM_DISCONNECT,
|
|
IDM_LOGOFF,
|
|
IDM_SENDMESSAGE
|
|
};
|
|
|
|
void CUserPage::UpdateUIState()
|
|
{
|
|
INT i;
|
|
|
|
//
|
|
// Set the state for controls which require a selection (1 or more items)
|
|
//
|
|
|
|
for (i = 0; i < ARRAYSIZE(g_aUserSingleIDs); i++)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hPage, g_aUserSingleIDs[i]), m_cSelected > 0);
|
|
}
|
|
|
|
CPtrArray * pArray = GetSelectedUsers();
|
|
|
|
if (pArray)
|
|
{
|
|
//
|
|
// See if we have our own session selected
|
|
//
|
|
|
|
for (int i = 0; i < pArray->GetSize(); i++)
|
|
{
|
|
CUserInfo * pUser = (CUserInfo *) pArray->GetAt(i);
|
|
if (g_dwMySessionId == pUser->m_dwSessionId)
|
|
{
|
|
if (SHRestricted(REST_NODISCONNECT))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hPage, IDM_DISCONNECT), FALSE);
|
|
}
|
|
|
|
if (pArray->GetSize() == 1)
|
|
{
|
|
//
|
|
// My session is the only one selected
|
|
//
|
|
EnableWindow(GetDlgItem(m_hPage, IDM_SENDMESSAGE), FALSE);
|
|
}
|
|
}
|
|
|
|
if (pUser->m_wtsState == WTSDisconnected)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hPage, IDM_DISCONNECT), FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
delete pArray;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*++ CUserPage::HandleUserPageNotify
|
|
|
|
Routine Description:
|
|
|
|
Processes WM_NOTIFY messages received by the taskpage dialog
|
|
|
|
Arguments:
|
|
|
|
hWnd - Control that generated the WM_NOTIFY
|
|
pnmhdr - Ptr to the NMHDR notification stucture
|
|
|
|
Return Value:
|
|
|
|
BOOL "did we handle it" code
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
INT CUserPage::HandleUserPageNotify(LPNMHDR pnmhdr)
|
|
{
|
|
switch(pnmhdr->code)
|
|
{
|
|
case LVN_ITEMCHANGED:
|
|
{
|
|
//
|
|
// If the (selection) state of an item is changing, see if
|
|
// the count has changed, and if so, update the UI
|
|
//
|
|
|
|
const NM_LISTVIEW * pnmv = (const NM_LISTVIEW *) pnmhdr;
|
|
if (pnmv->uChanged & LVIF_STATE)
|
|
{
|
|
UINT cSelected = ListView_GetSelectedCount(GetDlgItem(m_hPage, IDC_USERLIST));
|
|
if (cSelected != m_cSelected)
|
|
{
|
|
m_cSelected = cSelected;
|
|
UpdateUIState();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LVN_COLUMNCLICK:
|
|
{
|
|
// User clicked a header control, so set the sort column. If its the
|
|
// same as the current sort column, just invert the sort direction in
|
|
// the column. Then resort the task array
|
|
|
|
const NM_LISTVIEW * pnmv = (const NM_LISTVIEW *) pnmhdr;
|
|
LV_COLUMN lvcolumn;
|
|
|
|
lvcolumn.mask = LVCF_SUBITEM;
|
|
|
|
if(!ListView_GetColumn(GetDlgItem(m_hPage, IDC_USERLIST), pnmv->iSubItem, &lvcolumn))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (CUserInfo::GetUserSortColumnID() == lvcolumn.iSubItem)
|
|
{
|
|
CUserInfo::SwitchUserSortDirection();
|
|
}
|
|
else
|
|
{
|
|
CUserInfo::SetUserSortColumnID((USERCOLUMNID)lvcolumn.iSubItem);
|
|
}
|
|
|
|
ResortUserArray(&m_pUserArray);
|
|
TimerEvent();
|
|
}
|
|
break;
|
|
|
|
case LVN_GETDISPINFO:
|
|
{
|
|
LV_ITEM * plvitem = &(((LV_DISPINFO *) pnmhdr)->item);
|
|
|
|
//
|
|
// Listview needs a text string
|
|
//
|
|
|
|
if (plvitem->mask & LVIF_TEXT)
|
|
{
|
|
LV_COLUMN lvcolumn;
|
|
lvcolumn.mask = LVCF_SUBITEM;
|
|
|
|
if(!ListView_GetColumn(GetDlgItem(m_hPage, IDC_USERLIST),
|
|
plvitem->iSubItem, &lvcolumn))
|
|
{
|
|
break;
|
|
}
|
|
|
|
USERCOLUMNID columnid = (USERCOLUMNID) lvcolumn.iSubItem;
|
|
const CUserInfo * pUserInfo = (const CUserInfo *) plvitem->lParam;
|
|
|
|
switch(columnid)
|
|
{
|
|
case USR_COL_USERSNAME:
|
|
plvitem->mask |= LVIF_DI_SETITEM;
|
|
|
|
if (g_Options.m_fShowDomainNames)
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy(plvitem->pszText, plvitem->cchTextMax, pUserInfo->m_szDomainName );
|
|
StringCchCat(plvitem->pszText, plvitem->cchTextMax, L"\\" );
|
|
StringCchCat(plvitem->pszText, plvitem->cchTextMax, pUserInfo->m_szUserName );
|
|
}
|
|
else
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy(plvitem->pszText, plvitem->cchTextMax, pUserInfo->m_szUserName );
|
|
}
|
|
break;
|
|
|
|
case USR_COL_USERSESSION_ID:
|
|
// UI only - don't care if it gets truncated
|
|
StringCchPrintf(plvitem->pszText, plvitem->cchTextMax, L"%d", (ULONG) (pUserInfo->m_dwSessionId));
|
|
break;
|
|
|
|
case USR_COL_SESSION_STATUS:
|
|
if ( NULL != g_pszStatString[ g_aWTSStateToString[ pUserInfo->m_wtsState ] ] )
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText
|
|
, plvitem->cchTextMax
|
|
, g_pszStatString[ g_aWTSStateToString[ pUserInfo->m_wtsState ] ]
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText, plvitem->cchTextMax, L"" );
|
|
}
|
|
break;
|
|
|
|
case USR_COL_CLIENT_NAME:
|
|
if ( pUserInfo->m_wtsState != WTSDisconnected )
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText, plvitem->cchTextMax, pUserInfo->m_szClientName );
|
|
}
|
|
else
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText, plvitem->cchTextMax, L"" );
|
|
}
|
|
break;
|
|
|
|
case USR_COL_WINSTA_NAME:
|
|
if ( NULL != pUserInfo->m_pszWinStaName )
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText, plvitem->cchTextMax, pUserInfo->m_pszWinStaName );
|
|
}
|
|
else
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( plvitem->pszText, plvitem->cchTextMax, L"" );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Assert( 0 && "Unknown listview subitem" );
|
|
break;
|
|
|
|
} // end switch(columnid)
|
|
|
|
} // end LVIF_TEXT case
|
|
|
|
} // end LVN_GETDISPINFO case
|
|
break;
|
|
|
|
} // end switch(pnmhdr->code)
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*++ CUserPage::TimerEvent
|
|
|
|
Routine Description:
|
|
|
|
Called by main app when the update time fires. Walks every window
|
|
in the system (on every desktop, in every windowstation) and adds
|
|
or updates it in the task array, then removes any stale processes,
|
|
and filters the results into the listview
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
VOID CUserPage::TimerEvent()
|
|
{
|
|
//
|
|
// If this page is paused (ie: it has a context menu up, etc), we do
|
|
// nothing
|
|
//
|
|
|
|
if (m_fPaused)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static LARGE_INTEGER uPassCount = {0, 0};
|
|
|
|
//
|
|
// TODO: BRADG
|
|
// This should be done on a separate thread
|
|
//
|
|
|
|
PWTS_SESSION_INFO pSession;
|
|
DWORD nSessions;
|
|
DWORD dwSize;
|
|
LPTSTR pszClientName;
|
|
LPTSTR pszUserName;
|
|
LPTSTR pszDomainName;
|
|
HRESULT hr;
|
|
BOOL b;
|
|
BOOL bDelete;
|
|
INT i;
|
|
DWORD j;
|
|
CUserInfo *pNewUser;
|
|
|
|
b = WTSEnumerateSessions(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
0,
|
|
1,
|
|
&pSession,
|
|
&nSessions);
|
|
if ( b )
|
|
{
|
|
i = 0;
|
|
while (i < m_pUserArray->GetSize())
|
|
{
|
|
CUserInfo * pUserInfo = (CUserInfo *)(m_pUserArray->GetAt(i));
|
|
ASSERT(pUserInfo);
|
|
|
|
//
|
|
// See if this item has a matching session. If so, update it.
|
|
//
|
|
|
|
bDelete = FALSE;
|
|
|
|
for (j = 0; j < nSessions; j++)
|
|
{
|
|
if (pUserInfo->m_dwSessionId == pSession[j].SessionId)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j < nSessions)
|
|
{
|
|
//
|
|
// This session is still alive. See what it's doing
|
|
//
|
|
|
|
switch( pSession[j].State )
|
|
{
|
|
case WTSActive:
|
|
case WTSDisconnected:
|
|
case WTSShadow:
|
|
//
|
|
//If we log off user from disconnected session 0
|
|
//it does not change its state but remains disconnected
|
|
//we must not display disconnected session 0 if nobody
|
|
//is logged on to it.
|
|
//
|
|
|
|
b = WTSQuerySessionInformation(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pSession[j].SessionId,
|
|
WTSUserName,
|
|
&pszUserName,
|
|
&dwSize
|
|
);
|
|
|
|
if (!b || pszUserName == NULL)
|
|
{
|
|
bDelete = TRUE;
|
|
pSession[j].State = WTSIdle; //see "MAJOR HACK" below
|
|
break;
|
|
}
|
|
|
|
//
|
|
//pszUserName[0] == 0 - means that nobody is logged on to session 0.
|
|
//It might also happen, though very unlikely, that session number got
|
|
//reused by some other user while taskmgr was busy doing something.
|
|
//In this case we'll treat this session as a new one
|
|
//
|
|
|
|
if(lstrcmp(pUserInfo->m_szUserName,pszUserName))
|
|
{
|
|
bDelete = TRUE;
|
|
if(pszUserName[0] == 0)
|
|
{
|
|
pSession[j].State = WTSIdle; //see "MAJOR HACK" below
|
|
}
|
|
}
|
|
|
|
WTSFreeMemory(pszUserName);
|
|
pszUserName = NULL;
|
|
|
|
if(bDelete)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// It's still doing something interesting, so go and
|
|
// update the item's status
|
|
//
|
|
|
|
pszClientName = NULL;
|
|
|
|
b = WTSQuerySessionInformation(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pSession[j].SessionId,
|
|
WTSClientName,
|
|
&pszClientName,
|
|
&dwSize
|
|
);
|
|
|
|
hr = pUserInfo->SetData(
|
|
(pszClientName == NULL) ? TEXT("") : pszClientName,
|
|
pSession[j].pWinStationName,
|
|
pSession[j].State,
|
|
g_Options.m_fShowDomainNames,
|
|
uPassCount,
|
|
TRUE
|
|
);
|
|
if (pszClientName)
|
|
{
|
|
// Free the ClientName buffer
|
|
WTSFreeMemory(pszClientName);
|
|
pszClientName = NULL;
|
|
}
|
|
|
|
//
|
|
// MAJOR HACK -- Set the State to WTSIdle so we skip it
|
|
// when we check for new sessions.
|
|
//
|
|
|
|
pSession[j].State = WTSIdle;
|
|
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// It's no longer in a state we care about, delete it.
|
|
//
|
|
bDelete = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The list item doesn't have any matching information, so this means
|
|
// that the user probably has logged off. Delete it.
|
|
//
|
|
|
|
bDelete = TRUE;
|
|
}
|
|
|
|
if (bDelete)
|
|
{
|
|
//
|
|
// This item needs to be deleted from the list.
|
|
//
|
|
|
|
delete pUserInfo;
|
|
m_pUserArray->RemoveAt(i, 1);
|
|
|
|
//
|
|
// Loop back without incrementing i.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
//
|
|
// Now that we updated all entries in the m_pUserArray, we need double
|
|
// check the session data to see if we have any new sessions. See the
|
|
// MAJOR HACK comment above. We change the state of all updated
|
|
// sessions to WTSIdle so we skip them in the loop below.
|
|
//
|
|
|
|
for (j = 0; j < nSessions; j++)
|
|
{
|
|
switch( pSession[j].State )
|
|
{
|
|
case WTSActive:
|
|
case WTSDisconnected:
|
|
case WTSShadow:
|
|
//
|
|
// OK, we've discovered a NEW session that's in a
|
|
// state that we care about. Add it to the list.
|
|
//
|
|
|
|
pNewUser = new CUserInfo;
|
|
if (pNewUser == NULL)
|
|
{
|
|
// Not much we can do here.
|
|
break;
|
|
}
|
|
|
|
pNewUser->m_dwSessionId = pSession[j].SessionId;
|
|
|
|
//
|
|
// TODO: BRADG
|
|
// See about writing this as a loop
|
|
//
|
|
|
|
//
|
|
// Query all the cool info about the session.
|
|
//
|
|
|
|
b = WTSQuerySessionInformation(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pSession[j].SessionId,
|
|
WTSClientName,
|
|
&pszClientName,
|
|
&dwSize
|
|
);
|
|
if (!b)
|
|
{
|
|
delete pNewUser;
|
|
break;
|
|
}
|
|
|
|
hr = pNewUser->SetData(
|
|
(pszClientName == NULL) ? TEXT("") : pszClientName,
|
|
pSession[j].pWinStationName,
|
|
pSession[j].State,
|
|
g_Options.m_fShowDomainNames,
|
|
uPassCount,
|
|
FALSE
|
|
);
|
|
if (pszClientName != NULL)
|
|
{
|
|
WTSFreeMemory(pszClientName);
|
|
pszClientName = NULL;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
delete pNewUser;
|
|
break;
|
|
}
|
|
|
|
|
|
b = WTSQuerySessionInformation(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pSession[j].SessionId,
|
|
WTSUserName,
|
|
&pszUserName,
|
|
&dwSize
|
|
);
|
|
if (!b || pszUserName == NULL)
|
|
{
|
|
delete pNewUser;
|
|
break;
|
|
}
|
|
|
|
//
|
|
//This is case of disconnected session 0
|
|
//when nobody is logged on.
|
|
//
|
|
if(pszUserName[0] == 0)
|
|
{
|
|
WTSFreeMemory(pszUserName);
|
|
pszUserName = NULL;
|
|
delete pNewUser;
|
|
break;
|
|
}
|
|
|
|
StringCchCopy( pNewUser->m_szUserName, ARRAYSIZE(pNewUser->m_szUserName), pszUserName );
|
|
WTSFreeMemory(pszUserName);
|
|
pszUserName = NULL;
|
|
|
|
b = WTSQuerySessionInformation(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pSession[j].SessionId,
|
|
WTSDomainName,
|
|
&pszDomainName,
|
|
&dwSize
|
|
);
|
|
if (!b || pszDomainName == NULL)
|
|
{
|
|
delete pNewUser;
|
|
break;
|
|
}
|
|
StringCchCopy( pNewUser->m_szDomainName, ARRAYSIZE(pNewUser->m_szDomainName), pszDomainName );
|
|
WTSFreeMemory(pszDomainName);
|
|
pszDomainName = NULL;
|
|
|
|
pNewUser->m_fDirty = 1;
|
|
|
|
// All went well, so add it to the array
|
|
|
|
if (!(m_pUserArray->Add( (LPVOID) pNewUser)))
|
|
{
|
|
delete pNewUser;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
// Don't care about this one.
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free up the memory allocated on the WTSEnumerateSessions call
|
|
//
|
|
|
|
WTSFreeMemory( pSession );
|
|
pSession = NULL;
|
|
}
|
|
|
|
UpdateUserListview();
|
|
|
|
uPassCount.QuadPart++;
|
|
}
|
|
|
|
|
|
/*++ class CUserInfo::SetData
|
|
|
|
Class Description:
|
|
|
|
Updates (or initializes) the info about a running task
|
|
|
|
Arguments:
|
|
|
|
uPassCount- Current passcount, used to timestamp the last update of
|
|
this object
|
|
fUpdate - only worry about information that can change during a
|
|
task's lifetime
|
|
|
|
Return Value:
|
|
|
|
HRESULT
|
|
|
|
Revision History:
|
|
|
|
Nov-16-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserInfo::SetData(
|
|
LPTSTR lpszClientName,
|
|
LPTSTR lpszWinStaName,
|
|
WTS_CONNECTSTATE_CLASS wtsState,
|
|
BOOL fShowDomainName,
|
|
LARGE_INTEGER uPassCount,
|
|
BOOL fUpdateOnly)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_uPassCount.QuadPart = uPassCount.QuadPart;
|
|
|
|
//
|
|
// For each of the fields, we check to see if anything has changed, and if
|
|
// so, we mark that particular column as having changed, and update the value.
|
|
// This allows me to opimize which fields of the listview to repaint, since
|
|
// repainting an entire listview column causes flicker and looks bad in
|
|
// general
|
|
//
|
|
|
|
//
|
|
// WinStation
|
|
//
|
|
|
|
if (!fUpdateOnly || lstrcmp(m_pszWinStaName, lpszWinStaName))
|
|
{
|
|
LPTSTR pszOld = m_pszWinStaName;
|
|
DWORD cchLen = lstrlen(lpszWinStaName) + 1;
|
|
|
|
m_pszWinStaName = (LPTSTR) LocalAlloc( 0, cchLen * sizeof(*m_pszWinStaName) );
|
|
if (NULL == m_pszWinStaName)
|
|
{
|
|
m_pszWinStaName = pszOld;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy( m_pszWinStaName, cchLen, lpszWinStaName );
|
|
m_fDirty_COL_WINSTANAME = TRUE;
|
|
if ( NULL != pszOld )
|
|
{
|
|
LocalFree(pszOld);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Client Name
|
|
//
|
|
|
|
if ( NULL != lpszClientName && lstrcmp(m_szClientName, lpszClientName) )
|
|
{
|
|
// UI only - don't care if it gets truncated
|
|
StringCchCopy(m_szClientName, ARRAYSIZE(m_szClientName), lpszClientName);
|
|
m_fDirty_COL_CLIENTNAME = TRUE;
|
|
}
|
|
|
|
//
|
|
// Session Status
|
|
//
|
|
|
|
if (wtsState != m_wtsState) {
|
|
m_wtsState = wtsState;
|
|
m_fDirty_COL_SESSIONSTATUS = TRUE;
|
|
}
|
|
|
|
//
|
|
// Domain Name Status
|
|
//
|
|
|
|
if (fShowDomainName != m_fShowDomainName)
|
|
{
|
|
m_fShowDomainName = fShowDomainName;
|
|
m_fDirty_COL_USERNAME = TRUE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*++ CUserPage::SizeUserPage
|
|
|
|
Routine Description:
|
|
|
|
Sizes its children based on the size of the
|
|
tab control on which it appears.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
static const INT aUserControls[] =
|
|
{
|
|
IDM_DISCONNECT,
|
|
IDM_LOGOFF,
|
|
IDM_SENDMESSAGE
|
|
};
|
|
|
|
void CUserPage::SizeUserPage()
|
|
{
|
|
//
|
|
// Get the coords of the outer dialog
|
|
//
|
|
|
|
RECT rcParent;
|
|
GetClientRect(m_hPage, &rcParent);
|
|
|
|
HDWP hdwp = BeginDeferWindowPos( 1 + ARRAYSIZE(aUserControls) );
|
|
|
|
//
|
|
// Calc the deltas in the x and y positions that we need to
|
|
// move each of the child controls
|
|
//
|
|
|
|
RECT rcMaster;
|
|
HWND hwndMaster = GetDlgItem(m_hPage, IDM_SENDMESSAGE);
|
|
|
|
GetWindowRect(hwndMaster, &rcMaster);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcMaster, 2);
|
|
|
|
INT dx = ((rcParent.right - g_DefSpacing * 2) - rcMaster.right);
|
|
INT dy = ((rcParent.bottom - g_DefSpacing * 2) - rcMaster.bottom);
|
|
|
|
//
|
|
// Size the listbox
|
|
//
|
|
|
|
HWND hwndListbox = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
RECT rcListbox;
|
|
|
|
GetWindowRect(hwndListbox, &rcListbox);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcListbox, 2);
|
|
|
|
INT lbX = rcMaster.right - rcListbox.left + dx;
|
|
INT lbY = rcMaster.top - rcListbox.top + dy - g_DefSpacing;
|
|
|
|
DeferWindowPos(hdwp, hwndListbox, NULL,
|
|
0, 0,
|
|
lbX,
|
|
lbY,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
//
|
|
// Move each of the child controls by the above delta
|
|
//
|
|
|
|
for (int i = 0; i < ARRAYSIZE(aUserControls); i++)
|
|
{
|
|
HWND hwndCtrl = GetDlgItem(m_hPage, aUserControls[i]);
|
|
RECT rcCtrl;
|
|
|
|
GetWindowRect(hwndCtrl, &rcCtrl);
|
|
MapWindowPoints(HWND_DESKTOP, m_hPage, (LPPOINT) &rcCtrl, 2);
|
|
|
|
DeferWindowPos(hdwp, hwndCtrl, NULL,
|
|
rcCtrl.left + dx,
|
|
rcCtrl.top + dy,
|
|
0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
}
|
|
|
|
/*++ CUserPage::HandleWMCOMMAND
|
|
|
|
Routine Description:
|
|
|
|
Handles WM_COMMANDS received at the main page dialog
|
|
|
|
Arguments:
|
|
|
|
id - Command id of command received
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Dec-01-95 BradG Created
|
|
|
|
--*/
|
|
|
|
void CUserPage::HandleWMCOMMAND(INT id)
|
|
{
|
|
int iResult;
|
|
INT i;
|
|
INT iFinalOne = -1;
|
|
BOOL bFinalOne = FALSE;
|
|
BOOL bNeedToRefresh = FALSE;
|
|
DWORD dwSize;
|
|
LPTSTR psz;
|
|
WCHAR szCaption[ MAX_PATH ];
|
|
WCHAR szText1[ MAX_PATH * 2 ];
|
|
WCHAR szText2[ MAX_PATH * 2 ];
|
|
|
|
LoadString(g_hInstance, IDS_APPTITLE, szCaption, MAX_PATH);
|
|
|
|
CPtrArray * pArray = GetSelectedUsers();
|
|
|
|
if (!pArray)
|
|
{
|
|
//Assert( 0 && "WM_COMMAND but nothing selected" );
|
|
goto done;
|
|
}
|
|
|
|
if (id == IDM_SENDMESSAGE)
|
|
{
|
|
|
|
CSendMessageDlg SMDlg;
|
|
if(SMDlg.DoDialog(m_hwndTabs)!=IDOK)
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
// UI - only - don't care if it gets truncated
|
|
StringCchCopy( szText1, ARRAYSIZE(szText1), SMDlg.GetTitle() );
|
|
StringCchCopy( szText2, ARRAYSIZE(szText2), SMDlg.GetMessage() );
|
|
}
|
|
else if (id == IDM_LOGOFF || id == IDM_DISCONNECT)
|
|
{
|
|
//
|
|
// Verify this is what the user wants done
|
|
//
|
|
LoadString(
|
|
g_hInstance,
|
|
(id == IDM_LOGOFF) ? IDS_WARN_LOGOFF : IDS_WARN_DISCONNECT,
|
|
szText1,
|
|
ARRAYSIZE(szText1)
|
|
);
|
|
|
|
iResult = MessageBox(m_hwndTabs, szText1, szCaption, MB_YESNO | MB_DEFBUTTON2 | MB_ICONEXCLAMATION);
|
|
if (iResult == IDNO)
|
|
goto done;
|
|
}
|
|
|
|
BOOL b;
|
|
|
|
for( i = 0; i < pArray->GetSize(); i++ )
|
|
{
|
|
finalretry:
|
|
CUserInfo * pUser = (CUserInfo *) pArray->GetAt(i);
|
|
if (pUser == NULL)
|
|
{
|
|
Assert(0);
|
|
if (bFinalOne)
|
|
{
|
|
break; // Bail out, nothing left to process
|
|
}
|
|
else
|
|
{
|
|
continue; // try the next one
|
|
}
|
|
}
|
|
|
|
retry:
|
|
b = TRUE;
|
|
|
|
switch(id)
|
|
{
|
|
case IDM_SENDMESSAGE:
|
|
b = WTSSendMessage(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pUser->m_dwSessionId,
|
|
szText1,
|
|
lstrlen(szText1) * sizeof(WCHAR),
|
|
szText2,
|
|
lstrlen(szText2) * sizeof(WCHAR),
|
|
MB_OK | MB_TOPMOST | MB_ICONINFORMATION,
|
|
0, // ignored
|
|
&dwSize, // ignored, but it won't accept a NULL
|
|
FALSE
|
|
);
|
|
break;
|
|
|
|
case IDM_DISCONNECT:
|
|
if (g_dwMySessionId == pUser->m_dwSessionId && !bFinalOne)
|
|
{
|
|
// I don't want to kill of myself before everything else is complete,
|
|
// so I'll set a flag and skip myself for now.
|
|
iFinalOne = i;
|
|
continue;
|
|
}
|
|
b = WTSDisconnectSession(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pUser->m_dwSessionId,
|
|
FALSE
|
|
);
|
|
if (b)
|
|
{
|
|
bNeedToRefresh = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDM_LOGOFF:
|
|
if (g_dwMySessionId == pUser->m_dwSessionId && !bFinalOne)
|
|
{
|
|
// I don't want to kill of myself before everything else is complete,
|
|
// so I'll set a flag and skip myself for now.
|
|
iFinalOne = i;
|
|
continue;
|
|
}
|
|
b = WTSLogoffSession(
|
|
WTS_CURRENT_SERVER_HANDLE,
|
|
pUser->m_dwSessionId,
|
|
FALSE
|
|
);
|
|
if (b)
|
|
{
|
|
bNeedToRefresh = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDM_CONNECT:
|
|
{
|
|
WCHAR szPassword[ PASSWORD_LENGTH + 1 ];
|
|
BOOL bFirstTime = TRUE;
|
|
HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
|
|
|
|
// Start the connect loop with null password to try first.
|
|
szPassword[0] = '\0';
|
|
for( ;; )
|
|
{
|
|
DWORD Error;
|
|
BOOL fRet;
|
|
DWORD cch;
|
|
LPWSTR pszErrString;
|
|
|
|
fRet = WinStationConnect(hServer, pUser->m_dwSessionId, LOGONID_CURRENT, szPassword, TRUE);
|
|
if( fRet )
|
|
break; // success - break out of loop
|
|
|
|
Error = GetLastError();
|
|
|
|
// If a 'logon failure' brought us here, issue password dialog.
|
|
if(Error == ERROR_LOGON_FAILURE)
|
|
{
|
|
UINT ids = ( bFirstTime ? IDS_PWDDLG_USER : IDS_PWDDLG_USER2 );
|
|
CConnectPasswordDlg CPDlg( ids );
|
|
|
|
bFirstTime = FALSE;
|
|
|
|
if (CPDlg.DoDialog(m_hwndTabs) != IDOK)
|
|
{
|
|
break; // user CANCEL: break connect loop
|
|
}
|
|
else
|
|
{
|
|
StringCchCopy( szPassword, ARRAYSIZE(szPassword), CPDlg.GetPassword( ) );
|
|
continue; // try again with new password.
|
|
}
|
|
}
|
|
|
|
//
|
|
// Unhandled error occured. Pop up a message box and then bail the loop.
|
|
//
|
|
|
|
LoadString(g_hInstance, IDS_ERR_CONNECT, szText2, MAX_PATH);
|
|
|
|
// Retrieve system string for error.
|
|
cch = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
| FORMAT_MESSAGE_FROM_SYSTEM
|
|
| FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL,
|
|
Error,
|
|
0,
|
|
(LPWSTR) &pszErrString,
|
|
0,
|
|
NULL
|
|
);
|
|
if ( cch == 0 )
|
|
{
|
|
pszErrString = L'\0';
|
|
}
|
|
|
|
StringCchPrintf( szText1, ARRAYSIZE(szText1), szText2, Error, pszErrString );
|
|
|
|
MessageBox( m_hwndTabs, szText1, szCaption, MB_OK | MB_ICONEXCLAMATION );
|
|
|
|
if ( cch != 0 )
|
|
{
|
|
LocalFree( pszErrString );
|
|
}
|
|
|
|
break; // exit
|
|
}
|
|
|
|
//
|
|
// Destroy the password.
|
|
//
|
|
ZeroMemory( szPassword, sizeof(szPassword) );
|
|
}
|
|
break;
|
|
|
|
case IDM_REMOTECONTROL:
|
|
Shadow(m_hwndTabs, pUser);
|
|
break;
|
|
}
|
|
|
|
if (!b)
|
|
{
|
|
DWORD dwLastError = GetLastError();
|
|
UINT uiStr = 0;
|
|
|
|
//
|
|
// An error happened while processing the command
|
|
//
|
|
|
|
switch (id)
|
|
{
|
|
case IDM_DISCONNECT:
|
|
uiStr = IDS_ERR_DISCONNECT;
|
|
break;
|
|
case IDM_LOGOFF:
|
|
uiStr = IDS_ERR_LOGOFF;
|
|
break;
|
|
case IDM_SENDMESSAGE:
|
|
uiStr = IDS_ERR_SENDMESSAGE;
|
|
break;
|
|
}
|
|
|
|
if (uiStr)
|
|
{
|
|
LoadString(g_hInstance, uiStr, szText1, ARRAYSIZE(szText1));
|
|
// UI - only - don't care if it gets truncated
|
|
StringCchPrintf( szText2, ARRAYSIZE(szText2), szText1, pUser->m_szUserName, pUser->m_dwSessionId);
|
|
}
|
|
else
|
|
{
|
|
szText1[0] = L'\0';
|
|
}
|
|
|
|
psz = szText2 + lstrlen(szText2);
|
|
dwSize = ARRAYSIZE(szText2) - lstrlen(szText2) - 1;
|
|
FormatMessage(
|
|
FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
dwLastError,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
psz,
|
|
dwSize,
|
|
NULL
|
|
);
|
|
szText2[ ARRAYSIZE(szText2) - 1 ] = L'\0'; // make sure it is terminated.
|
|
|
|
iResult = MessageBox(
|
|
m_hwndTabs,
|
|
szText2,
|
|
szCaption,
|
|
MB_ICONSTOP | MB_ABORTRETRYIGNORE
|
|
);
|
|
if (iResult == IDCANCEL || iResult == IDABORT)
|
|
{
|
|
goto done;
|
|
}
|
|
else if (iResult == IDRETRY)
|
|
{
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Break out of the loop if we just went back to handle
|
|
// the special case of performing a disconnect or logoff
|
|
// on our own session.
|
|
//
|
|
|
|
if (bFinalOne)
|
|
break;
|
|
|
|
} // next i;
|
|
|
|
//
|
|
// Check here to see if we skiped our own session
|
|
//
|
|
|
|
if (iFinalOne != -1 && !bFinalOne)
|
|
{
|
|
// Yep, we skipped ourself. Lets put i back to the
|
|
// right location and try again.
|
|
bFinalOne = TRUE;
|
|
i = iFinalOne;
|
|
goto finalretry;
|
|
}
|
|
|
|
done:
|
|
if (pArray)
|
|
{
|
|
delete pArray;
|
|
}
|
|
|
|
Unpause();
|
|
|
|
//
|
|
// If we disconnected or logged off a user, go ahead and
|
|
// refresh the list. It should be up to date by now.
|
|
//
|
|
|
|
if (bNeedToRefresh)
|
|
{
|
|
TimerEvent();
|
|
}
|
|
}
|
|
|
|
|
|
/*++ UserPageProc
|
|
|
|
Routine Description:
|
|
|
|
Dialogproc for the task manager page.
|
|
|
|
Arguments:
|
|
|
|
hwnd - handle to dialog box
|
|
uMsg - message
|
|
wParam - first message parameter
|
|
lParam - second message parameter
|
|
|
|
Return Value:
|
|
|
|
For WM_INITDIALOG, TRUE == user32 sets focus, FALSE == we set focus
|
|
For others, TRUE == this proc handles the message
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
INT_PTR CALLBACK UserPageProc(
|
|
HWND hwnd, // handle to dialog box
|
|
UINT uMsg, // message
|
|
WPARAM wParam, // first message parameter
|
|
LPARAM lParam // second message parameter
|
|
)
|
|
{
|
|
CUserPage * thispage = (CUserPage *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
//
|
|
// See if the parent wants this message
|
|
//
|
|
|
|
if (TRUE == CheckParentDeferrals(uMsg, wParam, lParam))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);
|
|
CUserPage * thispage = (CUserPage *) lParam;
|
|
thispage->OnInitDialog(hwnd);
|
|
}
|
|
// We handle focus during Activate(). Return FALSE here so the
|
|
// dialog manager doesn't try to set focus.
|
|
return FALSE;
|
|
|
|
case WM_LBUTTONUP:
|
|
case WM_LBUTTONDOWN:
|
|
// We need to fake client mouse clicks in this child to appear as nonclient
|
|
// (caption) clicks in the parent so that the user can drag the entire app
|
|
// when the title bar is hidden by dragging the client area of this child
|
|
if (g_Options.m_fNoTitle)
|
|
{
|
|
SendMessage(g_hMainWnd,
|
|
uMsg == WM_LBUTTONUP ? WM_NCLBUTTONUP : WM_NCLBUTTONDOWN,
|
|
HTCAPTION,
|
|
lParam);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if(LOWORD(wParam) == IDM_USERCOLS)
|
|
{
|
|
if(ColSelectDlg.DoDialog(hwnd) == IDOK)
|
|
{
|
|
// Set up the columns in the listview
|
|
if (SUCCEEDED(thispage->SetupColumns()))
|
|
{
|
|
thispage->TimerEvent();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
thispage->HandleWMCOMMAND(LOWORD(wParam));
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
return thispage->HandleUserPageNotify((LPNMHDR) lParam);
|
|
|
|
case WM_MENUSELECT:
|
|
if ((UINT) HIWORD(wParam) == 0xFFFF)
|
|
{
|
|
// Menu dismissed, resume display
|
|
thispage->Unpause();
|
|
}
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
if ((HWND) wParam == GetDlgItem(hwnd, IDC_USERLIST))
|
|
{
|
|
thispage->HandleUserListContextMenu(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
//
|
|
// Size our kids
|
|
//
|
|
thispage->SizeUserPage();
|
|
return TRUE;
|
|
|
|
case WM_SETTINGCHANGE:
|
|
thispage->OnSettingsChange();
|
|
// fall through
|
|
|
|
case WM_SYSCOLORCHANGE:
|
|
SendMessage(GetDlgItem(hwnd, IDC_USERLIST), uMsg, wParam, lParam);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
void CUserPage::OnInitDialog(HWND hPage)
|
|
{
|
|
m_hPage = hPage;
|
|
|
|
HWND hUserList = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
ListView_SetImageList(hUserList, m_himlUsers, LVSIL_SMALL);
|
|
|
|
//
|
|
// Turn on SHOWSELALWAYS so that the selection is still highlighted even
|
|
// when focus is lost to one of the buttons (for example)
|
|
//
|
|
|
|
SetWindowLong(hUserList, GWL_STYLE, GetWindowLong(hUserList, GWL_STYLE) | LVS_SHOWSELALWAYS);
|
|
ListView_SetExtendedListViewStyle(hUserList, LVS_EX_DOUBLEBUFFER);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
void CUserPage::OnSettingsChange()
|
|
{
|
|
// in going between large-font settings and normal settings, the size of small
|
|
// icons changes; so throw away all our icons and change the size of images in
|
|
// our lists
|
|
|
|
BOOL fPaused = m_fPaused; // pause the page so we can get through
|
|
m_fPaused = TRUE; // the below without being updated
|
|
|
|
RemoveAllUsers();
|
|
m_pUserArray->RemoveAll();
|
|
|
|
m_fPaused = fPaused; // restore the paused state
|
|
TimerEvent(); // even if we're paused, we'll want to redraw
|
|
}
|
|
|
|
|
|
/*++ CUserPage::GetTitle
|
|
|
|
Routine Description:
|
|
|
|
Copies the title of this page to the caller-supplied buffer
|
|
|
|
Arguments:
|
|
|
|
pszText - the buffer to copy to
|
|
bufsize - size of buffer, in characters
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
void CUserPage::GetTitle(LPTSTR pszText, size_t bufsize)
|
|
{
|
|
LoadString(g_hInstance, IDS_USERPAGETITLE, pszText, static_cast<int>(bufsize));
|
|
}
|
|
|
|
|
|
/*++ CUserPage::Activate
|
|
|
|
Routine Description:
|
|
|
|
Brings this page to the front, sets its initial position,
|
|
and shows it
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
HRESULT (S_OK on success)
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserPage::Activate()
|
|
{
|
|
//
|
|
// Make this page visible
|
|
//
|
|
|
|
ShowWindow(m_hPage, SW_SHOW);
|
|
|
|
SetWindowPos(
|
|
m_hPage,
|
|
HWND_TOP,
|
|
0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE
|
|
);
|
|
|
|
//
|
|
// Change the menu bar to be the menu for this page
|
|
//
|
|
|
|
HMENU hMenuOld = GetMenu(g_hMainWnd);
|
|
HMENU hMenuNew = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDR_MAINMENU_USER));
|
|
|
|
AdjustMenuBar(hMenuNew);
|
|
|
|
g_hMenu = hMenuNew;
|
|
if (g_Options.m_fNoTitle == FALSE)
|
|
{
|
|
SetMenu(g_hMainWnd, hMenuNew);
|
|
}
|
|
|
|
if (hMenuOld)
|
|
{
|
|
DestroyMenu(hMenuOld);
|
|
}
|
|
|
|
UpdateUIState();
|
|
|
|
//
|
|
// If the tab control has focus, leave it there. Otherwise, set focus
|
|
// to the listview. If we don't set focus, it may stay on the previous
|
|
// page, now hidden, which can confuse the dialog manager and may cause
|
|
// us to hang.
|
|
//
|
|
|
|
if (GetFocus() != m_hwndTabs)
|
|
{
|
|
SetFocus(GetDlgItem(m_hPage, IDC_USERLIST));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*++ class CUserPage::SetupColumns
|
|
|
|
Class Description:
|
|
|
|
Removes any existing columns from the taskmanager listview and
|
|
adds all of the columns listed in the g_ActiveUserCol array.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
HRESULT
|
|
|
|
Revision History:
|
|
|
|
Nov-29-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserPage::SetupColumns()
|
|
{
|
|
HWND hwndList = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
if (NULL == hwndList)
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
ListView_DeleteAllItems(hwndList);
|
|
|
|
//
|
|
// Remove all existing columns
|
|
// save column widths.
|
|
//
|
|
|
|
LV_COLUMN lvcolumn;
|
|
lvcolumn.mask = LVCF_SUBITEM | LVCF_WIDTH;
|
|
|
|
UserColumn *pCol = ColSelectDlg.GetColumns();
|
|
|
|
do
|
|
{
|
|
if(ListView_GetColumn(hwndList, 0, &lvcolumn))
|
|
{
|
|
if(lvcolumn.iSubItem >= USR_COL_USERSNAME &&
|
|
lvcolumn.iSubItem < USR_MAX_COLUMN)
|
|
{
|
|
pCol[lvcolumn.iSubItem].Width=lvcolumn.cx;
|
|
}
|
|
}
|
|
|
|
} while( ListView_DeleteColumn(hwndList, 0) );
|
|
|
|
//
|
|
// Add all of the new columns
|
|
//
|
|
|
|
INT iColumn = 0;
|
|
for (int i=0; i<USR_MAX_COLUMN; i++)
|
|
{
|
|
if(pCol[i].bActive)
|
|
{
|
|
WCHAR szTitle[MAX_PATH];
|
|
LoadString( g_hInstance, pCol[i].dwNameID, szTitle, ARRAYSIZE(szTitle) );
|
|
|
|
lvcolumn.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
|
|
lvcolumn.fmt = pCol[i].Align;
|
|
lvcolumn.cx = pCol[i].Width;
|
|
lvcolumn.pszText = szTitle;
|
|
lvcolumn.iSubItem = i;
|
|
|
|
if (-1 == ListView_InsertColumn(hwndList, iColumn, &lvcolumn))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
iColumn++;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
/*++ CUserPage::Initialize
|
|
|
|
Routine Description:
|
|
|
|
Initializes the task manager page
|
|
|
|
Arguments:
|
|
|
|
hwndParent - Parent on which to base sizing on: not used for creation,
|
|
since the main app window is always used as the parent in
|
|
order to keep tab order correct
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserPage::Initialize(HWND hwndParent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Create the ptr array used to hold the info on running tasks
|
|
//
|
|
|
|
m_pUserArray = new CPtrArray(GetProcessHeap());
|
|
if (NULL == m_pUserArray)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
// Our pseudo-parent is the tab contrl, and is what we base our
|
|
// sizing on. However, in order to keep tab order right among
|
|
// the controls, we actually create ourselves with the main
|
|
// window as the parent
|
|
|
|
m_hwndTabs = hwndParent;
|
|
|
|
//
|
|
// Create the image lists
|
|
//
|
|
|
|
UINT flags = ILC_MASK;
|
|
|
|
if(IS_WINDOW_RTL_MIRRORED(hwndParent))
|
|
{
|
|
flags |= ILC_MIRROR;
|
|
}
|
|
|
|
m_himlUsers = ImageList_Create(
|
|
GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
flags,
|
|
2,
|
|
1
|
|
);
|
|
if (NULL == m_himlUsers)
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Load the default icons
|
|
hr = LoadDefaultIcons();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Load the status strings
|
|
//
|
|
|
|
WCHAR szText[ MAX_PATH ];
|
|
|
|
for( int i = 0; i < MAX_STAT_STRINGS; i++ )
|
|
{
|
|
if ( LoadString(g_hInstance, FIRST_STAT_STRING + i, szText, ARRAYSIZE(szText) ) )
|
|
{
|
|
DWORD cchLen = lstrlen(szText) + 1;
|
|
g_pszStatString[i] = (LPWSTR) LocalAlloc( 0, cchLen * sizeof(*g_pszStatString[i]) );
|
|
if (g_pszStatString[i])
|
|
{
|
|
// shouldn't be truncated as we dynamically allocated the array above
|
|
HRESULT hr = StringCchCopy( g_pszStatString[i], cchLen, szText);
|
|
ASSERT( S_OK == hr );
|
|
hr; // unreferenced on FRE builds.
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Create the dialog which represents the body of this page
|
|
//
|
|
|
|
m_hPage = CreateDialogParam(
|
|
g_hInstance, // handle to application instance
|
|
MAKEINTRESOURCE(IDD_USERSPAGE), // identifies dialog box template name
|
|
g_hMainWnd, // handle to owner window
|
|
UserPageProc, // pointer to dialog box procedure
|
|
(LPARAM) this // User data (our this pointer)
|
|
);
|
|
|
|
if (NULL == m_hPage)
|
|
{
|
|
hr = GetLastHRESULT();
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Set up the columns in the listview
|
|
|
|
hr = SetupColumns();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TimerEvent();
|
|
}
|
|
|
|
//
|
|
// If any failure along the way, clean up what got allocated
|
|
// up to that point
|
|
//
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (m_hPage)
|
|
{
|
|
DestroyWindow(m_hPage);
|
|
}
|
|
|
|
m_hwndTabs = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
HRESULT CUserPage::LoadDefaultIcons()
|
|
{
|
|
HICON hIcon;
|
|
|
|
hIcon = (HICON) LoadImage(
|
|
g_hInstance,
|
|
MAKEINTRESOURCE(IDI_USER),
|
|
IMAGE_ICON,
|
|
GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
0
|
|
);
|
|
if (!hIcon)
|
|
{
|
|
return GetLastHRESULT();
|
|
}
|
|
|
|
m_iUserIcon = ImageList_AddIcon(m_himlUsers, hIcon);
|
|
DestroyIcon(hIcon);
|
|
if (-1 == m_iUserIcon)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
hIcon = (HICON) LoadImage(
|
|
g_hInstance,
|
|
MAKEINTRESOURCE(IDI_CURRENTUSER),
|
|
IMAGE_ICON,
|
|
GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
0
|
|
);
|
|
if (!hIcon)
|
|
{
|
|
return GetLastHRESULT();
|
|
}
|
|
|
|
m_iCurrentUserIcon = ImageList_AddIcon(m_himlUsers, hIcon);
|
|
DestroyIcon(hIcon);
|
|
if (-1 == m_iUserIcon)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*++ CUserPage::Destroy
|
|
|
|
Routine Description:
|
|
|
|
Frees whatever has been allocated by the Initialize call and saves last
|
|
column settings.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
HRESULT CUserPage::Destroy()
|
|
{
|
|
//
|
|
// Get current column widths
|
|
//
|
|
|
|
HWND hwndList = GetDlgItem(m_hPage, IDC_USERLIST);
|
|
if (hwndList)
|
|
{
|
|
|
|
LV_COLUMN lvcolumn;
|
|
lvcolumn.mask = LVCF_SUBITEM | LVCF_WIDTH;
|
|
|
|
UserColumn *pCol = ColSelectDlg.GetColumns();
|
|
|
|
for(int i=0; ListView_GetColumn(hwndList, i, &lvcolumn); i++)
|
|
{
|
|
if(lvcolumn.iSubItem >= USR_COL_USERSNAME &&
|
|
lvcolumn.iSubItem < USR_MAX_COLUMN)
|
|
{
|
|
pCol[lvcolumn.iSubItem].Width=lvcolumn.cx;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save settings
|
|
//
|
|
|
|
ColSelectDlg.Save();
|
|
|
|
//
|
|
// Page cleanup
|
|
//
|
|
|
|
if (m_hPage)
|
|
{
|
|
DestroyWindow(m_hPage);
|
|
m_hPage = NULL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*++ CUserPage::Deactivate
|
|
|
|
Routine Description:
|
|
|
|
Called when this page is losing its place up front
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Nov-28-95 BradG Created
|
|
|
|
--*/
|
|
|
|
void CUserPage::Deactivate()
|
|
{
|
|
if (m_hPage)
|
|
{
|
|
ShowWindow(m_hPage, SW_HIDE);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD Shadow_WarningProc(HWND *phwnd);
|
|
INT_PTR CALLBACK ShadowWarn_WndProc( HWND hwnd , UINT msg , WPARAM wp , LPARAM lp );
|
|
void CenterDlg(HWND hwndToCenterOn , HWND hDlg );
|
|
|
|
/*++ Shadow
|
|
|
|
Routine Description:
|
|
|
|
remote control session
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Revision History:
|
|
|
|
Feb-8-2000 a-skuzin Created
|
|
|
|
--*/
|
|
void Shadow(HWND hwnd, CUserInfo * pUser)
|
|
{
|
|
WINSTATIONCONFIG WSConfig;
|
|
SHADOWCLASS Shadow;
|
|
ULONG ReturnLength;
|
|
HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
|
|
|
|
//Error handling
|
|
WCHAR szMsgText[MAX_PATH+1];
|
|
WCHAR szCaption[MAX_PATH+1];
|
|
WCHAR szTemplate[MAX_PATH+1];
|
|
|
|
LoadString(g_hInstance, IDS_APPTITLE, szCaption, MAX_PATH);
|
|
|
|
//
|
|
// Determine the WinStation's shadow state.
|
|
//
|
|
|
|
if(!WinStationQueryInformation(hServer,
|
|
pUser->m_dwSessionId,
|
|
WinStationConfiguration,
|
|
&WSConfig, sizeof(WINSTATIONCONFIG),
|
|
&ReturnLength ) )
|
|
{
|
|
// Can't query WinStation configuration; complain and return
|
|
return;
|
|
}
|
|
|
|
Shadow = WSConfig.User.Shadow;
|
|
|
|
//
|
|
// If shadowing is disabled, let the user know and return
|
|
//
|
|
|
|
if(Shadow == Shadow_Disable )
|
|
{
|
|
LoadString(g_hInstance,IDS_ERR_SHADOW_DISABLED,szTemplate,MAX_PATH);
|
|
// UI only - don't care it if gets truncated.
|
|
StringCchPrintf(szMsgText, ARRAYSIZE(szMsgText), szTemplate, pUser->m_dwSessionId );
|
|
MessageBox(hwnd, szMsgText, szCaption, MB_OK | MB_ICONEXCLAMATION);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// If the WinStation is disconnected and shadow notify is 'on',
|
|
// let the user know and break out.
|
|
//
|
|
|
|
if((pUser->m_wtsState == WTSDisconnected) &&
|
|
((Shadow == Shadow_EnableInputNotify) ||
|
|
(Shadow == Shadow_EnableNoInputNotify)) )
|
|
{
|
|
LoadString(g_hInstance,IDS_ERR_SHADOW_DISCONNECTED_NOTIFY_ON,szTemplate,MAX_PATH);
|
|
// UI only - don't care it if gets truncated.
|
|
StringCchPrintf( szMsgText, ARRAYSIZE(szMsgText), szTemplate, pUser->m_dwSessionId );
|
|
MessageBox(hwnd, szMsgText, szCaption, MB_OK | MB_ICONEXCLAMATION);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Display the 'start shadow' dialog for hotkey reminder and
|
|
// final 'ok' prior to shadowing.
|
|
//
|
|
|
|
CShadowStartDlg SSDlg;
|
|
|
|
if (SSDlg.DoDialog(hwnd) != IDOK)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// launch UI thread (???)
|
|
//
|
|
|
|
HWND hwndShadowWarn = NULL;
|
|
|
|
hwndShadowWarn = CreateDialogParam( g_hInstance
|
|
, MAKEINTRESOURCE( IDD_DIALOG_SHADOWWARN )
|
|
, hwnd
|
|
, ShadowWarn_WndProc
|
|
, (LPARAM) 0
|
|
);
|
|
if(hwndShadowWarn)
|
|
{
|
|
ShowWindow( hwndShadowWarn, SW_SHOW );
|
|
UpdateWindow( hwndShadowWarn );
|
|
}
|
|
|
|
//
|
|
// Invoke the shadow DLL.
|
|
//
|
|
|
|
HCURSOR hOldCursor = SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
|
|
//
|
|
// allow UI thread to init window (??? but this is the same thread)
|
|
//
|
|
|
|
Sleep( 900 );
|
|
|
|
//
|
|
// Shadow API always connects to local server,
|
|
// passing target servername as a parameter.
|
|
//
|
|
|
|
WCHAR szCompName[MAX_COMPUTERNAME_LENGTH + 1];
|
|
DWORD dwSize=MAX_COMPUTERNAME_LENGTH;
|
|
|
|
GetComputerName(szCompName,&dwSize);
|
|
|
|
BOOL bOK = WinStationShadow(WTS_CURRENT_SERVER_HANDLE, szCompName, pUser->m_dwSessionId,
|
|
(BYTE)(SSDlg.GetShadowHotkeyKey()),(WORD)(SSDlg.GetShadowHotkeyShift()));
|
|
|
|
if( hwndShadowWarn != NULL )
|
|
{
|
|
DestroyWindow(hwndShadowWarn);
|
|
}
|
|
|
|
if( !bOK )
|
|
{
|
|
LoadString(g_hInstance,IDS_ERR_SHADOW,szTemplate,MAX_PATH);
|
|
// UI only - don't care it if gets truncated.
|
|
StringCchPrintf( szMsgText, ARRAYSIZE(szMsgText), szTemplate, pUser->m_dwSessionId );
|
|
MessageBox(hwnd, szMsgText, szCaption, MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
SetCursor(hOldCursor);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
DWORD Shadow_WarningProc(HWND *phwnd)
|
|
{
|
|
|
|
DialogBoxParam( g_hInstance , MAKEINTRESOURCE( IDD_DIALOG_SHADOWWARN ) , NULL , ShadowWarn_WndProc,
|
|
(LPARAM)phwnd);
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
INT_PTR CALLBACK ShadowWarn_WndProc( HWND hwnd , UINT msg , WPARAM , LPARAM )
|
|
{
|
|
switch( msg )
|
|
{
|
|
case WM_INITDIALOG:
|
|
CenterDlg( GetDesktopWindow( ) , hwnd );
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
void CenterDlg(HWND hwndToCenterOn , HWND hDlg )
|
|
{
|
|
RECT rc, rcwk, rcToCenterOn;
|
|
|
|
SetRect( &rcToCenterOn , 0 , 0 , GetSystemMetrics(SM_CXSCREEN) , GetSystemMetrics( SM_CYSCREEN ) );
|
|
|
|
if (hwndToCenterOn != NULL)
|
|
{
|
|
GetWindowRect(hwndToCenterOn, &rcToCenterOn);
|
|
}
|
|
|
|
GetWindowRect( hDlg , &rc);
|
|
|
|
UINT uiWidth = rc.right - rc.left;
|
|
UINT uiHeight = rc.bottom - rc.top;
|
|
|
|
rc.left = (rcToCenterOn.left + rcToCenterOn.right) / 2 - ( rc.right - rc.left ) / 2;
|
|
rc.top = (rcToCenterOn.top + rcToCenterOn.bottom) / 2 - ( rc.bottom - rc.top ) / 2;
|
|
|
|
//
|
|
// Ensure the dialog always with the work area
|
|
//
|
|
|
|
if(SystemParametersInfo(SPI_GETWORKAREA, 0, &rcwk, 0))
|
|
{
|
|
UINT wkWidth = rcwk.right - rcwk.left;
|
|
UINT wkHeight = rcwk.bottom - rcwk.top;
|
|
|
|
if(rc.left + uiWidth > wkWidth) //right cut
|
|
rc.left = wkWidth - uiWidth;
|
|
|
|
if(rc.top + uiHeight > wkHeight) //bottom cut
|
|
rc.top = wkHeight - uiHeight;
|
|
|
|
if(rc.left < rcwk.left) //left cut
|
|
rc.left += rcwk.left - rc.left;
|
|
|
|
if(rc.top < rcwk.top) //top cut
|
|
rc.top += rcwk.top - rc.top;
|
|
|
|
}
|
|
|
|
SetWindowPos( hDlg, NULL, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER |
|
|
SWP_NOCOPYBITS | SWP_DRAWFRAME);
|
|
|
|
}
|