Kleine Anpassungen

OEM.cfg

@@ -4,7 +4,7 @@ uuid =
 );
 
 logconf = {
-	database = "OEMLog";
+	database = "$(OEM)Log";
 	tagtable = "Tags";
 	logtable = "Logs";
 	user = "root";
@@ -30,7 +30,7 @@ logsumconf =
 };
 
 remlogconf = {
-         database = "OEMRem";
+         database = "$(OEM)Rem";
          logtable = "Logs";
          user = "root";
          pass = "root";
@@ -43,7 +43,7 @@ restconf = {
 
 mqttconf =
 {
-    cfg_file_path = "/opt/GfA/OEM/mqttcl/mqttcl.conf.json"
+    cfg_file_path = "/opt/GfA/$(OEM)/mqttcl/mqttcl.conf.json"
 };
 
 sinclude = (

OEM.pri

@@ -1,8 +1,8 @@
 ###################################################
 
-CFG_INFILE		= OEM.cfg
+CFG_INFILE		= $(OEM).cfg
 CFG_OUTDIR		= .
-CFG_BASENAME	= OEM
+CFG_BASENAME	= $(OEM)
 DEPLOY_BASEDIR	= /opt/GfA
 DEPLOY_SUBDIR	= $$CFG_BASENAME
 #GEB_SEARCHDIR	= /path/to/geb/files

install.cfg

@@ -1,6 +1,7 @@
 config =
 {
-	oempattern = "OEM";
+	oemcontpat = "$(OEM)";
+	oemfilepat = "OEM";
 };
 
 oemsubstfiles =
@@ -12,7 +13,7 @@ oemsubstfiles =
 	"usr/visu/qml/shm.qml"
 );
 
-oemrenamefiles =
+oemrenfiles =
 (
 	"OEM.pro",
 	"OEM.pri",

projal.pri

@@ -1,4 +1,4 @@
-include(OEM.pri)
+include($(OEM).pri)
 
 GEBVARS			= gfagebvars
 SHMCONF			= gfashmconf

usr/visu/qml/shm.qml

@@ -4,7 +4,7 @@ import QtQuick.Controls 1.5
 import QtQuick.Controls.Styles 1.4
 import QtQuick.Controls.Private 1.0
 import com.gfa.ipc.appctrl 1.0
-import com.gfa.shm.oem 1.0
+import com.gfa.shm.$(oem) 1.0
 
 Rectangle {
     width: 800

usr/visu/var/shmbitvar.cpp

@@ -1,122 +0,0 @@
-#include "shmvar.h"
-#include <QDebug>
-
-#define GET_BOOL_VAL(p, m)				(!!(*p & m))
-#define SET_BIT(p, m)					(*p |= m)
-#define CLR_BIT(p, m)					(*p &= ~m)
-#define STORE_BIT(p, m, b)				(b) ? SET_BIT(p, m) : CLR_BIT(p, m)
-
-CShmBitVariable::CShmBitVariable(void *pData, size_t nOffset, int nBitNr, HSHM hShm, const char *pszName, QObject *pParent)
-								: QObject(pParent), m_varName(pszName), m_nBitNr(nBitNr)
-{
-	if(!pData || !hShm || (nBitNr > 7))
-	{
-		Q_ASSERT_X(false, "CShmBitVariable::CShmBitVariable", "Invalid parameter!");
-		return;
-	}
-
-	m_mask = (1 << nBitNr);
-    m_pShmByte = (uint8_t*)pData + nOffset;
-    m_cacheVal = GET_BOOL_VAL(m_pShmByte, m_mask);
-    m_hShm = hShm;
-    setObjectName(QStringLiteral("CShmBitVariable"));
-}
-
-CShmBitVariable::~CShmBitVariable(void)
-{
-}
-
-void CShmBitVariable::valRaw(QVariant &v)
-{
-	bool bVal = GET_BOOL_VAL(m_pShmByte, m_mask);
-	v.setValue(bVal);
-}
-
-QVariant CShmBitVariable::val(void)
-{
-	QVariant v;
-	Lock();
-	valRaw(v);
-	Unlock();
-    return v;
-}
-
-void CShmBitVariable::setVal(const QVariant &val)
-{
-	if(val.isValid() && !val.isNull())
-	{
-#if _TRACK_QT_WRITES
-		char szDebugOut[256];
-#endif	//	_TRACK_QT_WRITES
-
-		if(val.canConvert<bool>())
-		{
-			Lock();
-			bool bVal = GET_BOOL_VAL(m_pShmByte, m_mask);
-			m_cacheVal = val.toBool();
-
-			if(bVal != m_cacheVal)
-			{
-				STORE_BIT(m_pShmByte, m_mask, m_cacheVal);
-				emitChanged(false);
-#if _TRACK_QT_WRITES
-				sprintf(szDebugOut, "CShmBitVariable::setVal: Bit %s : %c", m_varName.toStdString().c_str(), m_cacheVal ? '1' : '0');
-    			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-			}
-			Unlock();
-		}
-	}
-}
-
-unsigned int CShmBitVariable::vt(void) const
-{
-	return VT_bool;
-}
-
-unsigned long long CShmBitVariable::CheckUpdateShm(bool fLock)
-{
-	CHECK_UPDATE_SHM_RETVAL rv = {1, 0};
-
-	if(fLock)
-		Lock();
-		
-	bool bVal = GET_BOOL_VAL(m_pShmByte, m_mask);
-
-	if(m_cacheVal != bVal)
-	{
-	    m_cacheVal = bVal;
-		emitChanged(false);
-		rv.nUpdated = 1;
-	}
-
-	if(fLock)
-		Unlock();
-
-	return rv.nRetval;
-}
-
-void CShmBitVariable::Lock(void)
-{
-	::GfaIpcLockSHM(m_hShm);
-//	qDebug() << "CShmBitVariable::Lock";
-}
-
-void CShmBitVariable::Unlock(void)
-{
-//	qDebug() << "CShmBitVariable::Unlock";
-	::GfaIpcUnlockSHM(m_hShm);
-}
-
-void CShmBitVariable::emitChanged(bool fLock)
-{
-//    qDebug() << "val changed!";
-	if(fLock)
-	    emit valChanged(val());
-	else
-	{
-	    QVariant v;
-	    valRaw(v);
-	    emit valChanged(v);
-	}
-}

usr/visu/var/shmstrvar.cpp

@@ -1,339 +0,0 @@
-#include "shmvar.h"
-#include <gfa/svc/common/conv.h>
-#include <QDebug>
-
-
-#define _IS_VALID_VT(vt)		((vt > CShmStringVariable::VT_Invalid) && (vt < CShmStringVariable::VT_Last))
-#define __min(x, y) 			((x) < (y) ? (x) : (y))
-#define __max(x, y) 			((x) > (y) ? (x) : (y))
-
-CShmStringVariable::CShmStringVariable(void *pData, size_t nCChData, VT vt, const std::type_info &rti, HSHM hShm, const char *pszName, int nIndex, QObject *pParent)
-										: QObject(pParent), m_vt(VT_Invalid), m_data({NULL}), m_cache({NULL}), m_nCbString(0), m_varName(pszName)
-{
-	if(!pData || !hShm || !nCChData || !_IS_VALID_VT(vt))
-	{
-		Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Invalid parameter!");
-		return;
-	}
-
-	m_vt = vt;
-    m_data.pVoid = pData;
-    m_hShm = hShm;
-    setObjectName(QStringLiteral("CShmStringVariable"));
-    if((m_nIndex = nIndex) >= 0)
-	{
-		m_varName += QString("%1%2%3").arg('[').arg(nIndex).arg(']');
-	}
-
-    if( (rti == typeid(char)) ||
-        (rti == typeid(signed char)) ||
-        (rti == typeid(unsigned char)))
-    {
-    	switch(vt)
-    	{
-   		case VT_Latin1:
-   		case VT_UTF_8:
-			m_nCbBuffer = nCChData;
-			m_cache.pVoid = ::malloc(m_nCbBuffer);
-			zeroTerm(m_data, nCChData - 1);
-			memcpy(m_cache.pVoid, m_data.pVoid, m_nCbBuffer);
-			m_nCbString = strlen(m_cache.pszMbs);
-   			break;
-   		case VT_UTF_16:
-   		case VT_UTF_32:
-		case VT_Unicode:
-            Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "data type does not support encoding type!");
-   			return;
-   		default:
-			Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Invalid string type!");
-   			return;
-    	}
-    }
-    else if(rti == typeid(char16_t))
-	{
-    	switch(vt)
-    	{
-   		case VT_UTF_16:
-			m_nCbBuffer = nCChData * sizeof(char16_t);
-			m_cache.pVoid = malloc(m_nCbBuffer);
-			zeroTerm(m_data, nCChData - 1);
-			memcpy(m_cache.pVoid, m_data.pVoid, m_nCbBuffer);
-			m_nCbString = wcs16len(m_cache.pszWc16) * sizeof(char16_t);
-   			break;
-		case VT_Unicode:
-   		case VT_Latin1:
-   		case VT_UTF_8:
-   		case VT_UTF_32:
-            Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "data type does not support encoding type!");
-   			return;
-   		default:
-			Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Invalid string type!");
-   			return;
-    	}
-	}
-    else if(rti == typeid(char32_t))
-	{
-    	switch(vt)
-    	{
-   		case VT_UTF_32:
-			m_nCbBuffer = nCChData * sizeof(char32_t);
-			m_cache.pVoid = malloc(m_nCbBuffer);
-			zeroTerm(m_data, nCChData - 1);
-			memcpy(m_cache.pVoid, m_data.pVoid, m_nCbBuffer);
-			m_nCbString = wcs32len(m_cache.pszWc32) * sizeof(char32_t);
-   			break;
-		case VT_Unicode:
-   		case VT_Latin1:
-   		case VT_UTF_8:
-   		case VT_UTF_16:
-            Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "data type does not support encoding type!");
-   			return;
-   		default:
-			Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Invalid string type!");
-   			return;
-    	}
-	}
-    else if(rti == typeid(wchar_t))
-	{
-    	switch(vt)
-    	{
-		case VT_Unicode:
-			m_nCbBuffer = nCChData * sizeof(wchar_t);
-			m_cache.pVoid = malloc(m_nCbBuffer);
-			zeroTerm(m_data, nCChData - 1);
-			memcpy(m_cache.pVoid, m_data.pVoid, m_nCbBuffer);
-			m_nCbString = wcslen(m_cache.pszWcs) * sizeof(wchar_t);
-   			break;
-   		case VT_Latin1:
-   		case VT_UTF_8:
-   		case VT_UTF_16:
-   		case VT_UTF_32:
-            Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "data type does not support encoding type!");
-   			return;
-   		default:
-			Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Invalid string type!");
-   			return;
-    	}
-	}
-    else
-	{
-        Q_ASSERT_X(false, "CShmStringVariable::CShmStringVariable", "Unrecognized data type!");
-	}
-}
-
-CShmStringVariable::~CShmStringVariable(void)
-{
-	if(m_cache.pVoid)
-		::free(m_cache.pVoid);
-}
-
-void CShmStringVariable::valRaw(QString &v)
-{
-	switch(m_vt)
-	{
-	case VT_Latin1:
-		v = QString::fromLatin1(m_data.pszMbs, m_nCbString);
-		break;
-	case VT_UTF_8:
-		v = QString::fromUtf8(m_data.pszMbs, m_nCbString);
-		break;
-	case VT_UTF_16:
-		v = QString::fromUtf16(m_data.pszWc16, m_nCbString / sizeof(char16_t));
-		break;
-	case VT_UTF_32:
-		v = QString::fromUcs4(m_data.pszWc32, m_nCbString / sizeof(char32_t));
-		break;
-	case VT_Unicode:
-		v = QString::fromWCharArray(m_data.pszWcs, m_nCbString / sizeof(wchar_t));
-		break;
-	default:
-//		Q_ASSERT_X(false, "CShmStringVariable::valRaw", "Unrecognized string type!");
-		break;
-	}
-}
-
-QString CShmStringVariable::val(void)
-{
-	QString v;
-	Lock();
-	valRaw(v);
-	Unlock();
-    return v;
-}
-
-void CShmStringVariable::setVal(const QString &val)
-{
-	QByteArray ba;
-	QVector<uint> vec;
-	size_t nCbVal = 0, nCChVal = 0;
-	wchar_t *pszData;
-	const void *pData;
-
-	switch(m_vt)
-	{
-	case VT_Latin1:
-		ba = val.toLatin1();
-		nCbVal = ba.size();
-		nCbVal = __min(nCbVal, m_nCbBuffer - 1);
-		nCChVal = nCbVal;
-		pData = ba.data();
-		break;
-	case VT_UTF_8:
-		ba = val.toUtf8();
-		nCbVal = ba.size();
-		nCbVal = __min(nCbVal, m_nCbBuffer - 1);
-		nCChVal = nCbVal;
-		pData = ba.data();
-		break;
-	case VT_UTF_16:
-		nCbVal = val.size() * sizeof(char16_t);
-		nCbVal = __min(nCbVal, m_nCbBuffer - sizeof(char16_t));
-		nCChVal = nCbVal / sizeof(char16_t);
-		pData = val.utf16();
-		break;
-	case VT_UTF_32:
-		vec = val.toUcs4();
-		nCbVal = vec.size() * sizeof(char32_t);
-		nCbVal = __min(nCbVal, m_nCbBuffer - sizeof(char32_t));
-		nCChVal = nCbVal / sizeof(char32_t);
-		pData = vec.data();
-		break;
-	case VT_Unicode:
-		nCChVal = val.size();
-		nCbVal = nCChVal * sizeof(wchar_t);
-		pszData = (wchar_t*)alloca(nCbVal);
-		val.toWCharArray(pszData);
-		nCbVal = __min(nCbVal, m_nCbBuffer - sizeof(wchar_t));
-		nCChVal = nCbVal / sizeof(wchar_t);
-		pData = pszData;
-		break;
-	default:
-        Q_ASSERT_X(false, "CShmStringVariable::setVal", "Unrecognized string type!");
-		return;
-	}
-	
-	Lock();
-	m_nCbString = nCbVal;
-	memcpy(m_cache.pVoid, pData, m_nCbString);
-	zeroTerm(m_cache, nCChVal);
-	
-	if(shmChanged(false))
-	{
-		memcpy(m_data.pVoid, m_cache.pVoid, m_nCbString);
-		zeroTerm(m_data, nCChVal);
-		emitChanged(false);
-	}
-	Unlock();
-}
-
-void CShmStringVariable::zeroTerm(volatile V_Ptr &rp, size_t at)
-{
-	switch(m_vt)
-	{
-	case VT_Latin1:
-	case VT_UTF_8:
-		rp.pszMbs[at] = '\0';
-		break;
-	case VT_UTF_16:
-		rp.pszWc16[at] = (char16_t)0;
-		break;
-	case VT_UTF_32:
-		rp.pszWc32[at] = (char32_t)0;
-		break;
-	case VT_Unicode:
-		rp.pszWcs[at] = L'\0';
-		break;
-	default:
-//        Q_ASSERT_X(false, "CShmStringVariable::zeroTerm", "Unrecognized string type!");
-		return;
-	}
-}
-
-unsigned int CShmStringVariable::vt(void) const
-{
-	return CShmVariable::VT_string;
-}
-
-unsigned long long CShmStringVariable::CheckUpdateShm(bool fLock)
-{
-	CHECK_UPDATE_SHM_RETVAL rv = {1, 0};
-	size_t nCChBuf = 0;
-
-	if(fLock)
-		Lock();
-	
-	if(shmChanged(false))
-	{
-		switch(m_vt)
-		{
-		case VT_Latin1:
-		case VT_UTF_8:
-			nCChBuf = m_nCbBuffer - 1;
-			zeroTerm(m_data, nCChBuf);
-			m_nCbString = strlen(m_data.pszMbs);
-			break;
-		case VT_UTF_16:
-			nCChBuf = m_nCbBuffer / sizeof(char16_t) - 1;
-			zeroTerm(m_data, nCChBuf);
-			m_nCbString = wcs16len(m_data.pszWc16) * sizeof(char16_t);
-			break;
-		case VT_UTF_32:
-			nCChBuf = m_nCbBuffer / sizeof(char32_t) - 1;
-			zeroTerm(m_data, nCChBuf);
-			m_nCbString = wcs32len(m_data.pszWc32) * sizeof(char32_t);
-			break;
-		case VT_Unicode:
-			nCChBuf = m_nCbBuffer / sizeof(wchar_t) - 1;
-			zeroTerm(m_data, nCChBuf);
-			m_nCbString = wcslen(m_data.pszWcs) * sizeof(wchar_t);
-			break;
-		default:
-			return rv.nRetval;
-		}
-
-		memcpy(m_cache.pVoid, m_data.pVoid, m_nCbBuffer);
-		emitChanged(false);
-		rv.nUpdated = 1;
-	}
-
-	if(fLock)
-		Unlock();
-
-	return rv.nRetval;
-}
-
-bool CShmStringVariable::shmChanged(bool fLock)
-{
-	bool bRet;
-	if(fLock)
-		Lock();
-	bRet =  !!memcmp(m_cache.pVoid, m_data.pVoid, m_nCbString + 1);
-	if(fLock)
-		Unlock();
-	return bRet;
-}
-
-void CShmStringVariable::Lock(void)
-{
-	::GfaIpcLockSHM(m_hShm);
-//	qDebug() << "CShmStringVariable::Lock";
-}
-
-void CShmStringVariable::Unlock(void)
-{
-//	qDebug() << "CShmStringVariable::Unlock";
-	::GfaIpcUnlockSHM(m_hShm);
-}
-
-void CShmStringVariable::emitChanged(bool fLock)
-{
-//	qDebug() << "CShmStringVariable: val changed!";
-	if(fLock)
-		emit valChanged(val());
-	else
-	{
-		QString v;
-		valRaw(v);
-		emit valChanged(v);
-	}
-}

usr/visu/var/shmthread.h

@@ -1,230 +0,0 @@
-// shmthread.h :
-//
-
-#if !defined(AGD_SHMTHREAD_H__C09C5E02_A3A0_4171_BA2E_045C3FE0C05C__INCLUDED_)
-#define AGD_SHMTHREAD_H__C09C5E02_A3A0_4171_BA2E_045C3FE0C05C__INCLUDED_
-
-#include <time.h>
-#include <pthread.h>
-#include <gfa/gfaipc.h>
-#include <QDebug>
-#include "shmvar.h"
-
-
-#define _SHM_SNEAK_PEEK					1
-#define _TRACK_TIME						0
-#define _TRACK_UPDATES					0
-
-#define _SHM_SCAN_INTERVAL_MS			100
-
-/////////////////////////////////////////////////////////////////////////////
-
-#define _INVALID_THREAD_ID				0
-
-/////////////////////////////////////////////////////////////////////////////
-// shmthread.h - Declarations:
-
-template<typename T, typename S>
-class CShmWatcher
-{
-public:
-	CShmWatcher(HSHM hShm, T &rT, const void *pShm);
-	virtual ~CShmWatcher(void);
-
-	bool StartWatch(unsigned long nMsInterval = _SHM_SCAN_INTERVAL_MS);
-	void StopWatch(void);
-
-	static void* ShmWatchWorker(void *pParam);
-
-	void Lock(void){
-		::GfaIpcLockSHM(m_hShm);}
-
-	void Unlock(void){
-		::GfaIpcUnlockSHM(m_hShm);}
-
-#if _SHM_SNEAK_PEEK
-	inline bool ShmPeek(void){
-		Lock();
-		bool bRet = !!memcmp(m_pCache, m_pShm, sizeof(S));
-		Unlock();
-		return bRet;}
-
-	inline void UpdateCache(void){
-		Lock();
-		memcpy(m_pCache, m_pShm, sizeof(S));
-		Unlock();}
-#endif	//	_SHM_SNEAK_PEEK
-
-private:
-	struct timespec m_tsInterval;
-    pthread_t m_threadID;
-    HSHM m_hShm;
-	T &m_rT;
-	S *m_pCache;
-	const void *m_pShm;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-template<typename T, typename S>
-CShmWatcher<T, S>::CShmWatcher(HSHM hShm, T &rT, const void *pShm) :	m_threadID(_INVALID_THREAD_ID),
-						                                                m_hShm(hShm),
-																		m_rT(rT),
-																		m_pCache(NULL),
-																		m_pShm(pShm)
-{
-#if _SHM_SNEAK_PEEK
-	if(m_pShm)
-	{
-		m_pCache = new S;
-		memcpy(m_pCache, pShm, sizeof(S));
-	}
-	else
-	{
-		Q_ASSERT_X(false, "CShmWatcher::CShmWatcher", "Invalid SHM pointer!");
-	}
-#endif	//	_SHM_SNEAK_PEEK
-}
-
-template<typename T, typename S>
-CShmWatcher<T, S>::~CShmWatcher(void)
-{
-	StopWatch();
-
-#if _SHM_SNEAK_PEEK
-	if(m_pCache)
-	{
-		delete m_pCache;
-		m_pCache = NULL;
-	}
-#endif	//	_SHM_SNEAK_PEEK
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-template<typename T, typename S>
-bool CShmWatcher<T, S>::StartWatch(unsigned long nMsInterval)
-{
-	Lock();
-	if(m_threadID != _INVALID_THREAD_ID)
-	{
-		Unlock();
-		return true;
-	}
-	Unlock();
-
-	m_tsInterval.tv_sec		= nMsInterval / 1000;
-	m_tsInterval.tv_nsec	= (nMsInterval % 1000) * 1000000;
-
-	bool bRet = !::pthread_create(&m_threadID, NULL, &CShmWatcher<T, S>::ShmWatchWorker, reinterpret_cast<void*>(this));
-
-	if(!bRet)
-	{
-		m_threadID = _INVALID_THREAD_ID;
-        qDebug() << "CShmWatcher::StartWatch failed!";
-	}
-	else
-	{
-        qDebug() << "CShmWatcher::StartWatch success!";
-	}
-
-	return bRet;
-}
-
-template<typename T, typename S>
-void CShmWatcher<T, S>::StopWatch(void)
-{
-	pthread_t threadID;
-
-	Lock();
-	if((threadID = m_threadID) != _INVALID_THREAD_ID)
-		m_threadID = _INVALID_THREAD_ID;
-	Unlock();
-
-	if(threadID != _INVALID_THREAD_ID)
-	{
-		::pthread_cancel(threadID);
-		::pthread_join(threadID, NULL);
-        qDebug() << "CShmWatcher::StopWatch: thread exit!";
-	}
-}
-
-template<typename T, typename S>
-void* CShmWatcher<T, S>::ShmWatchWorker(void *pParam)
-{
-	if(pParam)
-	{
-#if _TRACK_UPDATES
-		CHECK_UPDATE_SHM_RETVAL rv;
-#endif	//	_TRACK_UPDATES
-
-#if _TRACK_TIME
-		struct timespec tsStart, tsEnd;
-#endif	//	_TRACK_TIME
-
-#if _SHM_SNEAK_PEEK
-		bool bUpdt;
-#endif	//	_SHM_SNEAK_PEEK
-
-		CShmWatcher<T, S>* pSelf = reinterpret_cast<CShmWatcher<T, S>*>(pParam);
-
-		do
-		{
-#if _TRACK_TIME
-			unsigned long long nStart, nEnd;
-			double fTime;
-			::clock_gettime(CLOCK_MONOTONIC, &tsStart);
-#endif	//	_TRACK_TIME
-
-#if _SHM_SNEAK_PEEK
-			bUpdt = pSelf->ShmPeek();
-
-			if(bUpdt)
-			{
-#endif	//	_SHM_SNEAK_PEEK
-
-#if _TRACK_UPDATES
-				rv.nRetval = pSelf->m_rT.CheckUpdateShm();
-#else	//	_TRACK_UPDATES
-				pSelf->m_rT.CheckUpdateShm();
-#endif	//	_TRACK_UPDATES
-
-#if _SHM_SNEAK_PEEK
-				pSelf->UpdateCache();
-			}
-#if _TRACK_UPDATES
-            else
-			{
-				rv.nRetval = 0;
-			}
-#endif	//	_TRACK_UPDATES
-#endif	//	_SHM_SNEAK_PEEK
-
-#if _TRACK_TIME
-            ::clock_gettime(CLOCK_MONOTONIC, &tsEnd);
-            nStart	= tsStart.tv_sec * 1000000000 + tsStart.tv_nsec;
-			nEnd	= tsEnd.tv_sec   * 1000000000 + tsEnd.tv_nsec;
-			fTime = (double)(nEnd - nStart) / 1000000.0;
-            qDebug() << "CShmWatcher::ShmWatchWorker: Scan / Update time: - " << fTime << "ms";
-#endif	//	_TRACK_TIME
-
-#if _TRACK_UPDATES
-            qDebug() << "CShmWatcher::ShmWatchWorker: Variables scanned / updated: - " << rv.nChecked << "/" << rv.nUpdated;
-#endif	//	_TRACK_UPDATES
-
-            ::nanosleep(&pSelf->m_tsInterval, NULL);
-        }
-		while(true);
-
-		pSelf->Lock();
-		pSelf->m_threadID = _INVALID_THREAD_ID;
-		pSelf->Unlock();
-
-        qDebug() << "CShmWatcher::ShmWatchWorker: thread ended gracefully!";
-	}
-
-	return NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-#endif	//	!defined(AGD_SHMTHREAD_H__C09C5E02_A3A0_4171_BA2E_045C3FE0C05C__INCLUDED_)

usr/visu/var/shmvar.cpp

@@ -1,545 +0,0 @@
-#include "shmvar.h"
-#include <QDebug>
-
-CShmVariable::CShmVariable(void *pData, const std::type_info &rti, HSHM hShm, const char *pszName, int nIndex, QObject *pParent)
-							: QObject(pParent), m_vt(VT_Invalid), m_data({NULL}), m_varName(pszName)
-{
-	if(!pData || !hShm)
-	{
-		Q_ASSERT_X(false, "CShmVariable::CShmVariable", "Invalid parameter!");
-		return;
-	}
-
-    m_data.pVoid = pData;
-    m_hShm = hShm;
-    setObjectName(QStringLiteral("CShmVariable"));
-    if((m_nIndex = nIndex) >= 0)
-	{
-		m_varName += QString("%1%2%3").arg('[').arg(nIndex).arg(']');
-	}
-
-    if(rti == typeid(bool))
-    {
-    	m_vt = VT_bool;
-        m_cache.boolVal = *m_data.pBool;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_bool";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(char))
-    {
-#ifdef __CHAR_UNSIGNED__
-    	m_vt = VT_UI1;
-        m_cache.UI1Val = *m_data.pUI1;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_UI1";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-#else
-        m_vt = VT_I1;
-        m_cache.I1Val = *m_data.pI1;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_I1";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-#endif
-    }
-    else if(rti == typeid(signed char))
-    {
-        m_vt = VT_I1;
-        m_cache.I1Val = *m_data.pI1;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_I1";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(unsigned char))
-    {
-    	m_vt = VT_UI1;
-        m_cache.UI1Val = *m_data.pUI1;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_UI1";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(short))
-    {
-    	m_vt = VT_I2;
-        m_cache.I2Val = *m_data.pI2;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_I2";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(unsigned short))
-    {
-    	m_vt = VT_UI2;
-        m_cache.UI2Val = *m_data.pUI2;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_UI2";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(int))
-    {
-    	m_vt = VT_I4;
-        m_cache.I4Val = *m_data.pI4;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_I4";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(unsigned int))
-    {
-    	m_vt = VT_UI4;
-        m_cache.UI4Val = *m_data.pUI4;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_UI4";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(long))
-    {
-    	if(sizeof(long) == sizeof(long long))
-    	{
-	    	m_vt = VT_I8;
-            m_cache.I8Val = *m_data.pI8;
-#if _TRACK_TYPES_AT_LOAD
-            qDebug() << "VT_I8";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-	    }
-    	else
-    	{
-	    	m_vt = VT_I4;
-	        m_cache.I4Val = *m_data.pI4;
-#if _TRACK_TYPES_AT_LOAD
-            qDebug() << "VT_I4";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-	    }
-    }
-    else if(rti == typeid(unsigned long))
-    {
-    	if(sizeof(unsigned long) == sizeof(unsigned long long))
-    	{
-	    	m_vt = VT_UI8;
-            m_cache.UI8Val = *m_data.pUI8;
-#if _TRACK_TYPES_AT_LOAD
-            qDebug() << "VT_UI8";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-	    }
-    	else
-    	{
-	    	m_vt = VT_UI4;
-	        m_cache.UI4Val = *m_data.pUI4;
-#if _TRACK_TYPES_AT_LOAD
-            qDebug() << "VT_UI4";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-	    }
-    }
-    else if(rti == typeid(long long))
-    {
-    	m_vt = VT_I8;
-		m_cache.I8Val = *m_data.pI8;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_I8";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(unsigned long long))
-    {
-    	m_vt = VT_UI8;
-		m_cache.UI8Val = *m_data.pUI8;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_UI8";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(float))
-    {
-    	m_vt = VT_float;
-        m_cache.FloatVal = *m_data.pFloat;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_float";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else if(rti == typeid(double))
-    {
-    	m_vt = VT_double;
-        m_cache.DoubleVal = *m_data.pDouble;
-#if _TRACK_TYPES_AT_LOAD
-        qDebug() << "VT_double";
-#endif	//	_TRACK_TYPES_AT_LOAD    	
-    }
-    else
-	{
-		Q_ASSERT_X(false, "CShmVariable::CShmVariable", "Unknown data type!");
-	}
-}
-
-CShmVariable::~CShmVariable(void)
-{
-}
-
-void CShmVariable::valRaw(QVariant &v)
-{
-	switch(m_vt)
-	{
-	case VT_bool:
-		v.setValue(*m_data.pBool);
-		break;
-	case VT_I1:
-		v.setValue((signed int)*m_data.pI1);
-		break;
-	case VT_UI1:
-		v.setValue((unsigned int)*m_data.pUI1);
-		break;
-	case VT_I2:
-		v.setValue((signed int)*m_data.pI2);
-		break;
-	case VT_UI2:
-		v.setValue((unsigned int)*m_data.pUI2);
-		break;
-	case VT_I4:
-        v.setValue(*m_data.pI4);
-		break;
-	case VT_UI4:
-        v.setValue(*m_data.pUI4);
-		break;
-	case VT_I8:
-        v.setValue(*m_data.pI8);
-		break;
-	case VT_UI8:
-        v.setValue(*m_data.pUI8);
-		break;
-	case VT_float:
-		v.setValue(*m_data.pFloat);
-		break;
-	case VT_double:
-		v.setValue(*m_data.pDouble);
-		break;
-    default:
-        break;
-	}
-}
-
-QVariant CShmVariable::val(void)
-{
-	QVariant v;
-	Lock();
-	valRaw(v);
-	Unlock();
-    return v;
-}
-
-void CShmVariable::setVal(const QVariant &val)
-{
-	if(val.isValid() && !val.isNull())
-	{
-#if _TRACK_QT_WRITES
-		char szDebugOut[256];
-#endif	//	_TRACK_QT_WRITES
-
-		Lock();
-
-		switch(m_vt)
-		{
-		case VT_bool:
-			if(val.canConvert<bool>())
-			{
-				m_cache.boolVal = val.toBool();
-				if(*m_data.pBool != m_cache.boolVal)
-				{
-					*m_data.pBool = m_cache.boolVal;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: bool %s@(%p) - %s", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.boolVal ? "true" : "false");
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_I1:
-			if(val.canConvert<int>())
-			{
-				m_cache.I1Val = (signed char)val.toInt();
-				if(*m_data.pI1 != m_cache.I1Val)
-				{
-					*m_data.pI1 = m_cache.I1Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: signed char %s@(%p) - %hhd", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.I1Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_UI1:
-			if(val.canConvert<int>())
-			{
-				m_cache.UI1Val = (unsigned char)val.toInt();
-				if(*m_data.pUI1 != m_cache.UI1Val)
-				{
-					*m_data.pUI1 = m_cache.UI1Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: unsigned char %s@(%p) - %hhu", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.UI1Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_I2:
-			if(val.canConvert<int>())
-			{
-				m_cache.I2Val = (signed short)val.toInt();
-				if(*m_data.pI2 != m_cache.I2Val)
-				{
-					*m_data.pI2 = m_cache.I2Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: signed short %s@(%p) - %hd", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.I2Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_UI2:
-			if(val.canConvert<int>())
-			{
-				m_cache.UI2Val = (unsigned short)val.toInt();
-				if(*m_data.pUI2 != m_cache.UI2Val)
-				{
-					*m_data.pUI2 = m_cache.UI2Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: unsigned short %s@(%p) - %hu", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.UI2Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_I4:
-			if(val.canConvert<int>())
-			{
-				m_cache.I4Val = (signed int)val.toInt();
-				if(*m_data.pI4 != m_cache.I4Val)
-				{
-					*m_data.pI4 = m_cache.I4Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: signed int %s@(%p) - %d", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.I4Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_UI4:
-			if(val.canConvert<int>())
-			{
-				m_cache.UI4Val = (unsigned int)val.toInt();
-				if(*m_data.pUI4 != m_cache.UI4Val)
-				{
-					*m_data.pUI4 = m_cache.UI4Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: unsigned int %s@(%p) - %u", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.UI4Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_I8:
-			if(val.canConvert<long long>())
-			{
-				m_cache.I8Val = (signed long long)val.toLongLong();
-				if(*m_data.pI8 != m_cache.I8Val)
-				{
-					*m_data.pI8 = m_cache.I8Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: signed long long %s@(%p) - %lld", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.I8Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_UI8:
-			if(val.canConvert<long long>())
-			{
-				m_cache.UI8Val = (unsigned long long)val.toLongLong();
-				if(*m_data.pUI8 != m_cache.UI8Val)
-				{
-					*m_data.pUI8 = m_cache.UI8Val;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: unsigned long long %s@(%p) - %llu", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.UI8Val);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_float:
-			if(val.canConvert<float>())
-			{
-				m_cache.FloatVal = (float)val.toFloat();
-				if(*m_data.pFloat != m_cache.FloatVal)
-				{
-					*m_data.pFloat = m_cache.FloatVal;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: float %s@(%p) - %f", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.FloatVal);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		case VT_double:
-			if(val.canConvert<double>())
-			{
-				m_cache.DoubleVal = (double)val.toDouble();
-				if(*m_data.pDouble != m_cache.DoubleVal)
-				{
-					*m_data.pDouble = m_cache.DoubleVal;
-					emitChanged(false);
-#if _TRACK_QT_WRITES
-					sprintf(szDebugOut, "CShmVariable::setVal: double %s@(%p) - %f", m_varName.toStdString().c_str(), m_data.pVoid, m_cache.DoubleVal);
-        			qDebug() << szDebugOut;
-#endif	//	_TRACK_QT_WRITES
-				}
-			}
-			break;
-		default:
-	        qDebug() << "CShmVariable::setVal: invalid vartype!";
-			break;
-		}
-
-		Unlock();
-	}
-}
-
-unsigned int CShmVariable::vt(void) const
-{
-	return m_vt;
-}
-
-unsigned long long CShmVariable::CheckUpdateShm(bool fLock)
-{
-	CHECK_UPDATE_SHM_RETVAL rv = {1, 0};
-
-	if(fLock)
-		Lock();
-
-	switch(m_vt)
-	{
-	case VT_bool:
-		if(m_cache.boolVal != *m_data.pBool)
-		{
-			m_cache.boolVal = *m_data.pBool;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_I1:
-		if(m_cache.I1Val != *m_data.pI1)
-		{
-			m_cache.I1Val = *m_data.pI1;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_UI1:
-		if(m_cache.UI1Val != *m_data.pUI1)
-		{
-			m_cache.UI1Val = *m_data.pUI1;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_I2:
-		if(m_cache.I2Val != *m_data.pI2)
-		{
-			m_cache.I2Val = *m_data.pI2;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_UI2:
-		if(m_cache.UI2Val != *m_data.pUI2)
-		{
-			m_cache.UI2Val = *m_data.pUI2;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_I4:
-		if(m_cache.I4Val != *m_data.pI4)
-		{
-			m_cache.I4Val = *m_data.pI4;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_UI4:
-		if(m_cache.UI4Val != *m_data.pUI4)
-		{
-			m_cache.UI4Val = *m_data.pUI4;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_I8:
-		if(m_cache.I8Val != *m_data.pI8)
-		{
-			m_cache.I8Val = *m_data.pI8;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_UI8:
-		if(m_cache.UI8Val != *m_data.pUI8)
-		{
-			m_cache.UI8Val = *m_data.pUI8;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_float:
-		if(m_cache.FloatVal != *m_data.pFloat)
-		{
-			m_cache.FloatVal = *m_data.pFloat;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-	case VT_double:
-		if(m_cache.DoubleVal != *m_data.pDouble)
-		{
-			m_cache.DoubleVal = *m_data.pDouble;
-			emitChanged(false);
-			rv.nUpdated = 1;
-		}
-		break;
-    default:
-        break;
-	}
-
-	if(fLock)
-		Unlock();
-
-	return rv.nRetval;
-}
-
-void CShmVariable::Lock(void)
-{
-	::GfaIpcLockSHM(m_hShm);
-//	qDebug() << "CShmVariable::Lock";
-}
-
-void CShmVariable::Unlock(void)
-{
-//	qDebug() << "CShmVariable::Unlock";
-	::GfaIpcUnlockSHM(m_hShm);
-}
-
-void CShmVariable::emitChanged(bool fLock)
-{
-//    qDebug() << "val changed!";
-	if(fLock)
-	    emit valChanged(val());
-	else
-	{
-	    QVariant v;
-	    valRaw(v);
-	    emit valChanged(v);
-	}
-}

usr/visu/var/shmvar.h

@@ -1,238 +0,0 @@
-// shmvar.h :
-//
-
-#if !defined(AGD_SHMVAR_H__8E807F2F_C6E5_4D6B_8193_F29943D450B3__INCLUDED_)
-#define AGD_SHMVAR_H__8E807F2F_C6E5_4D6B_8193_F29943D450B3__INCLUDED_
-
-#include <pthread.h>
-#include <QObject>
-#include <QVariant>
-#include <QByteArray> 
-#include <gfa/gfaipc.h>
-#include <typeinfo>
-
-/////////////////////////////////////////////////////////////////////////////
-
-
-#define _TRACK_TYPES_AT_LOAD				0
-#define _TRACK_QT_WRITES					0
-
-
-/////////////////////////////////////////////////////////////////////////////
-
-typedef union _CHECK_UPDATE_SHM_RETVAL
-{
-	struct
-	{
-		unsigned int nChecked;
-		unsigned int nUpdated;
-	};
-	unsigned long long nRetval;
-}CHECK_UPDATE_SHM_RETVAL, *LPCHECK_UPDATE_SHM_RETVAL;
-typedef const CHECK_UPDATE_SHM_RETVAL *LPCCHECK_UPDATE_SHM_RETVAL;
-
-/////////////////////////////////////////////////////////////////////////////
-// shmvar.h - Declarations:
-
-class CShmVariable : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QVariant val READ val WRITE setVal NOTIFY valChanged USER true)
-    Q_PROPERTY(unsigned int vt READ vt CONSTANT)
-
-public:
-	enum VT
-	{
-		VT_Invalid,
-		VT_bool,
-		VT_I1,
-		VT_UI1,
-		VT_I2,
-		VT_UI2,
-		VT_I4,
-		VT_UI4,
-		VT_I8,
-		VT_UI8,
-		VT_float,
-		VT_double,
-		VT_string
-	};
-
-	Q_ENUM(VT)
-	
-	typedef union
-	{
-		void *pVoid;
-		bool *pBool;
-		signed char *pI1;
-		unsigned char *pUI1;
-		signed short *pI2;
-		unsigned short *pUI2;
-		signed int *pI4;
-		unsigned int *pUI4;
-		signed long long *pI8;
-		unsigned long long *pUI8;
-		float *pFloat;
-		double *pDouble;
-	}V_Ptr;
-
-	typedef union
-	{
-		bool boolVal;
-		signed char I1Val;
-		unsigned char UI1Val;
-		signed short I2Val;
-		unsigned short UI2Val;
-		signed int I4Val;
-		unsigned int UI4Val;
-		signed long long I8Val;
-		unsigned long long UI8Val;
-		float FloatVal;
-		double DoubleVal;
-	}V_Val;
-
-public:
-    explicit CShmVariable(void *pData, const std::type_info &rti, HSHM hShm, const char *pszName, int nIndex, QObject *pParent = 0);
-    virtual ~CShmVariable(void);
-
-    QVariant val(void);
-	void setVal(const QVariant &val);
-	unsigned int vt(void) const;
-	unsigned long long CheckUpdateShm(bool fLock);
-
-signals:
-	void valChanged(const QVariant &val) const;
-
-private:
-    void valRaw(QVariant &v);
-	void emitChanged(bool fLock = false);
-    void Lock(void);
-    void Unlock(void);
-
-private:
-    enum VT m_vt;
-    volatile V_Ptr m_data;
-    V_Val m_cache;
-    HSHM m_hShm;
-    QString m_varName;
-    int m_nIndex;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class CShmStringVariable : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QString val READ val WRITE setVal NOTIFY valChanged USER true)
-    Q_PROPERTY(unsigned int vt READ vt CONSTANT)
-
-public:
-	typedef enum
-	{
-		VT_Invalid,	// 0
-		VT_Latin1,	// 1
-		VT_UTF_8,	// 2
-		VT_UTF_16,	// 3
-		VT_UTF_32,	// 4
-		VT_Unicode,	// 5
-		VT_Last
-	}VT;
-
-	typedef union
-	{
-		void *pVoid;
-		char *pszMbs;
-		char16_t *pszWc16;
-		char32_t *pszWc32;
-		wchar_t *pszWcs;
-	}V_Ptr;
-
-public:
-    explicit CShmStringVariable(void *pData, size_t nCChData, VT vt, const std::type_info &rti, HSHM hShm, const char *pszName, int nIndex, QObject *pParent = 0);
-    virtual ~CShmStringVariable(void);
-
-    QString val(void);
-	void setVal(const QString &val);
-	unsigned int vt(void) const;
-	unsigned long long CheckUpdateShm(bool fLock);
-
-signals:
-	void valChanged(const QString &val) const;
-
-private:
-    void valRaw(QString &v);
-	void emitChanged(bool fLock = false);
-    bool shmChanged(bool fLock);
-    void Lock(void);
-    void Unlock(void);
-    void zeroTerm(volatile V_Ptr &rp, size_t at);
-
-private:
-    VT m_vt;
-    volatile V_Ptr m_data;
-    V_Ptr m_cache;
-    size_t m_nCbBuffer;
-    size_t m_nCbString;
-    HSHM m_hShm;
-    QString m_varName;
-    int m_nIndex;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class CShmBitVariable : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QVariant val READ val WRITE setVal NOTIFY valChanged USER true)
-    Q_PROPERTY(unsigned int vt READ vt CONSTANT)
-
-public:
-	enum VT
-	{
-		VT_Invalid,
-		VT_bool,
-		VT_I1,
-		VT_UI1,
-		VT_I2,
-		VT_UI2,
-		VT_I4,
-		VT_UI4,
-		VT_I8,
-		VT_UI8,
-		VT_float,
-		VT_double,
-		VT_string
-	};
-
-	Q_ENUM(VT)
-
-public:
-    explicit CShmBitVariable(void *pData, size_t nOffset, int nBitNr, HSHM hShm, const char *pszName, QObject *pParent = 0);
-    virtual ~CShmBitVariable(void);
-
-    QVariant val(void);
-	void setVal(const QVariant &val);
-	unsigned int vt(void) const;
-	unsigned long long CheckUpdateShm(bool fLock);
-
-signals:
-	void valChanged(const QVariant &val) const;
-
-private:
-    void valRaw(QVariant &v);
-	void emitChanged(bool fLock = false);
-    void Lock(void);
-    void Unlock(void);
-
-private:
-	uint8_t *m_pShmByte;
-	uint8_t m_mask;
-	bool m_cacheVal;
-    HSHM m_hShm;
-    QString m_varName;
-    int m_nIndex;
-    int m_nBitNr;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-#endif	//	!defined(AGD_SHMVAR_H__8E807F2F_C6E5_4D6B_8193_F29943D450B3__INCLUDED_)

usr/visu/visu.pro

@@ -31,7 +31,7 @@ INCLUDEPATH += ../../
 SOURCES += main.cpp
 
 HEADERS +=  \
-    ../../OEM_qt.h
+    ../../$(OEM)_qt.h
 
 RESOURCES += qml.qrc