hotopcserver.h

VC 编写的OPC客户端

	void SetLanguageID (LCID lcid) {m_dwLanguageID = lcid;}
	LCID GetLanguageID () {return (m_dwLanguageID);}

	void SetActive (BOOL bActive, BOOL bApply = FALSE) 
	{
		/*m_bActive = bActive;

		// apply change to server now
		if (bApply && m_pIGroupState)
		{
			DWORD dwRevRate; // for [out] parm
			m_pIGroupState->SetState (NULL, &dwRevRate, &m_bActive, NULL, NULL, NULL, NULL);

			// select the activated group
			CKMainWnd *pWnd = (CKMainWnd *) AfxGetMainWnd ();
			if (pWnd)
				pWnd->PostMessage (UM_SELECT_GROUP, 0, (LPARAM) this);

			// log status
			LogMsg (IDS_SET_GROUP_ACTIVE_STATE, bActive, GetName ());
		}*/
	}

	BOOL IsActive () {return (m_bActive);}

	void SetBias (long lBias) {m_lBias = lBias;}
	long GetBias () {return (m_lBias);}

	void SetDeadband (float fDeadband) {m_fDeadband = fDeadband;}
	float GetDeadband () {return (m_fDeadband);}

	void SetServerHandle (OPCHANDLE hServer) {m_hServer = hServer;}
	OPCHANDLE GetServerHandle () {return (m_hServer);}

	void SetValid (BOOL bValid) {m_bValid = bValid;}
	BOOL IsValid () {return (m_bValid);}

	void SetUpdateMethod (DWORD dwMethod) {m_dwUpdateMethod = dwMethod;}
	DWORD GetUpdateMethod () {return (m_dwUpdateMethod);}

	// flag accessor/manipulators
	void ForceDeletion (BOOL bSet) {m_bfFlags.bOnDeleteForceDeletion = bSet;}
	BOOL IsForceDeletion () {return (m_bfFlags.bOnDeleteForceDeletion);}

	// OPC Specifics
	void Initialize (LPUNKNOWN pUnk);
	void Uninitialize (bool bDelete = true);

	bool SetItemActiveState (CObArray &cItemList, DWORD cdwItems, bool bActive);

	void ReadSync (CObArray &cItemList, DWORD cdwItems, bool bDeviceRead, bool bPostMsg = true);
	void WriteSync (CObArray &cItemList, CStringArray &cValues, DWORD cdwItems);

	void ReadAsync10 (CObArray &cItemList, DWORD cdwItems, bool bDeviceRead);
	void RefreshAsync10 (bool bDeviceRead);
	void WriteAsync10 (CObArray &cItemList, CStringArray &cValues, DWORD cdwItems);

	void ReadAsync20 (CObArray &cItemList, DWORD cdwItems);
	void RefreshAsync20 (bool bDeviceRead);
	void WriteAsync20 (CObArray &cItemList, CStringArray &cValues, DWORD cdwItems);

	CHotOpcGroup* Clone ();

	
	
	void Start ();

	void ExportCsv (CStdioFile &csv);
	void ImportCsv (CStdioFile &csv, CObArray &cItemList, DWORD &cdwItems);

	// cut/copy/paste
	void Copy (CFixedSharedFile &sf);
	void Paste (CFixedSharedFile &sf);

	// parent server access
	CHotOpcServer* GetParentServer () {return (m_pServer);}

	// list management
	void SetPrev (CHotOpcGroup *pPrev) {m_pPrev = pPrev;}
	CHotOpcGroup* GetPrev () {return (m_pPrev);}

	void SetNext (CHotOpcGroup *pNext) {m_pNext = pNext;}
	CHotOpcGroup* GetNext () {return (m_pNext);}

	// item management
	void AddItems (CObArray &cItemList, DWORD dwCount, bool bLoadingProject = false);

	void RemoveItems (CObArray &cItemList, DWORD dwCount, bool bDelete = true);
	void RemoveAllItems (bool bDelete = true);

	CHotOpcItem* GetItemHead () {return (m_pItemHead);}
	DWORD GetItemCount () {return (m_cdwItems);}

	bool IsIGroupStateMgtSupported () {return (m_pIGroupState != NULL);}
	bool IsIPublicGroupStateMgtSupported () {return (m_pIPublicGroupState != NULL);}
	bool IsIItemMgtSupported () {return (m_pIItemMgt != NULL);}
	bool IsISyncIOSupported () {return (m_pISync != NULL);}
	bool IsIAsyncIOSupported () {return (m_pIAsync != NULL);}
	bool IsIDataObjectSupported () {return (m_pIDataObject != NULL);}
	bool IsIAsyncIO2Supported () {return (m_pIAsync2 != NULL);}
	bool IsIConnectionPointContainerSupported () {return (m_pIConnPtContainer != NULL);}

	IOPCItemMgt* GetIItemMgt () {return (m_pIItemMgt);}
	IOPCGroupStateMgt* GetIGroupStateMgt () {return (m_pIGroupState);}
	IOPCSyncIO* GetISyncIO () {return (m_pISync);}

private:
	bool MapStringValToVariant (CString &strValue, VARIANT &vtVal, VARTYPE vtType);

	typedef enum _tagGETARRELEMRET
	{
		tElement = 0,
		tEndRow,
		tInvalid,
		tOverflow,
		tDone
	} GETARRELEMRET;

	GETARRELEMRET GetArrayElement (LPCTSTR szInBuff, int *pnStart, LPTSTR szOutBuff, int nBuffSize);
	bool MapStringValToArrayVariant (CString &strValue, VARIANT *pvtSrc, VARIANT *pvtDst);

	void AddItemToList (CHotOpcItem *pItem);
	void RemoveItemFromList (CHotOpcItem *pItem);

private:
	// properties
	CString m_strName;		// group name

	DWORD m_dwUpdateRate;	// update rate in milliseconds
	LCID m_dwLanguageID;	// language ID

	BOOL m_bActive;			// active state
	long m_lBias;			// time bias in minutes
	float m_fDeadband;		// percent deadband

	OPCHANDLE m_hServer;	// server handle for this group
	BOOL m_bValid;			// TRUE if successfully added to the OPC server
	DWORD m_dwUpdateMethod;	// update method used by this group (see globals.h)

	typedef struct _flags
	{
		DWORD bOnDeleteForceDeletion	: 1;	// TRUE if the server should force deletion of group even if references exists
		//			DWORD bOnDeleteRemoveItems		: 1;	// TRUE if the client should remove items before remove group
		DWORD Reserved					: 31;
	} FLAGS;

	FLAGS m_bfFlags;

	// OPC specifics
	IOPCGroupStateMgt *m_pIGroupState;
	IOPCPublicGroupStateMgt *m_pIPublicGroupState;
	IOPCItemMgt *m_pIItemMgt;
	IOPCSyncIO *m_pISync;
	IOPCAsyncIO *m_pIAsync;
	IDataObject *m_pIDataObject;
	IOPCAsyncIO2 *m_pIAsync2;
	IConnectionPointContainer *m_pIConnPtContainer;

	IKDataSink20 *m_pIDataSink20;
	DWORD m_dwCookieDataSink20;

	CKAdviseSink *m_pIAdviseSink;
	DWORD m_dwCookieRead;
	DWORD m_dwCookieWrite;

	// parent server
	CHotOpcServer *m_pServer;

	// list management
	CHotOpcGroup *m_pPrev;
	CHotOpcGroup *m_pNext;

	// item management
	CHotOpcItem *m_pItemHead;
	DWORD m_cdwItems;

public:
	virtual void Serialize(CArchive& ar);
};

// **************************************************************************
// CHotOpcItem 命令目标
/*---------------------------------------------
CHotOpcItem类

desc:...

----------------------------------------------*/
class CHotOpcItem : public CObject  
{
public:
	// construction/destruction
	CHotOpcItem (CHotOpcGroup *pParent);
	~CHotOpcItem ();

public:
	// property accessor/manipulators
	void SetAccessPath (LPCTSTR strAccessPath) {m_strAccessPath = strAccessPath;}
	LPCTSTR GetAccessPath () {return (m_strAccessPath);}

	void SetActive (BOOL bActive) {m_bActive = bActive;}
	BOOL IsActive () {return (m_bActive);}

	void SetDataType (VARTYPE vtType) {m_vtDataType = vtType;}
	VARTYPE GetDataType () 
	{
		if (m_vtValue.vt != VT_EMPTY)
			return (m_vtValue.vt);

		return (m_vtDataType);
	}

	void SetItemID (LPCTSTR strItemID) {m_strItemID = strItemID;}
	LPCTSTR GetItemID () {return (m_strItemID);}

	void SetServerHandle (OPCHANDLE hServer) {m_hServer = hServer;}
	OPCHANDLE GetServerHandle () {return (m_hServer);}

	void SetAccessRights (DWORD dwAccess) {m_dwAccessRights = dwAccess;}
	DWORD GetAccessRights () {return (m_dwAccessRights);}

	void SetValid (BOOL bValid) 
	{
		m_bValid = bValid;

		if (!bValid)
		{
			m_wQuality = OPC_QUALITY_BAD_OUT_OF_SERVICE;
			m_cdwUpdates = 0;
			m_bTimeStamped = FALSE;

			VariantInit (&m_vtValue);
		}
	}

	BOOL IsValid () {return (m_bValid);}

	// data
	void UpdateData (VARIANT &vtVal, WORD wQuality);
	void UpdateData (VARIANT &vtVal, WORD wQuality, FILETIME &ftTimeStamp);

	void GetValue (CString &strValue);
	LPCTSTR GetQuality ();
	void GetTimeStamp (CString &strTimeStamp);
	DWORD GetUpdateCount ();

	// This can be dangerous!!
	VARIANT* GetValue () {return (&m_vtValue);}


	// cut/copy/paste
	void Copy (CFixedSharedFile &sf);
	void Paste (CFixedSharedFile &sf);

	// parent group access
	CHotOpcGroup* GetParentGroup () {return (m_pGroup);}

	// list management
	void SetPrev (CHotOpcItem *pPrev) {m_pPrev = pPrev;}
	CHotOpcItem* GetPrev () {return (m_pPrev);}

	void SetNext (CHotOpcItem *pNext) {m_pNext = pNext;}
	CHotOpcItem* GetNext () {return (m_pNext);}

	// GUI management
	void SetWParam (WPARAM wParam) {m_wParam = wParam;}
	WPARAM GetWParam () {return (m_wParam);}

private:
	// properties
	CString m_strAccessPath;	// access path
	CString m_strItemID;		// fully qualified item ID
	BOOL m_bActive;				// active state
	VARTYPE m_vtDataType;		// server's canonical datatype
	DWORD m_dwAccessRights;		// access rights
	OPCHANDLE m_hServer;		// server handle for this item

	typedef struct _flags
	{
		DWORD Reserved					: 32;
	} FLAGS;

	FLAGS m_bfFlags;

	BOOL m_bValid;				// TRUE if successfully added to an OPC server
	BOOL m_bTimeStamped;		// TRUE if the last update included a timestamp

	// data
	FILETIME m_ftTimeStamp;		// timestamp attached to value
	WORD m_wQuality;			// quality attached to value
	VARIANT m_vtValue;			// current value

	DWORD m_cdwUpdates;

	// parent server
	CHotOpcGroup *m_pGroup;

	// list management
	CHotOpcItem *m_pPrev;
	CHotOpcItem *m_pNext;

	// threading
	CCriticalSection m_csDataLock;

	// GUI management
	WPARAM m_wParam;
public:
	virtual void Serialize(CArchive& ar);
};

// **************************************************************************
// CFixedSharedFile 命令目标
/*---------------------------------------------
CFixedSharedFile类

desc:...

----------------------------------------------*/
class CFixedSharedFile : public CSharedFile
{
public:
	CFixedSharedFile (int nGrowBy = 128) : CSharedFile (GMEM_DDESHARE | GMEM_MOVEABLE, nGrowBy)
	{
	}

	BYTE* GetBuffer ()	// Enhancement (must be used with care)
	{
		ASSERT (m_lpBuffer);
		return (m_lpBuffer);
	}

	HGLOBAL Detach ()
	{
		ASSERT (m_hGlobalMemory != NULL);
		HGLOBAL hMem = m_hGlobalMemory;
		m_hGlobalMemory = NULL; // detach from global handle

		// This is the fix
		::GlobalUnlock (hMem);

		// re-initialize the CMemFile parts too
		m_lpBuffer = NULL;
		m_nBufferSize = 0;

		return hMem;
	}

	// Enhancement to allow data to be transfered to the clipboard
	BOOL CopyToClipboard (UINT uFmt)
	{
		// Open the clipboard
		if (!::OpenClipboard (NULL))
		{
			TRACE (_T("Shared Memory: Failed to open the clipboard\n"));
			return (false);
		}

		TRACE (_T("Copying %u bytes to the clipboard (uFmt == %u)\n"), GetLength (), uFmt);
		ASSERT (GetLength ());

		// Clear out current contents
		::EmptyClipboard ();

		// Stick the data in
		HANDLE hData = ::SetClipboardData (uFmt, Detach ());
		::CloseClipboard ();

		// Check for success
		if (!hData)
		{
			TRACE (_T("SetClipboardData () failed [OS Error == %u]\n"), GetLastError ());
			ASSERT (FALSE);
		}

		return (hData != NULL);
	}

protected:

};