/* Various tests to check if Wintab is acting as we would expect */

#include <windows.h>

#include "wintab.h"


extern HMGR hMgr;
extern HMODULE hWintab;
extern char szWintab[];


#ifdef WIN32
	#define LoadLibraryWorked(h)	(h)
#else
	#define LoadLibraryWorked(h)	(h >= HINSTANCE_ERROR)
#endif



/* -------------------------------------------------------------------------- */
BOOL BtnMarks(HMGR h, UINT c, UINT FAR *n, UINT FAR *t)
{
	typedef BOOL (API *BM)(HMGR, UINT, DWORD, DWORD);
	typedef BOOL (API *BMX)(HMGR, UINT, UINT FAR *, UINT FAR *);
	static BM bm = NULL;
	static BMX bmx = NULL;

	/* if not got wintab handle... */
	if (!hWintab)
		/* get wintab handle. */
		hWintab = LoadLibrary(szWintab);
	/* failsafe. */
	if (!LoadLibraryWorked(hWintab))
		return FALSE;

	/* if not got a proc... */
	if (!bmx && !bm) {
		/* try for portable version. */
		bmx = (BMX)GetProcAddress(hWintab, "WTMgrCsrPressureBtnMarksEx");
		/* if no portable version... */
		if (!bmx)
			/* try for non-portable version. */
			bm = (BM)GetProcAddress(hWintab, "WTMgrCsrPressureBtnMarks");
	}
	/* failsafe. */
	if (!bmx && !bm)
		return FALSE;

	/* if portable version... */
	if (bmx) {
		/* call it. */
		return bmx(h, c, n, t);
	}
	else {
		/* convert arguments and call non-portable version. */
		DWORD dwN, dwT;

		if (!n)
			dwN = 0;
		else if (n == WTP_LPDEFAULT)
			dwN = WTP_DWDEFAULT;
		else
			dwN = *(DWORD FAR *)n;

		if (!t)
			dwT = 0;
		else if (t == WTP_LPDEFAULT)
			dwT = WTP_DWDEFAULT;
		else
			dwT = *(DWORD FAR *)t;
		
		return bm(h, c, dwN, dwT);
	}
}

/* -------------------------------------------------------------------------- */
void BMSTest(HWND hWnd)
{
	typedef BYTE MAP[32];
	static MAP logSave, sysSave, logTest, sysTest, logPatt, sysPatt;
	int i;
	BOOL fResult;
	char buf[200];

	/* set up funky test patterns. */
	for (i = 0; i < sizeof(MAP); i++) {
		logPatt[i] = 31;
		sysPatt[i] = SBN_LDRAG;
	}
	/* loop over cursors... */
	for (i = 0; WTInfo(WTI_CURSORS + i, CSR_NAME, NULL); i++) {

		/* save the current maps. */
		WTInfo(WTI_CURSORS + i, CSR_BUTTONMAP, logSave);
		WTInfo(WTI_CURSORS + i, CSR_SYSBTNMAP, sysSave);

		/* if the function thinks it succeeded... */
		if (fResult = WTMgrCsrButtonMap(hMgr, i, logPatt, sysPatt)) {

			/* get the resulting maps. */
			WTInfo(WTI_CURSORS + i, CSR_BUTTONMAP, logTest);
			WTInfo(WTI_CURSORS + i, CSR_SYSBTNMAP, sysTest);

			/* put back the originals. */
			WTMgrCsrButtonMap(hMgr, i, logSave, sysSave);

			/* compare what we sent with what we got. */
			fResult = (!memcmp(logTest, logPatt, sizeof(MAP)) &&
						!memcmp(sysTest, sysPatt, sizeof(MAP)));
		}
		/* report the results. */
		wsprintf(buf, "WTMgrCsrButtonMap() Test %s for Cursor %d.",
				(LPSTR)(fResult ? "Succeeded" : "Failed"), i);
		MessageBox(hWnd, buf, "MgrTest", MB_ICONINFORMATION | MB_OK);
	}
}
/* -------------------------------------------------------------------------- */
void PMSTest(HWND hWnd)
{
	UINT nSave[2], tSave[2], nTest[2], tTest[2], nPatt[2], tPatt[2];
	int i;
	BOOL fResult;
	BOOL fN, fT;
	char buf[200];

	/* set up funky test patterns. */
	nPatt[0] = tPatt[0] = 1;
	nPatt[1] = tPatt[1] = 2;

	/* loop over cursors... */
	for (i = 0; WTInfo(WTI_CURSORS + i, CSR_NAME, NULL); i++) {

		/* check which channels to test. */
		fN = !!WTInfo(WTI_CURSORS + i, CSR_NPBTNMARKS, NULL);
		fT = !!WTInfo(WTI_CURSORS + i, CSR_TPBTNMARKS, NULL);

		if (!fN && !fT) {
			fResult = !BtnMarks(hMgr, i, NULL, NULL);
			fResult &= !BtnMarks(hMgr, i, nPatt, NULL);
			fResult &= !BtnMarks(hMgr, i, NULL, tPatt);
			fResult &= !BtnMarks(hMgr, i, nPatt, tPatt);
		}
		else
		{
			/* save the current maps. */
			if (fN)
				WTInfo(WTI_CURSORS + i, CSR_NPBTNMARKS, nSave);
			if (fT)
				WTInfo(WTI_CURSORS + i, CSR_TPBTNMARKS, tSave);
	
			/* if the function thinks it succeeded... */
			if (BtnMarks(hMgr, i, (fN ? (LPVOID)nPatt : NULL),
												 (fT ? (LPVOID)tPatt : NULL))) {
	
				/* get the resulting maps. */
				if (fN)
					WTInfo(WTI_CURSORS + i, CSR_NPBTNMARKS, nTest);
				if (fT)
					WTInfo(WTI_CURSORS + i, CSR_TPBTNMARKS, tTest);
	
				/* put back the originals. */
				BtnMarks(hMgr, i, (fN ? (LPVOID)nSave : NULL),
												(fT ? (LPVOID)tSave : NULL));
	
				/* compare what we sent with what we got. */
				fResult = TRUE;
				if (fN)
					fResult &= !memcmp(nTest, nPatt, sizeof(nTest));
				if (fT)
					fResult &= !memcmp(tTest, tPatt, sizeof(tTest));
			}
			else
				fResult = FALSE;
		}
		/* report the results. */
		wsprintf(buf, "WTMgrCsrPressureBtnMarks() Test %s for Cursor %d.",
				(LPSTR)(fResult ? "Succeeded" : "Failed"), i);
		MessageBox(hWnd, buf, "MgrTest", MB_ICONINFORMATION | MB_OK);
	}
}
/* -------------------------------------------------------------------------- */
void PRSTest(HWND hWnd)
{
	typedef UINT CURVE[256];
	static CURVE nSave, tSave, nTest, tTest, nPatt, tPatt;
	int nSize, tSize;
	int i, j;
	BOOL fResult;
	BOOL fN, fT;
	AXIS p;
	char buf[200];

	/* loop over devices... */
	for (j = 0; WTInfo(WTI_DEVICES + j, DVC_FIRSTCSR, &i); j++) {
		int k;

		/* set up funky test patterns. */
		if (WTInfo(WTI_DEVICES + j, DVC_NPRESSURE, &p)) {
			nSize = (int)(p.axMax - p.axMin);
			for (k = 0; k < nSize; k++)
				nPatt[k] = (k ? (UINT)p.axMax : (UINT)p.axMin);
		}

		if (WTInfo(WTI_DEVICES + j, DVC_TPRESSURE, &p)) {
			tSize = (int)(p.axMax - p.axMin);
			for (k = 0; k < tSize; k++)
				tPatt[k] = (k ? (UINT)p.axMax : (UINT)p.axMin);
		}

		/* loop over cursors... */
		for (; WTInfo(WTI_CURSORS + i, CSR_NAME, NULL); i++) {

			/* check which channels to test. */
			fN = !!WTInfo(WTI_CURSORS + i, CSR_NPRESPONSE, NULL);
			fT = !!WTInfo(WTI_CURSORS + i, CSR_TPRESPONSE, NULL);
	
			if (!fN && !fT) {
				fResult = !WTMgrCsrPressureResponse(hMgr, i, NULL, NULL);
				fResult &= !WTMgrCsrPressureResponse(hMgr, i, nPatt, NULL);
				fResult &= !WTMgrCsrPressureResponse(hMgr, i, NULL, tPatt);
				fResult &= !WTMgrCsrPressureResponse(hMgr, i, nPatt, tPatt);
			}
			else
			{
				/* save the current maps. */
				if (fN)
					WTInfo(WTI_CURSORS + i, CSR_NPRESPONSE, nSave);
				if (fT)
					WTInfo(WTI_CURSORS + i, CSR_TPRESPONSE, tSave);
	
				/* if the function thinks it succeeded... */
				if (WTMgrCsrPressureResponse(hMgr, i,
											 (fN ? (LPVOID)nPatt : NULL),
											 (fT ? (LPVOID)tPatt : NULL))) {
		
					/* get the resulting maps. */
					if (fN)
						WTInfo(WTI_CURSORS + i, CSR_NPRESPONSE, &nTest);
					if (fT)
						WTInfo(WTI_CURSORS + i, CSR_TPRESPONSE, &tTest);
		
					/* put back the originals. */
					WTMgrCsrPressureResponse(hMgr, i,
											 (fN ? (LPVOID)nSave : NULL),
											 (fT ? (LPVOID)tSave : NULL));
		
					/* compare what we sent with what we got. */
					fResult = TRUE;
					if (fN)
						fResult &= !memcmp(&nTest, &nPatt, sizeof(nTest));
					if (fT)
						fResult &= !memcmp(&tTest, &tPatt, sizeof(nTest));
				}
				else
					fResult = FALSE;
			}
			/* report the results. */
			wsprintf(buf, "WTMgrCsrPressureResponse() Test %s for Cursor %d.",
					(LPSTR)(fResult ? "Succeeded" : "Failed"), i);
			MessageBox(hWnd, buf, "MgrTest", MB_ICONINFORMATION | MB_OK);
		}
	}
}
/* -------------------------------------------------------------------------- */
void HMGRTest(HWND hWnd)
{
	BOOL success = 1;
	HMGR old_hMgr = hMgr;
	HMGR new_hMgr;

	new_hMgr = WTMgrOpen(hWnd, WT_DEFBASE);
	if( !new_hMgr ) {
		MessageBox(hWnd, "WTMgrOpen failed.", "MgrTest", MB_ICONHAND | MB_OK);
		success = 0;
	} else {
		HCTX old_hCtx = WTMgrDefContext(old_hMgr, 0);
		HCTX new_hCtx = WTMgrDefContext(new_hMgr, 0);
		LOGCONTEXT ctx;

		if( !old_hCtx || !new_hCtx ) {
			MessageBox(hWnd, "WTMgrDefContext failed.", "MgrTest", MB_ICONHAND | MB_OK);
			success = 0;
		}
		if( !WTGet(old_hCtx, &ctx) || !WTGet(old_hCtx, &ctx) ) {
			MessageBox(hWnd, "WTGet failed before WTMgrClose called.", "MgrTest", MB_ICONHAND | MB_OK);
			success = 0;
		}
		if( !WTMgrClose(old_hMgr) ) {
			MessageBox(hWnd, "WTMgrClose failed.", "MgrTest", MB_ICONHAND | MB_OK);
			success = 0;
		}
		if( WTGet(old_hCtx, &ctx) ) {
			MessageBox(hWnd, "Error! WTGet returned success on context handle from a closed manager.", "MgrTest", MB_ICONHAND | MB_OK);
			success = 0;
		}
		if( !WTGet(new_hCtx, &ctx) ) {
			MessageBox(hWnd, "WTGet failed for new_hCtx after WTMgrClose(old_hMgr).", "MgrTest", MB_ICONHAND | MB_OK);
			success = 0;
		}
		hMgr = new_hMgr;
	}
	if( success )
		MessageBox(hWnd, "Test Passed.", "MgrTest", MB_ICONINFORMATION | MB_OK);
}