windows-xp/Source/XPSP1/NT/termsrv/admtools/winutils/tsadmin/winadmin.h

/*******************************************************************************
*
* winadmin.h
*
* main header file for the WINADMIN application
*
* 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\winadmin.h  $
*
*     Rev 1.12   25 Apr 1998 13:43:14   donm
*  MS 2167: try to use proper Wd from registry
*
*     Rev 1.11   19 Feb 1998 17:42:52   donm
*  removed latest extension DLL support
*
*     Rev 1.9   19 Jan 1998 16:49:28   donm
*  new ui behavior for domains and servers
*
*     Rev 1.8   03 Nov 1997 15:28:02   donm
*  added Domains
*
*     Rev 1.7   22 Oct 1997 21:09:10   donm
*  update
*
*     Rev 1.6   17 Oct 1997 18:07:28   donm
*  update
*
*     Rev 1.5   15 Oct 1997 19:52:48   donm
*  update
*
*     Rev 1.4   13 Oct 1997 23:07:14   donm
*  update
*
*     Rev 1.3   13 Oct 1997 22:20:02   donm
*  update
*
*     Rev 1.2   26 Aug 1997 19:16:24   donm
*  bug fixes/changes from WinFrame 1.7
*
*     Rev 1.1   31 Jul 1997 16:52:52   butchd
*  update
*
*     Rev 1.0   30 Jul 1997 17:13:12   butchd
*  Initial revision.
*
*******************************************************************************/

#ifndef _WINADMIN_H
#define _WINADMIN_H

#ifndef __AFXWIN_H__
        #error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"       // main symbols
#include <afxmt.h>
#include <winsta.h>
#include <time.h>
#include <utildll.h>
#include "waextend.h"

// Classes defined in this file
class CTreeNode;
class CWinStation;
class CModule;
class CLicense;
class CServer;
class CWinAdminApp;
class CProcess;
class CHotFix;
class CDomain;
class CWd;

// Server icon overlay states
const USHORT STATE_NORMAL = 0x0000;
const USHORT STATE_NOT = 0x0100;
const USHORT STATE_QUESTION = 0x0200;

const USHORT MSG_TITLE_LENGTH = 64;
const USHORT MSG_MESSAGE_LENGTH = 256;

const USHORT LIST_TOP_OFFSET = 4;

const int KBDSHIFT      = 0x01;
const int KBDCTRL       = 0x02;
const int KBDALT        = 0x04;


enum VIEW {
        VIEW_BLANK,
        VIEW_ALL_SERVERS,
    VIEW_DOMAIN,
        VIEW_SERVER,
        VIEW_MESSAGE,
        VIEW_WINSTATION,
        VIEW_CHANGING
};

const int PAGE_CHANGING = 0xFFFF;

enum AS_PAGE {
// All Servers Pages
        PAGE_AS_SERVERS,
        PAGE_AS_USERS,
        PAGE_AS_WINSTATIONS,
        PAGE_AS_PROCESSES,
        PAGE_AS_LICENSES
};

enum DOMAIN_PAGE {
    PAGE_DOMAIN_SERVERS,
    PAGE_DOMAIN_USERS,
    PAGE_DOMAIN_WINSTATIONS,
    PAGE_DOMAIN_PROCESSES,
    PAGE_DOMAIN_LICENSES
};

enum SERVER_PAGE {
// Server Pages
        PAGE_USERS,
        PAGE_WINSTATIONS,
        PAGE_PROCESSES,
        PAGE_LICENSES,
        PAGE_INFO
};

enum WINS_PAGE {
// WinStation Pages
        PAGE_WS_PROCESSES,
        PAGE_WS_INFO,
        PAGE_WS_MODULES,
        PAGE_WS_CACHE,
        PAGE_WS_NO_INFO
};

// The column enums have to be here so that colsort.cpp can get to them
// Server User's columns
enum USERSCOLUMNS {
        USERS_COL_USER,
        USERS_COL_WINSTATION,
        USERS_COL_ID,
        USERS_COL_STATE,
        USERS_COL_IDLETIME,
        USERS_COL_LOGONTIME
};

// Server WinStation's columns
enum STATIONCOLUMNS {
        WS_COL_WINSTATION,
        WS_COL_USER,
        WS_COL_ID,
        WS_COL_STATE,
        WS_COL_TYPE,
        WS_COL_CLIENTNAME,
        WS_COL_IDLETIME,
        WS_COL_LOGONTIME,
        WS_COL_COMMENT
};

// Server Processes' columns
enum PROCESSCOLUMNS {
        PROC_COL_USER,
        PROC_COL_WINSTATION,
        PROC_COL_ID,
        PROC_COL_PID,
        PROC_COL_IMAGE
};

// Server Licenses' columns
enum LICENSECOLUMNS {
        LICENSE_COL_DESCRIPTION,
        LICENSE_COL_REGISTERED,
        LICENSE_COL_USERCOUNT,
        LICENSE_COL_POOLCOUNT,
        LICENSE_COL_NUMBER
};

// Server Hotfix columns
enum HOTFIXCOLUMNS {
        HOTFIX_COL_NAME,
        HOTFIX_COL_INSTALLEDBY,
        HOTFIX_COL_INSTALLEDON
};

// WinStation Processes columns
enum WS_PROCESSCOLUMNS {
        WS_PROC_COL_ID,
        WS_PROC_COL_PID,
        WS_PROC_COL_IMAGE
};

// WinStation Modules columns
enum MODULESCOLUMNS {
        MODULES_COL_FILENAME,
        MODULES_COL_FILEDATETIME,
        MODULES_COL_SIZE,
        MODULES_COL_VERSIONS
};

// All Server Servers columns
enum SERVERSCOLUMNS {
        SERVERS_COL_SERVER,
        SERVERS_COL_TCPADDRESS,
        SERVERS_COL_IPXADDRESS,
        SERVERS_COL_NUMWINSTATIONS
};

// All Server Users columns
enum AS_USERS_COLUMNS {
        AS_USERS_COL_SERVER,
        AS_USERS_COL_USER,
        AS_USERS_COL_WINSTATION,
        AS_USERS_COL_ID,
        AS_USERS_COL_STATE,
        AS_USERS_COL_IDLETIME,
        AS_USERS_COL_LOGONTIME
};

// All Server WinStations columns
enum AS_STATIONCOLUMNS {
        AS_WS_COL_SERVER,
        AS_WS_COL_WINSTATION,
        AS_WS_COL_USER,
        AS_WS_COL_ID,
        AS_WS_COL_STATE,
        AS_WS_COL_TYPE,
        AS_WS_COL_CLIENTNAME,
        AS_WS_COL_IDLETIME,
        AS_WS_COL_LOGONTIME,
        AS_WS_COL_COMMENT
};

// All Server Processes columns
enum AS_PROCESSCOLUMNS {
        AS_PROC_COL_SERVER,
        AS_PROC_COL_USER,
        AS_PROC_COL_WINSTATION,
        AS_PROC_COL_ID,
        AS_PROC_COL_PID,
        AS_PROC_COL_IMAGE
};

// All Server Licenses columns
enum AS_LICENSECOLUMNS {
        AS_LICENSE_COL_SERVER,
        AS_LICENSE_COL_DESCRIPTION,
        AS_LICENSE_COL_REGISTERED,
        AS_LICENSE_COL_USERCOUNT,
        AS_LICENSE_COL_POOLCOUNT,
        AS_LICENSE_COL_NUMBER
};

// in colsort.cpp
void SortByColumn(int View, int Page, CListCtrl *list, int ColumnNumber, BOOL bAscending);

// Extension Startup Function
typedef void (WINAPI *LPFNEXSTARTUPPROC) (HWND);
// Extension Shutdown Function
typedef void (WINAPI *LPFNEXSHUTDOWNPROC) (void);
// Extension Server Enumerate Function
typedef LPWSTR (WINAPI *LPFNEXENUMERATEPROC) (LPWSTR);
// Extension WinStation Init Function
typedef void* (WINAPI *LPFNEXWINSTATIONINITPROC) (HANDLE, ULONG);
// Extension WinStation Additional Info Function
typedef void (WINAPI *LPFNEXWINSTATIONINFOPROC) (void*, int);
// Extension WinStation Cleanup Function
typedef void (WINAPI *LPFNEXWINSTATIONCLEANUPPROC) (void*);
// Extension Server Init Function
typedef void* (WINAPI *LPFNEXSERVERINITPROC) (TCHAR*, HANDLE);
// Extension Server Cleanup Function
typedef void (WINAPI *LPFNEXSERVERCLEANUPPROC) (void*);
// Extension Server Event Function
typedef BOOL (WINAPI *LPFNEXSERVEREVENTPROC) (void*, ULONG);
// Extension Get Server Info
typedef ExtServerInfo* (WINAPI *LPFNEXGETSERVERINFOPROC) (void *);
// Extension Get Server License Info
typedef ExtLicenseInfo* (WINAPI *LPFNEXGETSERVERLICENSESPROC) (void*, ULONG*);
// Extension Get Global Info
typedef ExtGlobalInfo* (WINAPI *LPFNEXGETGLOBALINFOPROC) (void);
// Extension Get WinStation Info
typedef ExtWinStationInfo* (WINAPI *LPFNEXGETWINSTATIONINFOPROC) (void *);
// Extension Get WinStation Modules
typedef ExtModuleInfo* (WINAPI *LPFNEXGETWINSTATIONMODULESPROC) (void*, ULONG*);
// Extension Free Server License Info
typedef void (WINAPI *LPFNEXFREESERVERLICENSESPROC) (ExtLicenseInfo*);
// Extension Free WinStation Modules
typedef void (WINAPI *LPFNEXFREEWINSTATIONMODULESPROC) (ExtModuleInfo*);

/////////////////////////////////////////////////////////////////////////////
// CWinAdminApp:
// See WinAdmin.cpp for the implementation of this class
//
class CWinAdminApp : public CWinApp
{
public:
        // constructor
        CWinAdminApp();
        // Returns the Current User Name
        TCHAR *GetCurrentUserName() { return m_CurrentUserName; }
        // Returns the Current WinStation Name
        PWINSTATIONNAME GetCurrentWinStationName() { return m_CurrentWinStationName; }
        // Returns the Current Server Name
        TCHAR *GetCurrentServerName() { return m_CurrentServerName; }
        // Returns the Current Logon Id
        ULONG GetCurrentLogonId() { return m_CurrentLogonId; }
        // Returns the Current WinStation Flags
        ULONG GetCurrentWSFlags() { return m_CurrentWSFlags; }
        // Returns TRUE if the current user has Admin privileges?
        BOOL IsUserAdmin() { return m_Admin; }
        // Returns TRUE if we are running under Picasso
        BOOL IsPicasso() { return m_Picasso; }
        // Returns TRUE if we should show system processes
        BOOL ShowSystemProcesses() { return m_ShowSystemProcesses; }
        // Sets the show system processes variable
        void SetShowSystemProcesses(BOOL show) { m_ShowSystemProcesses = show; }
        // Returns TRUE if we should ask user for confirmation of Actions
        BOOL AskConfirmation() { return m_Confirmation; }
        // Sets the confirmation variable
        void SetConfirmation(BOOL conf) { m_Confirmation = conf; }
        // Returms TRUE if we should save the preferences upon exit
        BOOL SavePreferences() { return m_SavePreferences; }
        // Sets the save preferences variable
        void SetSavePreferences(BOOL pref) { m_SavePreferences = pref; }
        // Returns the Process List Refresh Time
        UINT GetProcessListRefreshTime() { return m_ProcessListRefreshTime; }
        // Sets the Process List Refresh Time
        void SetProcessListRefreshTime(UINT pt) { m_ProcessListRefreshTime = pt; }
        // Returns the Status Dialog Refresh Time
        UINT GetStatusRefreshTime() { return m_StatusRefreshTime; }
        // Sets the Status Dialog Refresh Time
        void SetStatusRefreshTime(UINT st) { m_StatusRefreshTime = st; }
        // Returns a pointer to the document
        CDocument *GetDocument() { return m_Document; }
        // Sets the m_Document variable
        void SetDocument(CDocument *doc) { m_Document = doc; }
        // Should we Show All Servers - based on menu item toggle
        BOOL GetShowAllServers() { return m_ShowAllServers; }
        // Set the Show All Servers variable
        void SetShowAllServers(BOOL sa) { m_ShowAllServers = sa; }
        // Returns the value of shadow hotkey key
        int GetShadowHotkeyKey() { return m_ShadowHotkeyKey; }
        // Sets the value of shadow hotkey key
        void SetShadowHotkeyKey(int key) { m_ShadowHotkeyKey = key; }
        // Returns the value of shadow hotkey shift state
        DWORD GetShadowHotkeyShift() { return m_ShadowHotkeyShift; }
        // Sets the value of shadow hotkey shift state
        void SetShadowHotkeyShift(DWORD shift) { m_ShadowHotkeyShift = shift; }
        // Get the tree width
        int GetTreeWidth() { return m_TreeWidth; }
        // Set the tree width
        void SetTreeWidth(int width) { m_TreeWidth = width; }
        // Get the window placement
        WINDOWPLACEMENT *GetPlacement() { return &m_Placement; }

        // Returns the address of the extension DLL's startup function
        LPFNEXSTARTUPPROC GetExtStartupProc() { return m_lpfnWAExStart; }
        // Returns the address of the extension DLL's shutdown function
        LPFNEXSHUTDOWNPROC GetExtShutdownProc() { return m_lpfnWAExEnd; }
        // Returns the address of the extension DLL's server enumeration function
        LPFNEXENUMERATEPROC GetExtEnumerationProc() { return m_lpfnWAExServerEnumerate; }
        // Returns the address of the extension DLL's WinStation Init function
        LPFNEXWINSTATIONINITPROC GetExtWinStationInitProc() { return m_lpfnWAExWinStationInit; }
        // Returns the address of the extension DLL's WinStation Info function
        LPFNEXWINSTATIONINFOPROC GetExtWinStationInfoProc() { return m_lpfnWAExWinStationInfo; }
        // Returns the address of the extension DLL's WinStation Cleanup function
        LPFNEXWINSTATIONCLEANUPPROC GetExtWinStationCleanupProc() { return m_lpfnWAExWinStationCleanup; }
        // Returns the address of the extension DLL's Server Init function
        LPFNEXSERVERINITPROC GetExtServerInitProc() { return m_lpfnWAExServerInit; }
        // Returns the address of the extension DLL's Server Cleanup function
        LPFNEXSERVERCLEANUPPROC GetExtServerCleanupProc() { return m_lpfnWAExServerCleanup; }
        // Returns the address of the extension DLL's Get Server Info function
        LPFNEXGETSERVERINFOPROC GetExtGetServerInfoProc() { return m_lpfnWAExGetServerInfo; }
        // Returns the address of the extension DLL's Get Server License Info function
        LPFNEXGETSERVERLICENSESPROC GetExtGetServerLicensesProc() { return m_lpfnWAExGetServerLicenses; }
        // Returns the address of the extension DLL's Server Event function
        LPFNEXSERVEREVENTPROC GetExtServerEventProc() { return m_lpfnWAExServerEvent; }
        // Returns the address of the extension DLL's Get Global Info function
        LPFNEXGETGLOBALINFOPROC GetExtGetGlobalInfoProc() { return m_lpfnWAExGetGlobalInfo; }
        // Returns the address of the extension DLL's Get WinStation Info Function
        LPFNEXGETWINSTATIONINFOPROC GetExtGetWinStationInfoProc() { return m_lpfnWAExGetWinStationInfo; }
        // Returns the address of the extension DLL's Get WinStation Module Info function
        LPFNEXGETWINSTATIONMODULESPROC GetExtGetWinStationModulesProc() { return m_lpfnWAExGetWinStationModules; }
        // Returns the address of the extension DLL's Free Server License Info function
        LPFNEXFREESERVERLICENSESPROC GetExtFreeServerLicensesProc() { return m_lpfnWAExFreeServerLicenses; }
        // Returns the address of the extension DLL's Free WinStation Modules function
        LPFNEXFREEWINSTATIONMODULESPROC GetExtFreeWinStationModulesProc() { return m_lpfnWAExFreeWinStationModules; }

        void BeginOutstandingThread() { ::InterlockedIncrement(&m_OutstandingThreads); }
        void EndOutstandingThread()     { ::InterlockedDecrement(&m_OutstandingThreads); }

        // make this guy public for speed ?
        TCHAR m_szSystemConsole[WINSTATIONNAME_LENGTH+1];
        // make this guy public so the MainFrm can get at it
        WINDOWPLACEMENT m_Placement;

private:
        void ReadPreferences();
        void WritePreferences();
        BOOL IsBrowserRunning();
        LONG m_OutstandingThreads;      // the number of outstanding threads
        TCHAR m_CurrentUserName[USERNAME_LENGTH+1];
        WINSTATIONNAME m_CurrentWinStationName;
        TCHAR m_CurrentServerName[MAX_COMPUTERNAME_LENGTH + 1];
        ULONG m_CurrentLogonId;
        ULONG m_CurrentWSFlags;
        BOOL m_Admin;                           // does the user have Admin privileges?
        BOOL m_Picasso;                 // are we running under Picasso?
        UINT m_ShowSystemProcesses;
        UINT m_ShowAllServers;
        int m_ShadowHotkeyKey;
        DWORD m_ShadowHotkeyShift;
        int m_TreeWidth;
        HINSTANCE m_hExtensionDLL;      // handle to the extension DLL if loaded

        // functions in the extension DLL
        LPFNEXSTARTUPPROC m_lpfnWAExStart;
        LPFNEXSHUTDOWNPROC m_lpfnWAExEnd;
        LPFNEXENUMERATEPROC m_lpfnWAExServerEnumerate;
        LPFNEXWINSTATIONINITPROC m_lpfnWAExWinStationInit;
        LPFNEXWINSTATIONINFOPROC m_lpfnWAExWinStationInfo;
        LPFNEXWINSTATIONCLEANUPPROC m_lpfnWAExWinStationCleanup;
        LPFNEXSERVERINITPROC m_lpfnWAExServerInit;
        LPFNEXSERVERCLEANUPPROC m_lpfnWAExServerCleanup;
        LPFNEXGETSERVERINFOPROC m_lpfnWAExGetServerInfo;
        LPFNEXGETSERVERLICENSESPROC m_lpfnWAExGetServerLicenses;
        LPFNEXSERVEREVENTPROC m_lpfnWAExServerEvent;
        LPFNEXGETGLOBALINFOPROC m_lpfnWAExGetGlobalInfo;
        LPFNEXGETWINSTATIONINFOPROC m_lpfnWAExGetWinStationInfo;
        LPFNEXGETWINSTATIONMODULESPROC m_lpfnWAExGetWinStationModules;
        LPFNEXFREESERVERLICENSESPROC m_lpfnWAExFreeServerLicenses;
        LPFNEXFREEWINSTATIONMODULESPROC m_lpfnWAExFreeWinStationModules;

        // user preferences
        UINT m_Confirmation;            // ask user for confirmation
        UINT m_SavePreferences;         // save preferences upon exit
        UINT m_ProcessListRefreshTime;
        UINT m_StatusRefreshTime;

        CDocument *m_Document;

// Overrides
        // ClassWizard generated virtual function overrides
        //{{AFX_VIRTUAL(CWinAdminApp)
        public:
        virtual BOOL InitInstance();
        virtual int ExitInstance();
        //}}AFX_VIRTUAL

// Implementation

        //{{AFX_MSG(CWinAdminApp)
        afx_msg void OnAppAbout();
                // NOTE - the ClassWizard will add and remove member functions here.
                //    DO NOT EDIT what you see in these blocks of generated code !
        //}}AFX_MSG
        DECLARE_MESSAGE_MAP()
};

enum NODETYPE {
        NODE_ALL_SERVERS,
        NODE_DOMAIN,
        NODE_SERVER,
        NODE_WINSTATION,
        NODE_PUBLISHED_APPS,
        NODE_APPLICATION,
        NODE_APP_SERVER,

        NODE_FAV_LIST,
        NODE_THIS_COMP,
        NODE_NONE
};

class CNodeType : public CObject
{
public:
    CNodeType( NODETYPE m )
    {
        m_nodetype = m;
    }

    ~CNodeType()
    {
        ODS( L"CNodeType I'm going away\n" );
    }

    NODETYPE m_nodetype;
};

class CTreeNode : public CObject
{
public:
        // constructor
        CTreeNode(NODETYPE NodeType, CObject* pObject) { m_NodeType = NodeType; m_pTreeObject = pObject; }
        // Returns the node type
        NODETYPE GetNodeType() { return m_NodeType; }
        // Returns the object pointed to by this node
        CObject *GetTreeObject() { return m_pTreeObject; }
        // Returns the sort order stored in the object
        ULONG GetSortOrder() { return m_SortOrder; }
        // Sets the sort order stored with the object
        void SetSortOrder(ULONG order) { m_SortOrder = order; }

        virtual ~CTreeNode( )
        {
            if( m_NodeType == NODE_FAV_LIST ||  m_NodeType == NODE_THIS_COMP )
            {
                if( m_pTreeObject != NULL )
                {
                    delete m_pTreeObject;
                }
                
            }            
        }

private:
        NODETYPE m_NodeType;
        CObject* m_pTreeObject;
        ULONG m_SortOrder;
};

// structure passed to the Server's BackgroundThreadProc
typedef struct _ServerProcInfo {
        CDocument *pDoc;
        CServer *pServer;
} ServerProcInfo;

// structure for storing User SID
class CUserSid : public CObject
{
public:
        USHORT m_SidCrc;
        TCHAR m_UserName[USERNAME_LENGTH+1];
};

// Information we get from the registry of the server
typedef struct _ServerRegistryInfo {
        ULONG InstallDate;
        TCHAR ServicePackLevel[128];
        TCHAR MSVersion[128];
        DWORD MSVersionNum;
        TCHAR MSBuild[128];
    TCHAR MSProductName[128];
        TCHAR CTXProductName[128];
        TCHAR CTXVersion[128];
        DWORD CTXVersionNum;
        TCHAR CTXBuild[128];
} ServerRegistryInfo;


class CHotfix : public CObject
{
public:
        TCHAR m_Name[10];
        TCHAR m_InstalledBy[USERNAME_LENGTH + 1];
        ULONG m_InstalledOn;
        ULONG m_Valid;
        CServer *m_pServer;
};

typedef struct _EncLevel {
    WORD StringID;
    DWORD RegistryValue;
    WORD Flags;
} EncryptionLevel;

typedef LONG (WINAPI *LPFNEXTENCRYPTIONLEVELSPROC) (WDNAME *pWdName, EncryptionLevel **);

class CWd : public CObject
{
public:
        // constructor
        CWd(PWDCONFIG2 pWdConfig, PWDNAME pRegistryName);
        // destructor
        ~CWd();

        BOOL GetEncryptionLevelString(DWORD Value, CString *pString);
        TCHAR *GetName() { return m_WdName; }
        TCHAR *GetRegistryName() { return m_RegistryName; }

private:
        HINSTANCE   m_hExtensionDLL;
        WDNAME m_WdName;
        WDNAME m_RegistryName;
        LPFNEXTENCRYPTIONLEVELSPROC m_lpfnExtEncryptionLevels;
    EncryptionLevel *m_pEncryptionLevels;
    LONG m_NumEncryptionLevels;
};

// structure passed to a Domain's background thread process
typedef struct _DomainProcInfo {
    LPVOID pDoc;
    CDomain *pDomain;
} DomainProcInfo;

// Flags for CDomain objects
const ULONG DF_CURRENT_DOMAIN           = 0x00000001;

// States of CDomain objects
enum DOMAIN_STATE {
        DS_NONE,                                // seed value for m_State and m_PreviousState
        DS_NOT_ENUMERATING,             // not enumerating (m_pBackgroundThread == NULL)
        DS_INITIAL_ENUMERATION, // enumerating servers for the first time
        DS_ENUMERATING,                 // enumerating
        DS_STOPPED_ENUMERATING, // no longer enumerating
};

class CDomain : public CObject
{
public:
        // constructor
        CDomain(TCHAR *name);
        // destructor
        ~CDomain();

    TCHAR *GetName() { return m_Name; }

        // Returns the state of this domain object
        DOMAIN_STATE GetState() { return m_State; }
        // Sets the state of this domain object
        void SetState(DOMAIN_STATE State);
        // Returns the previous state of this domain object
        DOMAIN_STATE GetPreviousState() { return m_PreviousState; }
        // Returns TRUE if m_State is set to a given state
        BOOLEAN IsState(DOMAIN_STATE State) { return (m_State == State); }
        // Returns TRUE if m_PreviousState is set to a given state
        BOOLEAN IsPreviousState(DOMAIN_STATE State) { return (m_PreviousState == State); }

        // Returns the tree item handle
        HTREEITEM GetTreeItem() { return m_hTreeItem; }
        // Sets the tree item handle
        void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }

        BOOLEAN IsCurrentDomain() { return (m_Flags & DF_CURRENT_DOMAIN) > 0; }
        void SetCurrentDomain() { m_Flags |= DF_CURRENT_DOMAIN; }
        void ClearCurrentDomain() { m_Flags &= ~DF_CURRENT_DOMAIN; }

        BOOL StartEnumerating();
        void StopEnumerating();
        void SetEnumEvent() { if(m_pBackgroundThread) m_WakeUpEvent.SetEvent(); }

        void LockBackgroundThread() { m_ThreadCriticalSection.Lock(); }
        void UnlockBackgroundThread() { m_ThreadCriticalSection.Unlock(); }

        // returns TRUE as long as the background thread should keep running
        BOOL ShouldBackgroundContinue() { return m_BackgroundContinue; }

    void ClearBackgroundContinue() { m_BackgroundContinue = FALSE; }

    // Returns the pointer to the domain's background thread
    CWinThread *GetThreadPointer() { return m_pBackgroundThread; }

        LPWSTR EnumHydraServers( /*LPWSTR pDomain,*/ DWORD verMajor, DWORD verMinor );

        void CreateServers(LPWSTR pBuffer, LPVOID pDoc);

        // Connect to all servers in this Domain
        void ConnectAllServers();

        // Disconnect from all servers in this Domain
        void DisconnectAllServers();

private:

        // the state of the domain object
        DOMAIN_STATE m_State;
        DOMAIN_STATE m_PreviousState;
        // the name of the domain
    TCHAR m_Name[50];
    HTREEITEM m_hTreeItem;

        // Background thread to update document when servers
        // appear and disapper
        // Called with AfxBeginThread
        static UINT BackgroundThreadProc(LPVOID);
        CWinThread *m_pBackgroundThread;
        BOOL m_BackgroundContinue;
        // Event to wakeup background thread so that
        // he can exit (WaitForSingleEvent instead of Sleep)
        CEvent m_WakeUpEvent;
        // Critical section to protect accesses to m_pBackgroundThread
        CCriticalSection m_ThreadCriticalSection;

    ULONG m_Flags;

};


// Flags for CServer objects
const ULONG SF_BACKGROUND_FOUND     = 0x00000001;
const ULONG SF_SERVER_INACTIVE      = 0x00000002;
const ULONG SF_REGISTRY_INFO        = 0x00000004;
const ULONG SF_HANDLE_GOOD          = 0x00000008;
const ULONG SF_SELECTED             = 0x00000010;
const ULONG SF_UNDEFINED_0040       = 0x00000020;
const ULONG SF_UNDEFINED_0080       = 0x00000040;
const ULONG SF_LOST_CONNECTION      = 0x00000080;
const ULONG SF_FOUND_LATER          = 0x00000100;
const ULONG SF_WINFRAME             = 0x00000200;
const ULONG SF_CONNECTED            = 0x00000400;

// How many times we will let a load level query timeout
// before we set it to N/A
const USHORT MAX_LL_TIMEOUTS = 10;

// States of CServer objects
enum SERVER_STATE {
        SS_NONE,                        // seed value for m_State and m_PreviousState
        SS_NOT_CONNECTED,       // not connected yet or disconnected
        SS_OPENED,                      // opened RPC connection
        SS_GETTING_INFO,        // getting information about the server
        SS_GOOD,                        // server information is good
        SS_DISCONNECTING,       // in the process of disconnecting
        SS_BAD                          // could not open the server
};


class CServer : public CObject
{
public:

    // constructor
    CServer(CDomain *pDomain, TCHAR *name, BOOL bFoundLater, BOOL bConnect);        // FoundLater is TRUE if found as new server after initial server enum
    // destructor
    ~CServer();

    // Functions to check,set,and clear m_ServerFlags
    BOOLEAN IsServerSane() { return (m_State != SS_BAD); }

    BOOLEAN IsManualFind( ) { return m_fManualFind; }
    void SetManualFind( ) { m_fManualFind = TRUE; }
    void ClearManualFind( ) { m_fManualFind = FALSE; }

    BOOLEAN IsBackgroundFound() { return (m_ServerFlags & SF_BACKGROUND_FOUND) > 0; }
    void SetBackgroundFound() { m_ServerFlags |= SF_BACKGROUND_FOUND; }
    void ClearBackgroundFound() { m_ServerFlags &= ~SF_BACKGROUND_FOUND; }

    BOOLEAN IsServerInactive() { return (m_ServerFlags & SF_SERVER_INACTIVE) > 0; }
    void SetServerInactive() { m_ServerFlags |= SF_SERVER_INACTIVE;  m_BackgroundContinue = FALSE; }
    void ClearServerInactive() { m_ServerFlags &= ~SF_SERVER_INACTIVE; }
    BOOLEAN IsServerActive() { return (m_ServerFlags & SF_SERVER_INACTIVE) == 0; }

    BOOLEAN IsRegistryInfoValid() { return (m_ServerFlags & SF_REGISTRY_INFO) > 0; }
    void SetRegistryInfoValid() { m_ServerFlags |= SF_REGISTRY_INFO; }
    void ClearRegistryInfoValid() { m_ServerFlags &= ~SF_REGISTRY_INFO; }

    BOOLEAN IsHandleGood() { return (m_ServerFlags & SF_HANDLE_GOOD) > 0; }
    void SetHandleGood() { m_ServerFlags |= SF_HANDLE_GOOD; }
    void ClearHandleGood() { m_ServerFlags &= ~SF_HANDLE_GOOD; }

    BOOLEAN IsSelected() { return (m_ServerFlags & SF_SELECTED) > 0; }
    void SetSelected() { m_ServerFlags |= SF_SELECTED; }
    void ClearSelected() { m_ServerFlags &= ~SF_SELECTED; }

    BOOLEAN HasLostConnection() { return (m_ServerFlags & SF_LOST_CONNECTION) > 0; }
    void SetLostConnection() { m_ServerFlags |= SF_LOST_CONNECTION; }
    void ClearLostConnection() { m_ServerFlags &= ~SF_LOST_CONNECTION; }

    BOOLEAN WasFoundLater() { return (m_ServerFlags & SF_FOUND_LATER) > 0; }
    void SetFoundLater() { m_ServerFlags |= SF_FOUND_LATER; }
    void ClearFoundLater() { m_ServerFlags &= ~SF_FOUND_LATER; }

    BOOLEAN IsWinFrame() { return (m_ServerFlags & SF_WINFRAME) > 0; }
    void SetWinFrame() { m_ServerFlags |= SF_WINFRAME; }
    void ClearWinFrame() { m_ServerFlags &= ~SF_WINFRAME; }

    // Returns the state of this server object
    SERVER_STATE GetState() { return m_State; }
    // Sets the state of this server object
    void SetState(SERVER_STATE State);
    // Returns the previous state of this server object
    SERVER_STATE GetPreviousState() { return m_PreviousState; }
    // Returns TRUE if m_State is set to a given state
    BOOLEAN IsState(SERVER_STATE State) { return (m_State == State); }
    // Returns TRUE if m_PreviousState is set to a given state
    BOOLEAN IsPreviousState(SERVER_STATE State) { return (m_PreviousState == State); }
    // Add a WinStation to WinStationList in sorted order
    void AddWinStation(CWinStation *pWinStation);
    // Returns a pointer to the WinStation linked list
    CObList *GetWinStationList() { return &m_WinStationList; }
    // Locks the WinStation linked list
    void LockWinStationList() { m_WinStationListCriticalSection.Lock(); }
    // Unlocks the WinStation linked list
    void UnlockWinStationList() { m_WinStationListCriticalSection.Unlock(); }

    void LockThreadAlive() { m_ThreadCriticalSection.Lock(); }
    void UnlockThreadAlive() { m_ThreadCriticalSection.Unlock(); }
    void SetThreadAlive() { LockThreadAlive(); m_bThreadAlive = TRUE; UnlockThreadAlive(); }
    void ClearThreadAlive() { LockThreadAlive(); m_bThreadAlive = FALSE; UnlockThreadAlive(); }

    // Returns a pointer to the Process linked list
    CObList *GetProcessList() { return &m_ProcessList; }
    // Locks the Process linked list
    void LockProcessList() { m_ProcessListCriticalSection.Lock(); }
    // Unlocks the Process linked list
    void UnlockProcessList() { m_ProcessListCriticalSection.Unlock(); }

    // Returns a pointer to the License linked list
    CObList *GetLicenseList() { return &m_LicenseList; }
    // Locks the License linked list
    void LockLicenseList() { m_LicenseListCriticalSection.Lock(); }
    // Unlocks the License linked list
    void UnlockLicenseList() { m_LicenseListCriticalSection.Unlock(); }

    // Returns a pointer to the User Sid linked list
    CObList *GetUserSidList() { return &m_UserSidList; }
    // Returns a pointer to the Hotfix linked list
    CObList *GetHotfixList() { return &m_HotfixList; }
    // Get the server's handle
    HANDLE GetHandle() { return m_Handle; }
    // Set the handle
    void SetHandle(HANDLE hIn) { m_Handle = hIn; }
    // Go get detailed information about the server
    void DoDetail();
    // Get this server's addresses from the browser
    void QueryAddresses();
    // Enumerate this server's processes
    BOOL EnumerateProcesses();
    // Clear out the list of processes
    void ClearProcesses();
    // Get the name of the server
    TCHAR *GetName() { return m_Name; }
    // Returns TRUE if this is the server that the app is being run from
    BOOL IsCurrentServer() { return (lstrcmpi(m_Name, ((CWinAdminApp*)AfxGetApp())->GetCurrentServerName()) == 0); }
    // Clears the WAF_SELECTED bit in all of this server's lists
    void ClearAllSelected();
    // returns TRUE as long as the background thread should keep running
    BOOL ShouldBackgroundContinue() { return m_BackgroundContinue; }
    // turns off the background continue boolean
    void ClearBackgroundContinue() { m_BackgroundContinue = FALSE; }
    // returns a pointer to a CWinStation from m_WinStationList
    CWinStation *FindWinStationById(ULONG Id);
    // returns a pointer to a CProcess from m_ProcessList given a PID
    CProcess *FindProcessByPID(ULONG Pid);
    // returns the number of connected WinStations
    ULONG GetNumWinStations() { return m_NumWinStations; }
    // Sets the number of connected WinStations
    void SetNumWinStations(ULONG num) { m_NumWinStations = num; }
    // Go out and fill in the registry info structure
    BOOL BuildRegistryInfo();
    // Returns the Install Date
    ULONG GetInstallDate() { return m_pRegistryInfo->InstallDate; }
    // Returns the Service Pack Level
    TCHAR *GetServicePackLevel() { return m_pRegistryInfo->ServicePackLevel; }
    // Returns the handle to this server's tree item
    TCHAR *GetMSVersion() { return m_pRegistryInfo->MSVersion; }
    // Returns the MS product version number (binary)
    DWORD GetMSVersionNum() { return m_pRegistryInfo->MSVersionNum; }
    // Returns the MS product build
    TCHAR *GetMSBuild() { return m_pRegistryInfo->MSBuild; }
    // Returns the MS product name
    TCHAR *GetMSProductName() { return m_pRegistryInfo->MSProductName; }
    // Returns the 'Citrix' product name
    TCHAR *GetCTXProductName() { return m_pRegistryInfo->CTXProductName; }
    // Returns the 'Citrix' product version
    TCHAR *GetCTXVersion() { return m_pRegistryInfo->CTXVersion; }
    // Returns the 'Citrix' product version number (binary)
    DWORD GetCTXVersionNum() { return m_pRegistryInfo->CTXVersionNum; }
    // Returns the 'Citrix' product build
    TCHAR *GetCTXBuild() { return m_pRegistryInfo->CTXBuild; }
   
    // Sets the pointer to the info from the extension DLL
    void SetExtensionInfo(void *p) { m_pExtensionInfo = p; }
    // Returns the pointer to the info from the extension DLL
    void *GetExtensionInfo() { return m_pExtensionInfo; }
    // Returns a pointer to the info from the extension DLL
    ExtServerInfo *GetExtendedInfo() { return m_pExtServerInfo; }

    // Manipulate the number selected counts
    UINT GetNumWinStationsSelected() { return m_NumWinStationsSelected; }
    UINT GetNumProcessesSelected() { return m_NumProcessesSelected; }
    void IncrementNumWinStationsSelected() { m_NumWinStationsSelected++; }
    void IncrementNumProcessesSelected() { m_NumProcessesSelected++; }
    void DecrementNumWinStationsSelected() { if(m_NumWinStationsSelected) m_NumWinStationsSelected--; }
    void DecrementNumProcessesSelected() { if(m_NumProcessesSelected) m_NumProcessesSelected--; }

    void RemoveWinStationProcesses(CWinStation *pWinStation); // remove all the processes for a given WinStation
    void QueryLicenses();
    CDomain *GetDomain() { return m_pDomain; }
    // Returns the pointer to the server's background thread
    CWinThread *GetThreadPointer() { return m_pBackgroundThread; }
    BOOL Connect();
    void Disconnect();
    
    // Returns the tree item handle
    HTREEITEM GetTreeItem() { return m_hTreeItem; }
    HTREEITEM GetTreeItemFromFav( ) { return m_hFavTree; }
    HTREEITEM GetTreeItemFromThisComputer( ) { return m_hThisServer; }

    // Sets the tree item handle
    void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }
    void SetTreeItemForFav( HTREEITEM handle ) { m_hFavTree = handle; }
    void SetTreeItemForThisComputer( HTREEITEM handle ) { m_hThisServer = handle; }


private:
    void AddLicense(CLicense *pNewLicense);

    // the state of the server object
    SERVER_STATE m_State;
    SERVER_STATE m_PreviousState;
    // the name of the server
    TCHAR m_Name[50];
    // Number of WinStations (store here for sorting)
    ULONG m_NumWinStations;
    // Handle to the tree item for this server in the tree view
    HTREEITEM m_hThisServer;
    HTREEITEM m_hTreeItem;
    HTREEITEM m_hFavTree;
    // Which domain this server is in
    CDomain *m_pDomain;

    // handle from WinStationOpenServer
    HANDLE m_Handle;

    CObList m_WinStationList;
    CCriticalSection m_WinStationListCriticalSection;

    CObList m_ProcessList;
    CCriticalSection m_ProcessListCriticalSection;

    CObList m_LicenseList;
    CCriticalSection m_LicenseListCriticalSection;

    CObList m_UserSidList;
    CObList m_HotfixList;

    // Pointer to registry info structure
    ServerRegistryInfo *m_pRegistryInfo;

    // Background thread to update document when WinStations
    // appear, disappear, and change state
    // Called with AfxBeginThread
    static UINT BackgroundThreadProc(LPVOID);
    CWinThread *m_pBackgroundThread;
    BOOL m_BackgroundContinue;
    // We need a critical section to wrap accesses to m_bThreadAlive
    CCriticalSection m_ThreadCriticalSection;
    BOOL m_bThreadAlive;

    // Keep track of how many of each thing are selected
    UINT m_NumWinStationsSelected;
    UINT m_NumProcessesSelected;

    ULONG m_ServerFlags;

    BOOLEAN m_fManualFind;

    // Pointer to information stored by the extension DLL
    void *m_pExtensionInfo;
    // Pointer to extended info from the extension DLL
    ExtServerInfo *m_pExtServerInfo;
};


class CLicense : public CObject
{
public:
        // constructor
        CLicense(CServer *pServer, ExtLicenseInfo *pLicenseInfo);
        // Return the serial number (what we sort on)
        TCHAR *GetSerialNumber() { return m_RegSerialNumber; }
        // Return the license number (what we display)
        TCHAR *GetLicenseNumber() { return m_LicenseNumber; }
        // Return the license class
        LICENSECLASS GetClass() { return m_Class; }
        // Return the description
        TCHAR *GetDescription() { return m_Description; }
        // Return the local count
        ULONG GetLocalCount() { return ((m_PoolCount == 0xFFFFFFFF) ? m_LicenseCount : m_LicenseCount - m_PoolCount); }
        // Return the pooled count
        ULONG GetPoolCount() { return ((m_PoolCount == 0xFFFFFFFF) ? 0 : m_PoolCount); }
        // Return the total count
        ULONG GetTotalCount() { return m_LicenseCount; }
        // Return TRUE if this license is registers
        BOOLEAN IsRegistered() { return((m_Flags & ELF_REGISTERED) > 0); }
        // Return TRUE if pooling is enabled
        BOOLEAN IsPoolingEnabled() { return(m_PoolCount != 0xFFFFFFFF); }
        // Returns a pointer to the server this license is for
        CServer *GetServer() { return m_pServer; }

private:
        LICENSECLASS m_Class;
        ULONG m_LicenseCount;
        ULONG m_PoolLicenseCount;
        WCHAR m_RegSerialNumber[26];
        WCHAR m_LicenseNumber[36];
        WCHAR m_Description[65];
        ULONG m_Flags;
        ULONG m_PoolCount;
        CServer *m_pServer;
};


typedef struct _MessageParms {
        TCHAR MessageTitle[MSG_TITLE_LENGTH + 1];
        TCHAR MessageBody[MSG_MESSAGE_LENGTH + 1];
        CWinStation* pWinStation;
} MessageParms;


typedef struct _ResetParms {
        CWinStation *pWinStation;
        BOOL bReset;    // TRUE if reset, FALSE if logoff
} ResetParms;


// Flags for CWinStation objects
const ULONG WF_SELECTED                 = 0x00000001;
const ULONG WF_CAN_BE_SHADOWED          = 0x00000002;
const ULONG WF_DIRECT_ASYNC             = 0x00000004;
const ULONG WF_CURRENT                  = 0x00000008;
const ULONG WF_HAS_USER                 = 0x00000010;
const ULONG WF_ADDITIONAL_DONE          = 0x00000020;
const ULONG WF_QUERIES_SUCCESSFUL       = 0x00000040;
const ULONG WF_CHANGED                  = 0x00000080;   // Changed during last enumeration
const ULONG WF_NEW                      = 0x00000100;   // New this enumeration


class CWinStation : public CObject
{
public:
        // constructor
        CWinStation(CServer *pServer, PLOGONID pLogonId);
        // destructor
        ~CWinStation();
        // Updates this WinStation with new data from another CWinStation
        BOOL Update(CWinStation *pWinStation);
        // Returns a pointer to this guy's server
        CServer *GetServer() { return m_pServer; }
        // Returns the logon Id
        ULONG GetLogonId() { return m_LogonId; }
        // Returns the name of the WinStation
        PWINSTATIONNAME GetName() { return m_Name; }
        // Sets the name
        void SetName(PWINSTATIONNAME name) { wcscpy(m_Name, name); }
        // Returns the state
        WINSTATIONSTATECLASS GetState() { return m_State; }
        // Sets the state
        void SetState(WINSTATIONSTATECLASS state) { m_State = state; }
        // Returns TRUE if m_State is set to a given state
        BOOLEAN IsState(WINSTATIONSTATECLASS state) { return (m_State == state); }
    // Returns the sort order
        ULONG GetSortOrder() { return m_SortOrder; }
        // Sets the sort order
        void SetSortOrder(ULONG sort) { m_SortOrder = sort; }
        // Returns the comment
        TCHAR *GetComment() { return m_Comment; }
        // Sets the comment
        void SetComment(TCHAR *comment) { wcscpy(m_Comment, comment); }
        // Returns the user name
        TCHAR *GetUserName() { return m_UserName; }
        // Sets the user name
        void SetUserName(TCHAR *name) { wcscpy(m_UserName, name); }
        // Returns the SdClass
        SDCLASS GetSdClass() { return m_SdClass; }
        // Sets the SdClass
        void SetSdClass(SDCLASS pd) { m_SdClass = pd; }
        // Returns the Logon Time
        LARGE_INTEGER GetLogonTime() { return m_LogonTime; }
        // Sets the Logon Time
        void SetLogonTime(LARGE_INTEGER t) { m_LogonTime = t; }
        // Returns the Last Input Time
        LARGE_INTEGER GetLastInputTime() { return m_LastInputTime; }
        // Sets the Last Input Time
        void SetLastInputTime(LARGE_INTEGER t) { m_LastInputTime = t; }
        // Returns the Current Time
        LARGE_INTEGER GetCurrentTime() { return m_CurrentTime; }
        // Set the Current Time
        void SetCurrentTime(LARGE_INTEGER t) { m_CurrentTime = t; }
        // Returns the IdleTime
        ELAPSEDTIME GetIdleTime() { return m_IdleTime; }
        // Sets the IdleTime variable
        void SetIdleTime(ELAPSEDTIME it) { m_IdleTime = it; }
        // Returns the WdName
        PWDNAME GetWdName() { return m_WdName; }
        // Sets the WdName
        void SetWdName(PWDNAME wdname) { wcscpy(m_WdName, wdname); }
        // Returns the Wd Structure
        CWd *GetWd() { return m_pWd; }
        // Sets the Wd Structure
        void SetWd(CWd *pwd) { m_pWd = pwd; }
        // Returns the PdName
        PPDNAME GetPdName() { return m_PdName; }
        // Returns the Client Name
        TCHAR *GetClientName() { return m_ClientName; }
        // Sets the Client Name
        void SetClientName(TCHAR *name) { wcscpy(m_ClientName, name); }
        //returns the client digital product id
                TCHAR* GetClientDigProductId() { return m_clientDigProductId; }
        //sets the client digital product id
        void SetClientDigProductId( TCHAR* prodid) { wcscpy(m_clientDigProductId, prodid); }
        // Returns the Client Build Number
        ULONG GetClientBuildNumber() { return m_ClientBuildNumber; }
        // Returns the Client Directory
        TCHAR *GetClientDir() { return m_ClientDir; }
        // Returns the Modem Name
        TCHAR *GetModemName() { return m_ModemName; }
        // Returns the Client License
        TCHAR *GetClientLicense() { return m_ClientLicense; }
        // Returns the Client Product Id
        USHORT GetClientProductId() { return m_ClientProductId; }
        // Returns the Client Serial Number
        ULONG GetClientSerialNumber() { return m_ClientSerialNumber; }
        // Returns the Client Address
        TCHAR *GetClientAddress() { return m_ClientAddress; }
        // Returns the number of host buffers
        USHORT GetHostBuffers() { return m_HostBuffers; }
        // Returns the number of client buffers
        USHORT GetClientBuffers() { return m_ClientBuffers; }
        // Returns the buffer length
        USHORT GetBufferLength() { return m_BufferLength; }
    // Gets additional information about the WinStation
    void QueryAdditionalInformation();
        // Shadow this WinStation
        void Shadow();
        // connect to this WinStation
        void Connect(BOOL bUser);
        // show status dialog
        void ShowStatus();
        // Are there outstanding threads?
        BOOL HasOutstandingThreads() { return(m_OutstandingThreads > 0); }
        // Is this WinStation down?
        BOOL IsDown() { return(m_State == State_Down || m_State == State_Init); }
        // Is this WinStation connected?
        BOOL IsConnected() { return(m_State == State_Connected || m_State == State_Active); }
        // Is this WinStation disconnected?
        BOOL IsDisconnected() { return(m_State == State_Disconnected); }
        // Is this WinStation active?
        BOOL IsActive() { return(m_State == State_Active); }
        // Is this WinStation idle?
        BOOL IsIdle() { return(m_State == State_Idle); }
        // Is this WinStation a listener?
        BOOL IsListener() { return(m_State == State_Listen); }
        // Is this the system console
        BOOL IsSystemConsole() { return(0 == lstrcmpi(m_Name, ((CWinAdminApp*)AfxGetApp())->m_szSystemConsole)); }
        // Returns TRUE if this WinStation is on the current server
        BOOL IsOnCurrentServer() { return m_pServer->IsCurrentServer(); }
        // Returns TRUE if the current user is logged in on this WinStation
        BOOL IsCurrentUser() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }
        //BOOL IsCurrentUser() { return(m_pServer->IsCurrentServer() && (lstrcmpi(m_UserName, ((CWinAdminApp*)AfxGetApp())->GetCurrentUserName()) == 0)); }
        // Returns TRUE if this is the current WinStation
        BOOL IsCurrentWinStation() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }
        // Returns the handle to this WinStations's tree item
        HTREEITEM GetTreeItem() { return m_hTreeItem; }
        HTREEITEM GetTreeItemFromFav( ) { return m_hFavTree; }
        HTREEITEM GetTreeItemFromThisComputer( ) { return m_hTreeThisComputer; }
        // Sets the tree item handle
        void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }
        void SetTreeItemForFav( HTREEITEM handle ) { m_hFavTree = handle; }
        void SetTreeItemForThisComputer( HTREEITEM handle ) { m_hTreeThisComputer = handle; }
        // Returns the number of colors
        TCHAR *GetColors() { return m_Colors; }
        // Returns the vertical resolution
        USHORT GetVRes() { return m_VRes; }
        // Returns the horizontal resolution
        USHORT GetHRes() { return m_HRes; }
    // Returns the protocol
    USHORT GetProtocolType() { return m_ProtocolType; }
    // Returns the encryption level
    BYTE GetEncryptionLevel() { return m_EncryptionLevel; }
    // Sets the encryption level
    void SetEncryptionLevel(BYTE level) { m_EncryptionLevel = level; }

        // Fills in the CString with the description of the Encryption level
        BOOL GetEncryptionLevelString(CString *pString) {
                if(m_pWd) {
                        return m_pWd->GetEncryptionLevelString(m_EncryptionLevel, pString);
                }
                else return FALSE;
        }
        // Returns the name of the Wd in the registry
        TCHAR *GetWdRegistryName() { return (m_pWd) ? m_pWd->GetRegistryName() : NULL; }

        // Returns the time of the last update to this WinStation's data
        clock_t GetLastUpdateClock() { return m_LastUpdateClock; }
        void SetLastUpdateClock() { m_LastUpdateClock = clock(); }

    // Is this an ICA WinStation?
    BOOL IsICA() { return(m_ProtocolType == PROTOCOL_ICA); }

        // Can this WinStation be shadowed
        BOOL CanBeShadowed() { return((m_WinStationFlags & WF_CAN_BE_SHADOWED) > 0); }
        void SetCanBeShadowed() { m_WinStationFlags |= WF_CAN_BE_SHADOWED; }
        void ClearCanBeShadowed() { m_WinStationFlags &= ~WF_CAN_BE_SHADOWED; }

        BOOLEAN IsDirectAsync() { return (m_WinStationFlags & WF_DIRECT_ASYNC) > 0; }
        void SetDirectAsync() { m_WinStationFlags |= WF_DIRECT_ASYNC; }
        void ClearDirectAsync() { m_WinStationFlags &= ~WF_DIRECT_ASYNC; }

        BOOLEAN IsCurrent() { return (m_WinStationFlags & WF_CURRENT) > 0; }
        void SetCurrent() { m_WinStationFlags |= WF_CURRENT; }
        void ClearCurrent() { m_WinStationFlags &= ~WF_CURRENT; }

        BOOLEAN IsChanged() { return (m_WinStationFlags & WF_CHANGED) > 0; }
        void SetChanged() { m_WinStationFlags |= WF_CHANGED; }
        void ClearChanged() { m_WinStationFlags &= ~WF_CHANGED; }

        BOOLEAN IsNew() { return (m_WinStationFlags & WF_NEW) > 0; }
        void SetNew() { m_WinStationFlags |= WF_NEW; }
        void ClearNew() { m_WinStationFlags &= ~WF_NEW; }

        BOOLEAN IsSelected() { return (m_WinStationFlags & WF_SELECTED) > 0; }
        void SetSelected() 
        { 
            if (!IsSelected()) 
            { 
                m_WinStationFlags |= WF_SELECTED; 
                m_pServer->IncrementNumWinStationsSelected(); 
            } 
        }
        
        void ClearSelected() 
        { 
            if (IsSelected()) 
            {
                m_WinStationFlags &= ~WF_SELECTED; 
                m_pServer->DecrementNumWinStationsSelected(); 
            }
        }

        BOOLEAN HasUser() { return (m_WinStationFlags & WF_HAS_USER) > 0; }
        void SetHasUser() { m_WinStationFlags |= WF_HAS_USER; }
        void ClearHasUser() { m_WinStationFlags &= ~WF_HAS_USER; }

        BOOLEAN AdditionalDone() { return (m_WinStationFlags & WF_ADDITIONAL_DONE) > 0; }
        void SetAdditionalDone() { m_WinStationFlags |= WF_ADDITIONAL_DONE; }
        void ClearAdditionalDone() { m_WinStationFlags &= ~WF_ADDITIONAL_DONE; }

        BOOL QueriesSuccessful() { return (m_WinStationFlags & WF_QUERIES_SUCCESSFUL) > 0; }
        void SetQueriesSuccessful() { m_WinStationFlags |= WF_QUERIES_SUCCESSFUL; }
        void ClearQueriesSuccessful() { m_WinStationFlags &= ~WF_QUERIES_SUCCESSFUL; }

        // Sets the pointer to the info from the extension DLL
        void SetExtensionInfo(void *p) { m_pExtensionInfo = p; }
        // Returns the pointer to the info from the extension DLL
        void *GetExtensionInfo() { return m_pExtensionInfo; }
    // Sets the pointer to the info from the extension DLL
    void SetExtendedInfo(ExtWinStationInfo *p) { m_pExtWinStationInfo = p; }
        // Returns a pointer to the info from the extension DLL
        ExtWinStationInfo *GetExtendedInfo() { return m_pExtWinStationInfo; }
        // Returns a pointer to the module info from the extension DLL
        ExtModuleInfo *GetExtModuleInfo() { return m_pExtModuleInfo; }
    // Sets the pointer to the module info from the extension DLL
    void SetExtModuleInfo(ExtModuleInfo *m) { m_pExtModuleInfo = m; }
        // Returns the number of modules
        ULONG GetNumModules() { return m_NumModules; }

        void BeginOutstandingThread() {
                                ::InterlockedIncrement(&m_OutstandingThreads);
                                //((CWinAdminApp*)AfxGetApp())->BeginOutStandingThread());
        }

        void EndOutstandingThread()     {
                                ::InterlockedDecrement(&m_OutstandingThreads);
                                //((CWinAdminApp*)AfxGetApp())->EndOutStandingThread());
        }

        // static member function to send a message to a WinStation
        // Called with AfxBeginThread
        static UINT SendMessage(LPVOID);
        // static member function to disconnect a WinStation
        // Called with AfxBeginThread
        static UINT Disconnect(LPVOID);
        // static member function to reset a WinStation
        // Called with AfxBeginThread
        static UINT Reset(LPVOID);

private:
        CServer* m_pServer;
        CWd* m_pWd;
        ULONG m_LogonId;
        WINSTATIONNAME m_Name;
        WINSTATIONSTATECLASS m_State;
        ULONG m_SortOrder;
        TCHAR m_Comment[WINSTATIONCOMMENT_LENGTH + 1];
        TCHAR m_UserName[USERNAME_LENGTH + 1];
        SDCLASS m_SdClass;
        LARGE_INTEGER m_LogonTime;
        LARGE_INTEGER m_LastInputTime;
        LARGE_INTEGER m_CurrentTime;
        ELAPSEDTIME m_IdleTime;
        WDNAME m_WdName;
        PDNAME m_PdName;
        TCHAR m_ClientName[CLIENTNAME_LENGTH + 1];
        ULONG m_ClientBuildNumber;
        TCHAR m_ClientDir[256];
        TCHAR m_ModemName[256];
        TCHAR m_ClientLicense[30];
        USHORT m_ClientProductId;
        ULONG m_ClientSerialNumber;
        TCHAR m_ClientAddress[30];
        USHORT m_HostBuffers;
        USHORT m_ClientBuffers;
        USHORT m_BufferLength;
        LONG m_OutstandingThreads;      // the number of outstanding threads

        HTREEITEM m_hTreeItem;          // tree item for this WinStation in the servers tree view
        HTREEITEM m_hFavTree;
        HTREEITEM m_hTreeThisComputer;
        USHORT m_VRes;                          // Vertical resolution
        USHORT m_HRes;                          // Horizontal resolution
        TCHAR m_Colors[4];                      // Number of colors (as an ASCII string)
        clock_t m_LastUpdateClock;      // Tick count when we last update this WinStation's info
        USHORT m_ProtocolType;      // Protocol - PROTOCOL_ICA or PROTOCOL_RDP
        BYTE m_EncryptionLevel;         // security level of encryption pd

        ULONG m_WinStationFlags;

        // Pointer to information stored by the extension DLL
        void *m_pExtensionInfo;
        ExtWinStationInfo *m_pExtWinStationInfo;
        ExtModuleInfo *m_pExtModuleInfo;
        ULONG m_NumModules;
        TCHAR m_clientDigProductId[CLIENT_PRODUCT_ID_LENGTH];
};

// Process flags
const ULONG PF_SYSTEM           = 0x00000001;
const ULONG PF_SELECTED         = 0x00000002;
const ULONG PF_TERMINATING      = 0x00000004;   // Currently trying to terminate it
const ULONG PF_CHANGED          = 0x00000008;   // Changed during last enumeration
const ULONG PF_CURRENT          = 0x00000010;   // Still active during last enumeration
const ULONG PF_NEW              = 0x00000020;   // New this enumeration

class CProcess : public CObject
{
public:
        // Constructor
        CProcess(ULONG PID,
             ULONG LogonId,
             CServer *pServer,
             PSID pSID,
             CWinStation *pWinStation,
             TCHAR *ImageName);

        // Updates a process with new information from another process
        BOOL Update(CProcess *pProcess);
        // Returns a pointer to the server that this Process if running on
        CServer *GetServer() { return m_pServer; }
        // Sets the Server
        void SetServer(CServer *pServer) { m_pServer = pServer; }
        // Returns a pointer to the WinStation that owns this process
        CWinStation *GetWinStation() { return m_pWinStation; }
        // Sets the Winstation
        void SetWinStation(CWinStation *pWinStation) { m_pWinStation = pWinStation; }
        // Returns the PID of this process
        ULONG GetPID() { return m_PID; }

        // Returns the LogonId for this process
        ULONG GetLogonId() { return m_LogonId; }
        // Returns a pointer to the image name
        TCHAR *GetImageName() { return m_ImageName; }
        // Returns a pointer to the user name
        TCHAR *GetUserName() { return m_UserName; }
        // Returns TRUE if this process belongs to the current user
        // BOOL IsCurrentUsers() { return (m_pServer->IsCurrentServer()
        //                                                         && wcscmp(m_UserName, ((CWinAdminApp*)AfxGetApp())->GetCurrentUserName())==0); }

        BOOL IsCurrentUsers() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }


        BOOLEAN IsSystemProcess() { return (m_Flags & PF_SYSTEM) > 0; }
        void SetSystemProcess() { m_Flags |= PF_SYSTEM; }
        void ClearSystemProcess() { m_Flags &= ~PF_SYSTEM; }

        BOOLEAN IsSelected() { return (m_Flags & PF_SELECTED) > 0; }
        void SetSelected() { m_Flags |= PF_SELECTED; m_pServer->IncrementNumProcessesSelected(); }
        void ClearSelected() { m_Flags &= ~PF_SELECTED; m_pServer->DecrementNumProcessesSelected(); }

        BOOLEAN IsTerminating() { return (m_Flags & PF_TERMINATING) > 0; }
        void SetTerminating() { m_Flags |= PF_TERMINATING; }
        void ClearTerminating() { m_Flags &= ~PF_TERMINATING; }

        BOOLEAN IsCurrent() { return (m_Flags & PF_CURRENT) > 0; }
        void SetCurrent() { m_Flags |= PF_CURRENT; }
        void ClearCurrent() { m_Flags &= ~PF_CURRENT; }

        BOOLEAN IsChanged() { return (m_Flags & PF_CHANGED) > 0; }
        void SetChanged() { m_Flags |= PF_CHANGED; }
        void ClearChanged() { m_Flags &= ~PF_CHANGED; }

        BOOLEAN IsNew() { return (m_Flags & PF_NEW) > 0; }
        void SetNew() { m_Flags |= PF_NEW; }
        void ClearNew() { m_Flags &= ~PF_NEW; }

private:
        // Determine whether or not this is a system process
        BOOL QuerySystemProcess();
        // Determine which user owns a process
        void DetermineProcessUser(PSID pSid);

        ULONG m_PID;
        ULONG m_LogonId;
        USHORT m_SidCrc;
        TCHAR m_ImageName[20];//[MAX_PROCESSNAME+1];
        TCHAR m_UserName[USERNAME_LENGTH+1];
        CServer *m_pServer;
        CWinStation *m_pWinStation;
        ULONG m_Flags;
};

class CAdminView : public CView
{
public:
        virtual void Reset(void *) { }
        virtual LRESULT OnTabbed( WPARAM , LPARAM ){ return 0;}
};

//=------------------------------------------------
class CMyTabCtrl : public CTabCtrl
{    
public:
    CMyTabCtrl()
    {
        
    }
protected:
    afx_msg void OnSetFocus( CWnd* );
    DECLARE_MESSAGE_MAP()
};
//=------------------------------------------------

class CAdminPage : public CFormView
{
friend class CServerView;
friend class CWinStationView;
friend class CAllServersView;
friend class CDomainView;

public:
   CAdminPage(UINT nIDTemplate);
   CAdminPage();
   DECLARE_DYNCREATE(CAdminPage)

   virtual void Reset(void *) { }
   virtual void ClearSelections() { }
};


typedef struct _columndefs {
        UINT stringID;
        int format;
   int width;
} ColumnDef;

// Commonly used column definitions
#define CD_SERVER               {       IDS_COL_SERVER,                 LVCFMT_LEFT,    115             }
#define CD_USER                 {       IDS_COL_USER,                   LVCFMT_LEFT,    100     }
#define CD_USER2                {       IDS_COL_USER,                   LVCFMT_LEFT,    80              }
#define CD_USER3                {       IDS_COL_USER,                   LVCFMT_LEFT,    90              }
#define CD_SESSION              {       IDS_COL_WINSTATION,             LVCFMT_LEFT,    80              }
#define CD_SESSION2             {       IDS_COL_WINSTATION,             LVCFMT_LEFT,    100     }
#define CD_ID                   {       IDS_COL_ID,                             LVCFMT_RIGHT,   30              }
#define CD_STATE                {       IDS_COL_STATE,                  LVCFMT_LEFT,    50              }
#define CD_TYPE                 {       IDS_COL_TYPE,                   LVCFMT_LEFT,    80              }
#define CD_CLIENT_NAME  {       IDS_COL_CLIENT_NAME,    LVCFMT_LEFT,    80              }
#define CD_IDLETIME             {       IDS_COL_IDLETIME,               LVCFMT_RIGHT,   80              }
#define CD_LOGONTIME    {       IDS_COL_LOGONTIME,              LVCFMT_LEFT,    90              }
#define CD_COMMENT              {       IDS_COL_COMMENT,                LVCFMT_LEFT,    200             }
// Server Columns
#define CD_TCPADDRESS   {       IDS_COL_TCPADDRESS,             LVCFMT_LEFT,    90              }
#define CD_IPXADDRESS   {       IDS_COL_IPXADDRESS,             LVCFMT_LEFT,    110             }
#define CD_NUM_SESSIONS {       IDS_COL_NUM_WINSTATIONS, LVCFMT_RIGHT,  70              }
// License Columns
#define CD_LICENSE_DESC {       IDS_COL_LICENSE_DESC,   LVCFMT_LEFT,    200             }
#define CD_LICENSE_REG  {       IDS_COL_LICENSE_REGISTERED,             LVCFMT_CENTER,  80      }
#define CD_USERCOUNT    {       IDS_COL_USERCOUNT,      LVCFMT_RIGHT,   80              }
#define CD_POOLCOUNT    {       IDS_COL_POOLCOUNT,      LVCFMT_RIGHT,   80              }
#define CD_LICENSE_NUM  {       IDS_COL_LICENSE_NUMBER, LVCFMT_LEFT,    240             }
// Process Columns
#define CD_PROC_ID      {       IDS_COL_ID,                             LVCFMT_RIGHT,   30              }
#define CD_PROC_PID     {       IDS_COL_PID,                    LVCFMT_RIGHT,   50              }
#define CD_PROC_IMAGE   {       IDS_COL_IMAGE,                  LVCFMT_LEFT,    100             }
// Hotfix Columns
#define CD_HOTFIX               {       IDS_COL_HOTFIX,                 LVCFMT_LEFT,    90              }
#define CD_INSTALLED_BY {       IDS_COL_INSTALLED_BY,   LVCFMT_LEFT,    90              }
#define CD_INSTALLED_ON {       IDS_COL_INSTALLED_ON,   LVCFMT_LEFT,    150             }


// Definitions of PageDef flags
const UINT PF_PICASSO_ONLY = 0x0001;
const UINT PF_NO_TAB = 0x0002;

typedef struct _pagedef {
   CAdminPage *m_pPage;
   CRuntimeClass *m_pRuntimeClass;
   UINT tabStringID;
   int page;
   UINT flags;
} PageDef;
//defines for help

//=================================================================================

#define ID_HELP_FILE L"tsadmin.hlp"

//==================================================================================
#define HIDC_MESSAGE_TITLE                      0x500FB
#define HIDC_SHADOWSTART_HOTKEY                 0x500F1
#define HIDC_SHADOWSTART_SHIFT                  0x500F2
#define HIDC_SHADOWSTART_CTRL                   0x500F3
#define HIDC_SHADOWSTART_ALT                    0x500F4
#define HIDC_MESSAGE_TITLE                      0x500FB
#define HIDC_MESSAGE_MESSAGE                    0x500FC
#define HIDC_COMMON_USERNAME                    0x5012C
#define HIDC_COMMON_WINSTATIONNAME              0x5012D
#define HIDC_COMMON_IBYTES                      0x5012E
#define HIDC_COMMON_OBYTES                      0x5012F
#define HIDC_COMMON_IFRAMES                     0x50130
#define HIDC_COMMON_OFRAMES                     0x50131
#define HIDC_COMMON_IBYTESPERFRAME              0x50132
#define HIDC_COMMON_OBYTESPERFRAME              0x50133
#define HIDC_COMMON_IFRAMEERRORS                0x50134
#define HIDC_COMMON_OFRAMEERRORS                0x50135
#define HIDC_COMMON_IPERCENTFRAMEERRORS         0x50136
#define HIDC_COMMON_OPERCENTFRAMEERRORS         0x50137
#define HIDC_COMMON_ITIMEOUTERRORS              0x50138
#define HIDC_COMMON_OTIMEOUTERRORS              0x50139
#define HIDC_COMMON_ICOMPRESSIONRATIO           0x5013A
#define HIDC_COMMON_OCOMPRESSIONRATIO           0x5013B
#define HIDC_REFRESHNOW                         0x50140
#define HIDC_RESETCOUNTERS                      0x50141
#define HIDC_MOREINFO                           0x50142
#define HIDC_ASYNC_DEVICE                       0x5015F
#define HIDC_ASYNC_BAUD                         0x50160
#define HIDC_ASYNC_DTR                          0x50161
#define HIDC_ASYNC_RTS                          0x50162
#define HIDC_ASYNC_CTS                          0x50163
#define HIDC_ASYNC_DSR                          0x50164
#define HIDC_ASYNC_DCD                          0x50165
#define HIDC_ASYNC_RI                           0x50166
#define HIDC_ASYNC_IFRAMING                     0x50167
#define HIDC_ASYNC_IOVERRUN                     0x50168
#define HIDC_ASYNC_IOVERFLOW                    0x50169
#define HIDC_ASYNC_IPARITY                      0x5016A
#define HIDC_ASYNC_OFRAMING                     0x5016B
#define HIDC_ASYNC_OOVERRUN                     0x5016C
#define HIDC_ASYNC_OOVERFLOW                    0x5016D
#define HIDC_ASYNC_OPARITY                      0x5016E
#define HIDC_NETWORK_LANADAPTER                 0x50173
#define HIDC_PREFERENCES_PROC_MANUAL            0x503EF
#define HIDC_PREFERENCES_PROC_EVERY             0x503F0
#define HIDC_PREFERENCES_PROC_SECONDS           0x503F1
#define HIDC_PREFERENCES_STATUS_MANUAL          0x503F3
#define HIDC_PREFERENCES_STATUS_EVERY           0x503F4
#define HIDC_PREFERENCES_STATUS_SECONDS         0x503F5
#define HIDC_PREFERENCES_CONFIRM                0x503F7
#define HIDC_PREFERENCES_SAVE                   0x503F8
#define HIDC_PREFERENCES_REMEMBER                       0X50443

#define HIDD_SERVER_WINSTATIONS                 0x20084
#define HIDD_SERVER_PROCESSES                   0x20085
#define HIDD_SERVER_USERS                       0x20086
#define HIDD_SERVER_LICENSES                    0x20087
#define HIDD_WINSTATION_INFO                    0x20099
#define HIDD_WINSTATION_PROCESSES               0x2009A
#define HIDD_PREFERENCES                        0x2009C
#define HIDD_SERVER_INFO                        0x2009D
#define HIDD_MESSAGE                            0x200FA
#define HIDD_ASYNC_STATUS                       0x2015E
#define HIDD_NETWORK_STATUS                     0x20172
#define HIDD_CONNECT_PASSWORD                   0x201B8
#define HIDD_ALL_SERVER_PROCESSES               0x201BA
#define HIDD_ALL_SERVER_USERS                   0x201BB
#define HIDD_ALL_SERVER_SESSIONS                0x201BC
#define HIDD_BAD_SERVER                         0x201BE
#define HIDD_LISTENER                           0x201BF
#define HIDD_WINSTATION_NOINFO                  0x201C0
#define HIDD_BUSY_SERVER                        0x201C1
#define HIDD_WINSTATION_CACHE                   0x201C2
#define HIDD_BAD_WINSTATION                     0x201C3

//==========================================================================================




//Global variable for help

static const DWORD aMenuHelpIDs[] =
{
    IDC_MESSAGE_TITLE, HIDC_MESSAGE_TITLE,
        IDC_MESSAGE_MESSAGE,HIDC_MESSAGE_MESSAGE,
        IDC_SHADOWSTART_HOTKEY,HIDC_SHADOWSTART_HOTKEY,
        IDC_SHADOWSTART_SHIFT ,HIDC_SHADOWSTART_SHIFT,
        IDC_SHADOWSTART_CTRL ,HIDC_SHADOWSTART_CTRL,
    IDC_SHADOWSTART_ALT ,HIDC_SHADOWSTART_ALT,
        IDC_COMMON_USERNAME ,HIDC_COMMON_USERNAME,
    IDC_COMMON_WINSTATIONNAME  ,HIDC_COMMON_WINSTATIONNAME,
    IDC_COMMON_IBYTES,HIDC_COMMON_IBYTES,
        IDC_COMMON_OBYTES  ,HIDC_COMMON_OBYTES,
    IDC_COMMON_IFRAMES ,HIDC_COMMON_IFRAMES,
    IDC_COMMON_OFRAMES ,HIDC_COMMON_OFRAMES,
    IDC_COMMON_IBYTESPERFRAME ,HIDC_COMMON_IBYTESPERFRAME,
        IDC_COMMON_OBYTESPERFRAME ,HIDC_COMMON_OBYTESPERFRAME,
    IDC_COMMON_IFRAMEERRORS  ,HIDC_COMMON_IFRAMEERRORS,
        IDC_COMMON_OFRAMEERRORS ,HIDC_COMMON_OFRAMEERRORS,
    IDC_COMMON_IPERCENTFRAMEERRORS ,HIDC_COMMON_IPERCENTFRAMEERRORS,
    IDC_COMMON_OPERCENTFRAMEERRORS ,HIDC_COMMON_OPERCENTFRAMEERRORS,
        IDC_COMMON_ITIMEOUTERRORS ,HIDC_COMMON_ITIMEOUTERRORS,
    IDC_COMMON_OTIMEOUTERRORS,HIDC_COMMON_OTIMEOUTERRORS,
    IDC_COMMON_ICOMPRESSIONRATIO ,HIDC_COMMON_ICOMPRESSIONRATIO,
    IDC_COMMON_OCOMPRESSIONRATIO ,HIDC_COMMON_OCOMPRESSIONRATIO,
    IDC_REFRESHNOW ,HIDC_REFRESHNOW,
    IDC_RESETCOUNTERS,HIDC_RESETCOUNTERS,
    IDC_MOREINFO,HIDC_MOREINFO,
    IDC_ASYNC_DEVICE,  HIDC_ASYNC_DEVICE ,
    IDC_ASYNC_BAUD  ,HIDC_ASYNC_BAUD  ,
    IDC_ASYNC_DTR ,  HIDC_ASYNC_DTR ,
    IDC_ASYNC_RTS  , HIDC_ASYNC_RTS  ,
    IDC_ASYNC_CTS  ,  HIDC_ASYNC_CTS  ,
    IDC_ASYNC_DSR ,  HIDC_ASYNC_DSR    ,
    IDC_ASYNC_DCD  , HIDC_ASYNC_DCD     ,
    IDC_ASYNC_RI  ,  HIDC_ASYNC_RI       ,
    IDC_ASYNC_IFRAMING ,  HIDC_ASYNC_IFRAMING  ,
    IDC_ASYNC_IOVERRUN , HIDC_ASYNC_IOVERRUN    ,
    IDC_ASYNC_IOVERFLOW ,    HIDC_ASYNC_IOVERFLOW,
    IDC_ASYNC_IPARITY  , HIDC_ASYNC_IPARITY       ,
    IDC_ASYNC_OFRAMING ,   HIDC_ASYNC_OFRAMING     ,
    IDC_ASYNC_OOVERRUN ,   HIDC_ASYNC_OOVERRUN      ,
    IDC_ASYNC_OOVERFLOW ,  HIDC_ASYNC_OOVERFLOW      ,
    IDC_ASYNC_OPARITY    ,  HIDC_ASYNC_OPARITY        ,
    IDC_NETWORK_LANADAPTER,     HIDC_NETWORK_LANADAPTER,
    IDC_PREFERENCES_PROC_MANUAL ,HIDC_PREFERENCES_PROC_MANUAL ,
    IDC_PREFERENCES_PROC_EVERY   , HIDC_PREFERENCES_PROC_EVERY ,
    IDC_PREFERENCES_PROC_SECONDS  , HIDC_PREFERENCES_PROC_SECONDS,
    IDC_PREFERENCES_STATUS_MANUAL  ,  HIDC_PREFERENCES_STATUS_MANUAL,
    IDC_PREFERENCES_STATUS_EVERY    , HIDC_PREFERENCES_STATUS_EVERY,
    IDC_PREFERENCES_STATUS_SECONDS   ,  HIDC_PREFERENCES_STATUS_SECONDS ,
    IDC_PREFERENCES_STATUS_SECONDS    ,HIDC_PREFERENCES_STATUS_SECONDS   ,
    IDC_PREFERENCES_CONFIRM     ,HIDC_PREFERENCES_CONFIRM           ,
        IDD_WINSTATION_NOINFO,HIDD_WINSTATION_NOINFO,
        IDC_PREFERENCES_SAVE , HIDC_PREFERENCES_SAVE,
        IDC_PREFERENCES_PERSISTENT ,HIDC_PREFERENCES_REMEMBER,
};

/////////////////////////////////////////////////////////////////////////////
#endif // _WINADMIN_H