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.
815 lines
24 KiB
815 lines
24 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
winscomp.cpp
|
|
This file contains the derived implementations from CComponent
|
|
and CComponentData for the WINS admin snapin.
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "winscomp.h"
|
|
#include "root.h"
|
|
#include "server.h"
|
|
#include "vrfysrv.h"
|
|
#include "status.h"
|
|
|
|
#include <atlimpl.cpp>
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#define HI HIDDEN
|
|
#define EN ENABLED
|
|
|
|
LARGE_INTEGER gliWinssnapVersion;
|
|
|
|
UINT aColumns[WINSSNAP_NODETYPE_MAX][MAX_COLUMNS] =
|
|
{
|
|
{IDS_ROOT_NAME, IDS_STATUS, 0, 0, 0, 0, 0, 0,0}, // WINSSNAP_ROOT
|
|
{IDS_WINSSERVER_NAME, IDS_DESCRIPTION, 0, 0, 0, 0, 0, 0,0}, // WINSSNAP_SERVER
|
|
{IDS_ACTIVEREG_RECORD_NAME, IDS_ACTIVEREG_TYPE, IDS_ACTIVEREG_IPADDRESS, IDS_ACTIVEREG_ACTIVE, IDS_ACTIVEREG_STATIC,IDS_ACTREG_OWNER, IDS_ACTIVEREG_VERSION, IDS_ACTIVEREG_EXPIRATION,0}, // WINSSNAP_ACTIVE_REGISTRATIONS
|
|
{IDS_REPLICATION_SERVERNAME,IDS_ACTIVEREG_IPADDRESS, IDS_ACTIVEREG_TYPE, 0, 0, 0, 0, 0,0}, // WINSSNAP_REPLICATION_PARTNERS
|
|
{IDS_ROOT_NODENAME, IDS_ROOT_NODE_STATUS, IDS_LAST_UPDATE, 0, 0, 0, 0, 0,0}, // STATUS
|
|
{0,0,0,0,0,0,0,0,0}
|
|
};
|
|
|
|
//
|
|
// CODEWORK this should be in a resource, for example code on loading data resources see
|
|
// D:\nt\private\net\ui\common\src\applib\applib\lbcolw.cxx ReloadColumnWidths()
|
|
// JonN 10/11/96
|
|
//
|
|
// StatusRemove
|
|
int aColumnWidths[WINSSNAP_NODETYPE_MAX][MAX_COLUMNS] =
|
|
{
|
|
{250, 150, 50, AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // WINSSNAP_ROOT
|
|
{250, 250, AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // WINSSNAP_SERVER
|
|
{150, 120, 100, 75, 50, 100, 100, 150, AUTO_WIDTH}, // WINSSNAP_ACTIVE_REGISTRATIONS
|
|
{100, 100, 100, 150, AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // WINSSNAP_REPLICATION_PARTNERS
|
|
{250, 100, 200, AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // WINSSNAP_SERVER_STATUS
|
|
{AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // WINSSNAP_SERVER_STATUS
|
|
|
|
};
|
|
|
|
// icon defines
|
|
UINT g_uIconMap[ICON_IDX_MAX + 1][2] =
|
|
{
|
|
{IDI_ICON01, ICON_IDX_ACTREG_FOLDER_CLOSED},
|
|
{IDI_ICON02, ICON_IDX_ACTREG_FOLDER_CLOSED_BUSY},
|
|
{IDI_ICON03, ICON_IDX_ACTREG_FOLDER_OPEN},
|
|
{IDI_ICON04, ICON_IDX_ACTREG_FOLDER_OPEN_BUSY},
|
|
{IDI_ICON05, ICON_IDX_CLIENT},
|
|
{IDI_ICON06, ICON_IDX_CLIENT_GROUP},
|
|
{IDI_ICON07, ICON_IDX_PARTNER},
|
|
{IDI_ICON08, ICON_IDX_REP_PARTNERS_FOLDER_CLOSED},
|
|
{IDI_ICON09, ICON_IDX_REP_PARTNERS_FOLDER_CLOSED_BUSY},
|
|
{IDI_ICON10, ICON_IDX_REP_PARTNERS_FOLDER_CLOSED_LOST_CONNECTION},
|
|
{IDI_ICON11, ICON_IDX_REP_PARTNERS_FOLDER_OPEN},
|
|
{IDI_ICON12, ICON_IDX_REP_PARTNERS_FOLDER_OPEN_BUSY},
|
|
{IDI_ICON13, ICON_IDX_REP_PARTNERS_FOLDER_OPEN_LOST_CONNECTION},
|
|
{IDI_ICON14, ICON_IDX_SERVER},
|
|
{IDI_ICON15, ICON_IDX_SERVER_BUSY},
|
|
{IDI_ICON16, ICON_IDX_SERVER_CONNECTED},
|
|
{IDI_ICON17, ICON_IDX_SERVER_LOST_CONNECTION},
|
|
{IDI_ICON18, ICON_IDX_SERVER_NO_ACCESS},
|
|
{IDI_WINS_SNAPIN, ICON_IDX_WINS_PRODUCT},
|
|
{0, 0}
|
|
};
|
|
|
|
// help mapper for dialogs and property pages
|
|
struct ContextHelpMap
|
|
{
|
|
UINT uID;
|
|
const DWORD * pdwMap;
|
|
};
|
|
|
|
ContextHelpMap g_uContextHelp[WINSSNAP_NUM_HELP_MAPS] =
|
|
{
|
|
{IDD_ACTREG_FIND_RECORD, g_aHelpIDs_IDD_ACTREG_FIND_RECORD},
|
|
{IDD_CHECK_REG_NAMES, g_aHelpIDs_IDD_CHECK_REG_NAMES},
|
|
{IDD_DELTOMB_RECORD, g_aHelpIDs_IDD_DELTOMB_RECORD},
|
|
{IDD_DYN_PROPERTIES, g_aHelpIDs_IDD_DYN_PROPERTIES},
|
|
{IDD_FILTER_SELECT, g_aHelpIDs_IDD_FILTER_SELECT},
|
|
{IDD_GETIPADDRESS, g_aHelpIDs_IDD_GETIPADDRESS},
|
|
{IDD_GETNETBIOSNAME, g_aHelpIDs_IDD_GETNETBIOSNAME},
|
|
{IDD_IPADDRESS, g_aHelpIDs_IDD_IPADDRESS},
|
|
{IDD_NAME_TYPE, g_aHelpIDs_IDD_NAME_TYPE},
|
|
{IDD_OWNER_DELETE, g_aHelpIDs_IDD_OWNER_DELETE},
|
|
{IDD_OWNER_FILTER, g_aHelpIDs_IDD_OWNER_FILTER},
|
|
{IDD_FILTER_IPADDR, g_aHelpIDs_IDD_FILTER_IPADDR},
|
|
{IDD_PULL_TRIGGER, NULL},
|
|
{IDD_REP_NODE_ADVANCED, g_aHelpIDs_IDD_REP_NODE_ADVANCED},
|
|
{IDD_REP_NODE_PUSH, g_aHelpIDs_IDD_REP_NODE_PUSH},
|
|
{IDD_REP_NODE_PULL, g_aHelpIDs_IDD_REP_NODE_PULL},
|
|
{IDD_REP_NODE_GENERAL, g_aHelpIDs_IDD_REP_NODE_GENERAL},
|
|
{IDD_REP_PROP_ADVANCED, g_aHelpIDs_IDD_REP_PROP_ADVANCED},
|
|
{IDD_REP_PROP_GENERAL, g_aHelpIDs_IDD_REP_PROP_GENERAL},
|
|
{IDD_SEND_PUSH_TRIGGER, g_aHelpIDs_IDD_SEND_PUSH_TRIGGER},
|
|
{IDD_SERVER_PROP_ADVANCED, g_aHelpIDs_IDD_SERVER_PROP_ADVANCED},
|
|
{IDD_SERVER_PROP_DBRECORD, g_aHelpIDs_IDD_SERVER_PROP_DBRECORD},
|
|
{IDD_SERVER_PROP_DBVERIFICATION, g_aHelpIDs_IDD_SERVER_PROP_DBVERIFICATION},
|
|
{IDD_SERVER_PROP_GEN, g_aHelpIDs_IDD_SERVER_PROP_GEN},
|
|
{IDD_SNAPIN_PP_GENERAL, g_aHelpIDs_IDD_SNAPIN_PP_GENERAL},
|
|
{IDD_STATIC_MAPPING_PROPERTIES, g_aHelpIDs_IDD_STATIC_MAPPING_PROPERTIES},
|
|
{IDD_STATIC_MAPPING_WIZARD, g_aHelpIDs_IDD_STATIC_MAPPING_WIZARD},
|
|
{IDD_STATS_NARROW, NULL},
|
|
{IDD_STATUS_NODE_PROPERTIES, g_aHelpIDs_IDD_STATUS_NODE_PROPERTIES},
|
|
{IDD_VERIFY_WINS, NULL},
|
|
{IDD_VERSION_CONSIS, g_aHelpIDs_IDD_VERSION_CONSIS},
|
|
};
|
|
|
|
CWinsContextHelpMap g_winsContextHelpMap;
|
|
|
|
DWORD * WinsGetHelpMap(UINT uID)
|
|
{
|
|
DWORD * pdwMap = NULL;
|
|
g_winsContextHelpMap.Lookup(uID, pdwMap);
|
|
return pdwMap;
|
|
}
|
|
|
|
|
|
|
|
CString aMenuButtonText[3][2];
|
|
|
|
#define ARRAYLEN(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CWinsComponent implementation
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Class CWinsComponent implementation
|
|
---------------------------------------------------------------------------*/
|
|
CWinsComponent::CWinsComponent()
|
|
{
|
|
}
|
|
|
|
CWinsComponent::~CWinsComponent()
|
|
{
|
|
}
|
|
|
|
STDMETHODIMP CWinsComponent::InitializeBitmaps(MMC_COOKIE cookie)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
ASSERT(m_spImageList != NULL);
|
|
HICON hIcon;
|
|
|
|
for (int i = 0; i < ICON_IDX_MAX; i++)
|
|
{
|
|
hIcon = LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(g_uIconMap[i][0]));
|
|
if (hIcon)
|
|
{
|
|
// call mmc
|
|
m_spImageList->ImageListSetIcon(reinterpret_cast<LONG_PTR*>(hIcon), g_uIconMap[i][1]);
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponent::QueryDataObject
|
|
Implementation of IComponent::QueryDataObject. We need this for
|
|
virtual listbox support. MMC calls us back normally with the cookie
|
|
we handed it... In the case of the VLB, it hands us the index of
|
|
the item. So, we need to do some extra checking...
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponent::QueryDataObject
|
|
(
|
|
MMC_COOKIE cookie,
|
|
DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT* ppDataObject
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spSelectedNode;
|
|
SPITFSNode spRootNode;
|
|
SPITFSResultHandler spResultHandler;
|
|
long lViewOptions = 0;
|
|
LPOLESTR pViewType = NULL;
|
|
CDataObject * pDataObject;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// check to see what kind of result view type the selected node has
|
|
CORg (GetSelectedNode(&spSelectedNode));
|
|
CORg (spSelectedNode->GetResultHandler(&spResultHandler));
|
|
|
|
CORg (spResultHandler->OnGetResultViewType(this, spSelectedNode->GetData(TFS_DATA_COOKIE), &pViewType, &lViewOptions));
|
|
|
|
if ( (lViewOptions & MMC_VIEW_OPTIONS_OWNERDATALIST) ||
|
|
(cookie == MMC_MULTI_SELECT_COOKIE) )
|
|
{
|
|
if (cookie == MMC_MULTI_SELECT_COOKIE)
|
|
{
|
|
// this is a special case for multiple select. We need to build a list
|
|
// of GUIDs and the code to do this is in the handler...
|
|
spResultHandler->OnCreateDataObject(this, cookie, type, ppDataObject);
|
|
}
|
|
else
|
|
{
|
|
// this node has a virtual listbox for the result pane. Gerenate
|
|
// a special data object using the selected node as the cookie
|
|
Assert(m_spComponentData != NULL);
|
|
CORg (m_spComponentData->QueryDataObject(reinterpret_cast<LONG_PTR>((ITFSNode *) spSelectedNode), type, ppDataObject));
|
|
}
|
|
|
|
pDataObject = reinterpret_cast<CDataObject *>(*ppDataObject);
|
|
pDataObject->SetVirtualIndex((int) cookie);
|
|
}
|
|
else
|
|
if (cookie == MMC_WINDOW_COOKIE)
|
|
{
|
|
// this cookie needs the text for the static root node, so build the DO with
|
|
// the root node cookie
|
|
m_spNodeMgr->GetRootNode(&spRootNode);
|
|
CORg (m_spComponentData->QueryDataObject((MMC_COOKIE) spRootNode->GetData(TFS_DATA_COOKIE), type, ppDataObject));
|
|
}
|
|
else
|
|
{
|
|
// just forward this to the component data
|
|
Assert(m_spComponentData != NULL);
|
|
CORg (m_spComponentData->QueryDataObject(cookie, type, ppDataObject));
|
|
}
|
|
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponent::OnSnapinHelp
|
|
-
|
|
Author: v-shubk
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponent::OnSnapinHelp
|
|
(
|
|
LPDATAOBJECT pDataObject,
|
|
LPARAM arg,
|
|
LPARAM param
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
|
|
HtmlHelpA(NULL, "WinsSnap.chm", HH_DISPLAY_TOPIC, 0);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponent::CompareObjects
|
|
Implementation of IComponent::CompareObjects
|
|
MMC calls this to compare two objects
|
|
We override this for the virtual listbox case. With a virtual listbox,
|
|
the cookies are the same, but the index in the internal structs
|
|
indicate which item the dataobject refers to. So, we need to look
|
|
at the indicies instead of just the cookies.
|
|
Author:
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponent::CompareObjects
|
|
(
|
|
LPDATAOBJECT lpDataObjectA,
|
|
LPDATAOBJECT lpDataObjectB
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
if (lpDataObjectA == NULL || lpDataObjectB == NULL)
|
|
return E_POINTER;
|
|
|
|
// Make sure both data object are mine
|
|
SPINTERNAL spA;
|
|
SPINTERNAL spB;
|
|
HRESULT hr = S_FALSE;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
spA = ExtractInternalFormat(lpDataObjectA);
|
|
spB = ExtractInternalFormat(lpDataObjectB);
|
|
|
|
if (spA != NULL && spB != NULL)
|
|
{
|
|
if (spA->HasVirtualIndex() && spB->HasVirtualIndex())
|
|
{
|
|
hr = (spA->GetVirtualIndex() == spB->GetVirtualIndex()) ? S_OK : S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
hr = (spA->m_cookie == spB->m_cookie) ? S_OK : S_FALSE;
|
|
}
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Class CWinsComponentData implementation
|
|
---------------------------------------------------------------------------*/
|
|
|
|
CWinsComponentData::CWinsComponentData()
|
|
{
|
|
// initialize our global help map
|
|
for (int i = 0; i < WINSSNAP_NUM_HELP_MAPS; i++)
|
|
{
|
|
g_winsContextHelpMap.SetAt(g_uContextHelp[i].uID, (LPDWORD) g_uContextHelp[i].pdwMap);
|
|
}
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponentData::OnInitialize
|
|
-
|
|
Author: EricDav, KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CWinsComponentData::OnInitialize(LPIMAGELIST pScopeImage)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HICON hIcon;
|
|
|
|
for (int i = 0; i < ICON_IDX_MAX; i++)
|
|
{
|
|
hIcon = LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(g_uIconMap[i][0]));
|
|
if (hIcon)
|
|
{
|
|
// call mmc
|
|
VERIFY(SUCCEEDED(pScopeImage->ImageListSetIcon(reinterpret_cast<LONG_PTR*>(hIcon), g_uIconMap[i][1])));
|
|
}
|
|
}
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponentData::OnDestroy
|
|
-
|
|
Author: EricDav, KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CWinsComponentData::OnDestroy()
|
|
{
|
|
m_spNodeMgr.Release();
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponentData::OnInitializeNodeMgr
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponentData::OnInitializeNodeMgr
|
|
(
|
|
ITFSComponentData * pTFSCompData,
|
|
ITFSNodeMgr * pNodeMgr
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// For now create a new node handler for each new node,
|
|
// this is rather bogus as it can get expensive. We can
|
|
// consider creating only a single node handler for each
|
|
// node type.
|
|
CWinsRootHandler * pHandler = NULL;
|
|
SPITFSNodeHandler spHandler;
|
|
SPITFSNode spNode;
|
|
HRESULT hr = hrOK;
|
|
|
|
try
|
|
{
|
|
pHandler = new CWinsRootHandler(pTFSCompData);
|
|
|
|
// Do this so that it will get released correctly
|
|
spHandler = pHandler;
|
|
}
|
|
catch(...)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
CORg( hr );
|
|
|
|
// Create the root node for this sick puppy
|
|
CORg( CreateContainerTFSNode(&spNode,
|
|
&GUID_WinsGenericNodeType,
|
|
pHandler,
|
|
pHandler, /* result handler */
|
|
pNodeMgr) );
|
|
|
|
// Need to initialize the data for the root node
|
|
pHandler->InitializeNode(spNode);
|
|
|
|
CORg( pNodeMgr->SetRootNode(spNode) );
|
|
m_spRootNode.Set(spNode);
|
|
|
|
pTFSCompData->SetHTMLHelpFileName(_T("winssnap.chm"));
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponentData::OnCreateComponent
|
|
-
|
|
Author: EricDav, KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponentData::OnCreateComponent
|
|
(
|
|
LPCOMPONENT *ppComponent
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
ASSERT(ppComponent != NULL);
|
|
|
|
HRESULT hr = hrOK;
|
|
CWinsComponent * pComp = NULL;
|
|
|
|
try
|
|
{
|
|
pComp = new CWinsComponent;
|
|
}
|
|
catch(...)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (FHrSucceeded(hr))
|
|
{
|
|
pComp->Construct(m_spNodeMgr,
|
|
static_cast<IComponentData *>(this),
|
|
m_spTFSComponentData);
|
|
*ppComponent = static_cast<IComponent *>(pComp);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CWinsComponentData::GetCoClassID
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(const CLSID *)
|
|
CWinsComponentData::GetCoClassID()
|
|
{
|
|
return &CLSID_WinsSnapin;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CSfmComponentData::OnCreateDataObject
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CWinsComponentData::OnCreateDataObject
|
|
(
|
|
MMC_COOKIE cookie,
|
|
DATA_OBJECT_TYPES type,
|
|
IDataObject ** ppDataObject
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
Assert(ppDataObject != NULL);
|
|
|
|
CDataObject * pObject = NULL;
|
|
SPIDataObject spDataObject;
|
|
|
|
pObject = new CDataObject;
|
|
spDataObject = pObject; // do this so that it gets released correctly
|
|
|
|
Assert(pObject != NULL);
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pObject->SetType(type);
|
|
pObject->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pObject->SetClsid(*GetCoClassID());
|
|
|
|
pObject->SetTFSComponentData(m_spTFSComponentData);
|
|
|
|
return pObject->QueryInterface(IID_IDataObject,
|
|
reinterpret_cast<void**>(ppDataObject));
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//// IPersistStream interface members
|
|
STDMETHODIMP
|
|
CWinsComponentData::GetClassID
|
|
(
|
|
CLSID *pClassID
|
|
)
|
|
{
|
|
ASSERT(pClassID != NULL);
|
|
|
|
// Copy the CLSID for this snapin
|
|
*pClassID = CLSID_WinsSnapin;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CWinsComponentData::IsDirty()
|
|
{
|
|
return m_spRootNode->GetData(TFS_DATA_DIRTY) ? hrOK : hrFalse;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CWinsComponentData::Load
|
|
(
|
|
IStream *pStm
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
LARGE_INTEGER liSavedVersion;
|
|
CString str;
|
|
|
|
ASSERT(pStm);
|
|
|
|
CDWordArray dwArrayIp;
|
|
CDWordArray dwArrayFlags;
|
|
CDWordArray dwArrayRefreshInterval;
|
|
CDWordArray dwArrayColumnInfo;
|
|
DWORD dwUpdateInterval;
|
|
DWORD dwSnapinFlags;
|
|
CStringArray strArrayName;
|
|
ULONG nNumReturned = 0;
|
|
DWORD dwFileVersion;
|
|
CWinsRootHandler * pRootHandler;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
HCURSOR hOldCursor;
|
|
HCURSOR hNewCursor;
|
|
int i;
|
|
|
|
// set the mode for this stream
|
|
XferStream xferStream(pStm, XferStream::MODE_READ);
|
|
|
|
// read the version of the file format
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_VERSION, &dwFileVersion));
|
|
|
|
// Read the version # of the admin tool
|
|
CORg(xferStream.XferLARGEINTEGER(WINSSTRM_TAG_VERSIONADMIN, &liSavedVersion));
|
|
if (liSavedVersion.QuadPart < gliWinssnapVersion.QuadPart)
|
|
{
|
|
// File is an older version. Warn the user and then don't
|
|
// load anything else
|
|
Assert(FALSE);
|
|
}
|
|
|
|
// Read the root node name
|
|
CORg(xferStream.XferCString(WINSSTRM_TAB_SNAPIN_NAME, &str));
|
|
Assert(m_spRootNode);
|
|
pRootHandler = GETHANDLER(CWinsRootHandler, m_spRootNode);
|
|
pRootHandler->SetDisplayName(str);
|
|
|
|
// read the root node info
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_SNAPIN_FLAGS, &dwSnapinFlags));
|
|
pRootHandler->m_dwFlags = dwSnapinFlags;
|
|
|
|
pRootHandler->m_fValidate = (dwSnapinFlags & FLAG_VALIDATE_CACHE) ? TRUE : FALSE;
|
|
|
|
// read from the stream
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_UPDATE_INTERVAL, &dwUpdateInterval));
|
|
|
|
pRootHandler->SetUpdateInterval(dwUpdateInterval);
|
|
|
|
// now read all of the server information
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_IP, &dwArrayIp));
|
|
CORg(xferStream.XferCStringArray(WINSSTRM_TAG_SERVER_NAME, &strArrayName));
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_FLAGS, &dwArrayFlags));
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_REFRESHINTERVAL, &dwArrayRefreshInterval));
|
|
|
|
hOldCursor = NULL;
|
|
|
|
hNewCursor = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
|
|
if (hNewCursor)
|
|
hOldCursor = SetCursor(hNewCursor);
|
|
|
|
// now create the servers based on the information
|
|
for (i = 0; i < dwArrayIp.GetSize(); i++)
|
|
{
|
|
//
|
|
// now create the server object
|
|
//
|
|
pRootHandler->AddServer((LPCWSTR) strArrayName[i],
|
|
FALSE,
|
|
dwArrayIp[i],
|
|
FALSE,
|
|
dwArrayFlags[i],
|
|
dwArrayRefreshInterval[i]
|
|
);
|
|
}
|
|
|
|
pRootHandler->DismissVerifyDialog();
|
|
|
|
// load the column information
|
|
for (i = 0; i < NUM_SCOPE_ITEMS; i++)
|
|
{
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_COLUMN_INFO, &dwArrayColumnInfo));
|
|
|
|
for (int j = 0; j < MAX_COLUMNS; j++)
|
|
{
|
|
aColumnWidths[i][j] = dwArrayColumnInfo[j];
|
|
}
|
|
|
|
}
|
|
|
|
if (hOldCursor)
|
|
SetCursor(hOldCursor);
|
|
|
|
Error:
|
|
return SUCCEEDED(hr) ? S_OK : E_FAIL;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CWinsComponentData::Save
|
|
(
|
|
IStream *pStm,
|
|
BOOL fClearDirty
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
CDWordArray dwArrayIp;
|
|
CStringArray strArrayName;
|
|
CDWordArray dwArrayFlags;
|
|
CDWordArray dwArrayRefreshInterval;
|
|
CDWordArray dwArrayColumnInfo;
|
|
DWORD dwUpdateInterval;
|
|
DWORD dwSnapinFlags;
|
|
DWORD dwFileVersion = WINSSNAP_FILE_VERSION;
|
|
CString str;
|
|
CWinsRootHandler * pRootHandler;
|
|
int nNumServers = 0, nVisibleCount = 0;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
ULONG nNumReturned = 0;
|
|
int nCount = 0;
|
|
const GUID * pGuid;
|
|
CWinsServerHandler *pServer;
|
|
int i;
|
|
|
|
ASSERT(pStm);
|
|
|
|
// set the mode for this stream
|
|
XferStream xferStream(pStm, XferStream::MODE_WRITE);
|
|
|
|
// Write the version # of the file format
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_VERSION, &dwFileVersion));
|
|
|
|
// Write the version # of the admin tool
|
|
CORg(xferStream.XferLARGEINTEGER(WINSSTRM_TAG_VERSIONADMIN, &gliWinssnapVersion));
|
|
|
|
// write the root node name
|
|
Assert(m_spRootNode);
|
|
pRootHandler = GETHANDLER(CWinsRootHandler, m_spRootNode);
|
|
str = pRootHandler->GetDisplayName();
|
|
|
|
CORg(xferStream.XferCString(WINSSTRM_TAB_SNAPIN_NAME, &str));
|
|
|
|
//
|
|
// Build our array of servers
|
|
//
|
|
hr = m_spRootNode->GetChildCount(&nVisibleCount, &nNumServers);
|
|
|
|
dwArrayColumnInfo.SetSize(MAX_COLUMNS);
|
|
|
|
// save the root node info
|
|
dwSnapinFlags = pRootHandler->m_dwFlags;
|
|
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_SNAPIN_FLAGS, &dwSnapinFlags));
|
|
|
|
dwUpdateInterval = pRootHandler->GetUpdateInterval();
|
|
CORg(xferStream.XferDWORD(WINSSTRM_TAG_UPDATE_INTERVAL, &dwUpdateInterval));
|
|
|
|
//
|
|
// loop and save off all the server's attributes
|
|
//
|
|
m_spRootNode->GetEnum(&spNodeEnum);
|
|
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
while (nNumReturned)
|
|
{
|
|
pGuid = spCurrentNode->GetNodeType();
|
|
|
|
if (*pGuid == GUID_WinsServerStatusNodeType)
|
|
{
|
|
// go to the next node
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
//nCount++;
|
|
|
|
continue;
|
|
}
|
|
|
|
pServer = GETHANDLER(CWinsServerHandler, spCurrentNode);
|
|
|
|
// put the information in our array
|
|
strArrayName.Add(pServer->GetServerAddress());
|
|
dwArrayIp.Add(pServer->GetServerIP());
|
|
dwArrayFlags.Add(pServer->m_dwFlags);
|
|
dwArrayRefreshInterval.Add(pServer->m_dwRefreshInterval);
|
|
|
|
// go to the next node
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
|
|
nCount++;
|
|
}
|
|
|
|
// now write out all of the server information
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_IP, &dwArrayIp));
|
|
CORg(xferStream.XferCStringArray(WINSSTRM_TAG_SERVER_NAME, &strArrayName));
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_FLAGS, &dwArrayFlags));
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_SERVER_REFRESHINTERVAL, &dwArrayRefreshInterval));
|
|
|
|
// save the column information
|
|
for (i = 0; i < NUM_SCOPE_ITEMS; i++)
|
|
{
|
|
for (int j = 0; j < MAX_COLUMNS; j++)
|
|
{
|
|
dwArrayColumnInfo[j] = aColumnWidths[i][j];
|
|
}
|
|
|
|
CORg(xferStream.XferDWORDArray(WINSSTRM_TAG_COLUMN_INFO, &dwArrayColumnInfo));
|
|
}
|
|
|
|
if (fClearDirty)
|
|
{
|
|
m_spRootNode->SetData(TFS_DATA_DIRTY, FALSE);
|
|
}
|
|
|
|
Error:
|
|
return SUCCEEDED(hr) ? S_OK : STG_E_CANTSAVE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CWinsComponentData::GetSizeMax
|
|
(
|
|
ULARGE_INTEGER *pcbSize
|
|
)
|
|
{
|
|
ASSERT(pcbSize);
|
|
|
|
// Set the size of the string to be saved
|
|
ULISet32(*pcbSize, 10000);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CWinsComponentData::InitNew()
|
|
{
|
|
return hrOK;
|
|
}
|
|
|
|
HRESULT
|
|
CWinsComponentData::FinalConstruct()
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
hr = CComponentData::FinalConstruct();
|
|
|
|
if (FHrSucceeded(hr))
|
|
{
|
|
m_spTFSComponentData->GetNodeMgr(&m_spNodeMgr);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
void
|
|
CWinsComponentData::FinalRelease()
|
|
{
|
|
CComponentData::FinalRelease();
|
|
}
|
|
|
|
|
|
|