infoserver.cpp

来自「此为Insight opc client InfoServerExplorer源」· C++ 代码 · 共 1,428 行 · 第 1/3 页

		return FALSE;
	}
}

BOOL CInfoServer::RecreateOnServer()
{
	for(int g = 0; g < m_Groups.GetSize(); g++)
	{
		if(ReCreateGroupOnServer(&m_Groups[g]))
		{
			//recreate its points
			CArray<CItem*, CItem*>*	pItems;
			unsigned int nItems = 0;

			nItems = m_Groups[g]->GetItems(&pItems);

			for(unsigned int i = 0; i < nItems; i++)
			{
				if(!m_Groups[g]->ReCreateItemOnServer(&(*pItems)[i]))
				{
					return FALSE;	
				}
			}
		}
		else
			return FALSE;
	}

	return TRUE;
}

BOOL CInfoServer::RemoveGroup(CGroup** group)
{
	HRESULT			res;
	CIOPCServer		opcServer(m_pUnkn);
	int				nGroups, nItems;
	BOOL			bRet = FALSE;

	TRACE("Reference count should be 0 !\n");
	TRACE("UnAdvise needed ?\n");

	if(IsConnected())
	{
		(*group)->UnAdvise();

		res = opcServer.RemoveGroup((*group)->GetHandle(), TRUE); //force delete (even if references are outstanding)
		if(SUCCEEDED(res))
		{
			bRet = TRUE;
		}
		else
		{
			DisplayError(res);
			bRet = FALSE;
		}
	}
	else
	{
		bRet = FALSE;
	}

	//since following code handles only client memory it is always executed.
	nGroups = m_Groups.GetSize();
	for(int g = 0; g <  nGroups; g++)
	{
		if( *group == m_Groups[g] ) 
		{
			//delete the items (No RemoveItem() is necessary; RemoveGroups removes the items)
			CArray<CItem*, CItem*>*	pItems;
			nItems = m_Groups[g]->GetItems(&pItems);
			for(int i = 0; i < nItems ; i++)
			{
				CItem* pItem;
				pItem = (*pItems)[0];
				pItems->RemoveAt(0,1);
				delete pItem;
			}
			pItems->FreeExtra();

			delete *group;

			m_Groups.RemoveAt(g,1);
			m_Groups.FreeExtra();
			break;
		}
	}
				
	if(bRet) ((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(_T("Group successfuly removed."));

	return bRet;
}

BOOL CInfoServer::EditGroup(CGroup** group)
{
	USES_CONVERSION;

	CGroupDlg			dlg;
	CIOPCGroupStateMgt	opcGroup((*group)->GetInterface());
	OPCHANDLE			hClientGroup; //out -> in => no modification
	OPCHANDLE			hServerGroup; //out: not used
	DWORD				rate;		//out: servers rate
	LPWSTR				pGroupName;
	BOOL				bRet = FALSE;

	
	if((*group)->GetDataChangeEnabled(&dlg.m_bDataChange, FALSE))
	{
		//is what we store the same as on the server ?
		BOOL bNewDataChange = FALSE;
		(*group)->GetDataChangeEnabled(&bNewDataChange, TRUE);
		if(bNewDataChange != dlg.m_bDataChange)
		{
			((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(_T("CGroup::m_bDataChange inconsistency to IOPCAsyncIO2::GetEnabled()."));
			ASSERT(0);
		}

		if(SUCCEEDED(opcGroup.GetState(	&dlg.m_dwUpdateRate, &dlg.m_bActive,     
										&pGroupName,
										&dlg.m_lTimeBias,
										&dlg.m_fDeadBand,
										&dlg.m_dwLCID,
										&hClientGroup,
										&hServerGroup
										)))
		{
			dlg.m_sGroup = OLE2A(pGroupName);

			if(IDOK == dlg.DoModal()) 
			{
				if(SUCCEEDED(opcGroup.SetState(	&dlg.m_dwUpdateRate,
												&rate,
												&dlg.m_bActive, 										  
												&dlg.m_lTimeBias,
												&dlg.m_fDeadBand,
												&dlg.m_dwLCID,
												&hClientGroup)))
				{
					(*group)->SetActive(dlg.m_bActive);
					(*group)->SetUpdateRate(rate);
					(*group)->SetTimeBias(dlg.m_lTimeBias);
					(*group)->SetDeadBand(dlg.m_fDeadBand);
					(*group)->SetLCID(dlg.m_dwLCID);

					if(SUCCEEDED(opcGroup.SetName(A2OLE(dlg.m_sGroup))))
					{
						(*group)->SetName(dlg.m_sGroup);

						((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(_T("Edited group successfuly."));
						bRet = (*group)->SetDataChangeEnabled(dlg.m_bDataChange);
					}
				}
			}
		}
		CoTaskMemFree(pGroupName);
	}

	return bRet;
}


BOOL CInfoServer::GetStatus()
{
	USES_CONVERSION;

	CServerStatusDlg	dlg;
	OPCSERVERSTATUS*	pServerStatus;
	BOOL				bRet = FALSE;
	CIOPCServer			opcServer(m_pUnkn);
	HRESULT				res;

	res = opcServer.GetStatus(&pServerStatus);
	if(SUCCEEDED(res))
	{
		if(pServerStatus->dwBandWidth == 0xFFFFFFFF)
			dlg.m_sBandwidth.Format(IDS_OPC_UNKNOWN);
		else
			dlg.m_sBandwidth.Format("%d", pServerStatus->dwBandWidth);

		dlg.m_sGroups.Format("%d",pServerStatus->dwGroupCount);

		if(pServerStatus->ftStartTime.dwHighDateTime != 0)
		{
			CTime tStart(pServerStatus->ftStartTime);
			dlg.m_sStartTime = tStart.Format(_T("%c"));
		}
		else
			dlg.m_sStartTime.Format(IDS_OPC_UNKNOWN);

		if(pServerStatus->ftCurrentTime.dwHighDateTime != 0)
		{
			CTime tCurrent(pServerStatus->ftCurrentTime);
			dlg.m_sCurrentTime = tCurrent.Format(_T("%c"));
		}
		else
			dlg.m_sCurrentTime.Format(IDS_OPC_UNKNOWN);

		if(pServerStatus->ftLastUpdateTime.dwHighDateTime != 0)
		{
			CTime tLastUpdate(pServerStatus->ftLastUpdateTime);
			dlg.m_sLastUpdateTime = tLastUpdate.Format(_T("%c"));
		}
		else
			dlg.m_sLastUpdateTime.Format(IDS_OPC_NOUPDATES);

		switch(pServerStatus->dwServerState)
		{
			case OPC_STATUS_FAILED:
			{
				 dlg.m_sStatus.Format(IDS_OPC_SERVER_STATUS_FAILED);
				 break;
			}
			case OPC_STATUS_RUNNING:
			{
				 dlg.m_sStatus.Format(IDS_OPC_SERVER_STATUS_RUNNING);
				 break;
			}
			case OPC_STATUS_NOCONFIG:
			{
				 dlg.m_sStatus.Format(IDS_OPC_SERVER_STATUS_NOCONFIG);
				 break;
			}
			case OPC_STATUS_SUSPENDED:
			{
				 dlg.m_sStatus.Format(IDS_OPC_SERVER_STATUS_SUSPENDED);
				 break;
			}
			case OPC_STATUS_TEST:
			{
				 dlg.m_sStatus.Format(IDS_OPC_SERVER_STATUS_TEST);
				 break;
			}
			default:
			{
				 dlg.m_sStatus.Format(IDS_OPC_UNKNOWN);
				 break;
			}
		}

		dlg.m_sVendorInfo = OLE2A(pServerStatus->szVendorInfo);
		
		dlg.m_sMayorVersion.Format("%d", pServerStatus->wMajorVersion);
		dlg.m_sMinorVersion.Format("%d", pServerStatus->wMinorVersion);
		dlg.m_sBuildNumber.Format("%d", pServerStatus->wBuildNumber);

		((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(_T("GetStatus() returned success."));
		
		dlg.DoModal();

		bRet = TRUE;
	}
	else
	{
		bRet = FALSE;
		((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(_T("GetStatus()"), res);
	}

	if(NULL !=pServerStatus)
	{
		CoTaskMemFree(pServerStatus->szVendorInfo);
		CoTaskMemFree(pServerStatus);
	}

	return bRet;
}

CComPtr<IUnknown> CInfoServer::GetInterface()
{
	return m_pUnkn;
}

CIAdviseSink** CInfoServer::GetAdviseSink()
{
	return &m_pAdviseSink;
}

CComObject<COPCConnectionPoint>** CInfoServer::GetDataAccessConnectionPoint()
{
	return &m_pDataAccessConnectionPoint;
}

BOOL CInfoServer::GetErrorString(HRESULT hr, CString& sErrorText)
{
	USES_CONVERSION;

	BOOL	bRet = FALSE;
	BOOL	bStringSet = FALSE;

	try
	{
		if((m_pUnkn != NULL) && IsConnected())
		{
			CIOPCServer	opcServer(m_pUnkn);
			LPWSTR		pErrorString = NULL;
			
			//returns error texts for OPC and windows errors
			hr = opcServer.GetErrorString(hr, 0, &pErrorString);
			if(SUCCEEDED(hr))
			{
				sErrorText = OLE2A(pErrorString);
				bRet = TRUE;
				bStringSet = TRUE;
			}
			
			CoTaskMemFree(pErrorString);
		}
	}
	catch(...)
	{
		//go ahead an try GetSystemErrorString
	}

	if(!bStringSet)
	{
		bRet = GetSystemErrorString(hr, sErrorText);
	}

	return bRet;
}

BOOL CInfoServer::GetSystemErrorString(HRESULT hr, CString& sErrorText)
{
	TCHAR* sMsg = NULL;
	CString sErrorHRESULT;

	try
	{
		if(HRESULT_FACILITY(hr) == FACILITY_WINDOWS)
			hr = HRESULT_CODE(hr);
			
		if(0 != FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
						 NULL,
						 hr,
						 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
						 (LPTSTR)&sMsg, 0, NULL ))
		{
			sErrorHRESULT.Format(_T(" (%#x)."), hr);
			sErrorText = CString(sMsg) + sErrorHRESULT;
			LocalFree(sMsg);
			return TRUE;
		}
	}
	catch(...)
	{
		sErrorText = _T("Exception in CInfoServer::GetSystemErrorString()");
		TRACE(sErrorText);
	}

	return FALSE;
}

//for convinience
BOOL CInfoServer::DisplayError(HRESULT dwError)
{
	((CInfoServerExplorerApp*)AfxGetApp())->DisplayText(dwError);

	return TRUE;
}

unsigned int CInfoServer::GetGroups(CArray<CGroup*, CGroup*>** groups)
{
	*groups = &m_Groups;
	return((*groups)->GetSize());
}


//options
float  CInfoServer::GetOPCVersion()
{
	return m_fOPCVersion;
}

void  CInfoServer::SetOPCVersion(float opc_version)
{
	m_fOPCVersion = opc_version;
}

int CInfoServer::GetDataChangeType()
{
	return m_iDataChangeType;
}

void CInfoServer::SetDataChangeType(int iDataChangeType)
{
	m_iDataChangeType = iDataChangeType;
}

UINT  CInfoServer::GetReloadEnumNextElements()
{
	return m_iReloadEnumNextElements;
}

void  CInfoServer::SetReloadEnumNextElements(UINT elements)
{
	m_iReloadEnumNextElements = elements;
}

/*
	m_iReloadEnumMethod = 0: with IID_IEnumString
	m_iReloadEnumMethod = 1: with IID_IEnumunknown
*/
int  CInfoServer::GetReloadEnumMethod()
{
	return m_iReloadEnumMethod;
}

void  CInfoServer::SetReloadEnumMethod(int new_method)
{
	m_iReloadEnumMethod = new_method;
}

UINT CInfoServer::GetReloadEnumAttributesNextElements()
{
	return m_iReloadEnumAttributesNextElements;
}

void CInfoServer::SetReloadEnumAttributesNextElements(UINT elements)
{
	m_iReloadEnumAttributesNextElements = elements;
}

UINT CInfoServer::GetBrowserEnumNextElements()
{
	return m_iBrowserEnumNextElements;
}

void CInfoServer::SetBrowserEnumNextElements(UINT elements)
{
	m_iBrowserEnumNextElements = elements;
}

BOOL CInfoServer::UseValidateItems()
{
	return m_bUseValidateItems;
}

void CInfoServer::SetUseValidateItems(BOOL bUseValidateItems)
{
	m_bUseValidateItems = bUseValidateItems;
}



void CInfoServer::SetOPCServer(CString sOPCServer)
{
	m_sOPCServer = sOPCServer;
}

CString CInfoServer::GetOPCServer()
{
	return m_sOPCServer;
}

void CInfoServer::SetOPCServerComputer(CString sOPCServerComputer)
{
	m_sOPCServerComputer = sOPCServerComputer;
}

CString CInfoServer::GetOPCServerComputer()
{
	return m_sOPCServerComputer;
}

CString CInfoServer::GetOPCServerName()
{
	return m_sOPCServerComputer + CString(_T("\\")) + m_sOPCServer;
}

void CInfoServer::SetOPCServerCLSID(CLSID clsidOPCServer)
{
	m_clsidOPCServer = clsidOPCServer;
}

CLSID CInfoServer::GetOPCServerCLSID()
{
	return m_clsidOPCServer;
}