touch-driver-proxy.cpp

TouchPanel driver which encapsulate real driver. This driver helps to hook by user application touch

#include <windows.h>
#include <Pmpolicy.h>
#include "touch-driver-proxy.h"
#include "logger.h"


#ifdef __cplusplus
extern "C"{
#endif 

#define TOUCH_DRV_FN	L"touch.dll"
#define _GET_PROC_PTR(procType, procName)	\
	if (!pfn##procName) { \
	_LOG(L"Loading func '%s'\n", L#procName); \
		pfn##procName = (procType)GetProcAddress(g_hTouchLib, L#procName); \
	} 
	//\
	//_LOG(L"Calling func '%s'\n", L#procName);

#define GET_PROC_PTR(procType, procName) \
	_GET_PROC_PTR(procType, procName); \
	if (!pfn##procName) { \
		_LOG(L"Error loading func '%s'\n", L#procName); \
	}

#define GET_PROC_PTR_RZERO(procType, procName) \
	_GET_PROC_PTR(procType, procName); \
	if (!pfn##procName) { \
		_LOG(L"Error loading func '%s'\n", L#procName); \
		return 0; \
	}

#define GET_PROC_PTR_RNOTH(procType, procName) \
	_GET_PROC_PTR(procType, procName); \
	if (!pfn##procName) { \
		_LOG(L"Error loading func '%s'\n", L#procName); \
		return; \
	}


#define MAX_CALLBACKS		10
typedef struct proxy_callback
{
	HWND tpcbHWND;
	DWORD tpcbMessage;
} ProxyCallback, *PProxyCallback;

typedef struct shared_tag
{
	CRITICAL_SECTION lock;
	ProxyCallback cbs[MAX_CALLBACKS];
	int cbsUsed;
} SharedMem, *PSharedMem;

HANDLE shmem_map = 0;
PSharedMem shmem_dll = 0;

HMODULE g_hTouchLib;
bool powerHandlerInitialized;
PFN_TOUCH_PANEL_GET_DEVICE_CAPS pfnTouchPanelGetDeviceCaps;
PFN_TOUCH_PANEL_SET_MODE pfnTouchPanelSetMode;
PFN_TOUCH_PANEL_INITIALIZE_CURSOR pfnTouchPanelInitializeCursor;
PFN_TOUCH_PANEL_ENABLE pfnTouchPanelEnable;
PFN_TOUCH_PANEL_DISABLE pfnTouchPanelDisable;
PFN_TOUCH_PANEL_READ_CALIBRATION_POINT pfnTouchPanelReadCalibrationPoint;
PFN_TOUCH_PANEL_READ_CALIBRATION_ABORT pfnTouchPanelReadCalibrationAbort;
PFN_TOUCH_PANEL_SET_CALIBRATION pfnTouchPanelSetCalibration;
PFN_TOUCH_PANEL_CALIBRATE_A_POINT pfnTouchPanelCalibrateAPoint;
PFN_TOUCH_PANEL_POWER_HANDLER pfnTouchPanelPowerHandler;
PFN_TOUCH_GET_QUEUE_PTR pfnTouchGetQueuePtr;
PFN_TOUCH_GET_FOCUS_WND pfnTouchGetFocusWnd;
PFN_TOUCH_GET_LAST_TOUCH_FOCUS_WND pfnTouchGetLastTouchFocusWnd;
PFN_TOUCH_RESET pfnTouchReset;
PFN_TOUCH_CREATE_EVENT pfnTouchCreateEvent;
PFN_TOUCH_GET_REGISTERED_WINDOW pfnTouchGetRegisteredWindow;
PFN_TOUCH_REGISTER_WINDOW pfnTouchRegisterWindow;
PFN_TOUCH_UNREGISTER_WINDOW pfnTouchUnregisterWindow;
PFN_TOUCH_SET_VALUE pfnTouchSetValue;
PFN_TOUCH_GET_VALUE pfnTouchGetValue;

PFN_TOUCH_PANEL_CALLBACK pfnTouchPanelCallbackOriginal;
void TouchPanelPowerHandler(BOOL	bOff);
static bool TouchPanelPowerFlag = true;

bool TouchPanelProxyRegisterMessage(HWND cbHwnd, DWORD cbMessage)
{
	_LOG(L"registerProxyCb: %08X:%08X\n", cbHwnd, cbMessage);	
	bool ret = false;
	EnterCriticalSection(&(shmem_dll->lock));	
	if (shmem_dll->cbsUsed < MAX_CALLBACKS && cbMessage && cbHwnd)
	{
		int i = shmem_dll->cbsUsed;
		for (int j=0; j<i; j++)
		{
			if (shmem_dll->cbs[j].tpcbHWND == cbHwnd && shmem_dll->cbs[j].tpcbMessage == cbMessage)
			{
				i = -1;
				break;
			}
		}
		if (i >= 0)
		{
			shmem_dll->cbs[i].tpcbHWND = cbHwnd;
			shmem_dll->cbs[i].tpcbMessage = cbMessage;	
			shmem_dll->cbsUsed++;
		}
		ret = true;
	}
	_LOG(L"registerProxyCb: %08X:%08X => %d\n", cbHwnd, cbMessage, ret);	
	LeaveCriticalSection(&(shmem_dll->lock));
	return ret;
}

static void removeProxyCallback(int i)
{
	int cnt = shmem_dll->cbsUsed;
	_LOG(L"removeProxyCallback (%d from %d)\n", i, cnt);
	for (int j=i+1; j<cnt; j++) shmem_dll->cbs[j-1] = shmem_dll->cbs[j];
	if (i<cnt) shmem_dll->cbsUsed--;
}

bool TouchPanelProxyUnregisterMessage(HWND cbHwnd, DWORD cbMessage)
{
	_LOG(L"unregisterProxyCb: %08X:%08X\n", cbHwnd, cbMessage);	
	bool ret = false;
	EnterCriticalSection(&(shmem_dll->lock));	
	if (shmem_dll->cbsUsed > 0)
	{
		int cnt = shmem_dll->cbsUsed;
		int i;
		for (i=0; i<cnt; i++)
		{
			if (shmem_dll->cbs[i].tpcbHWND == cbHwnd && shmem_dll->cbs[i].tpcbMessage == cbMessage)
				break;
		}
		if (i < cnt)
		{
			removeProxyCallback(i);
			ret = true;
		}
	}
	_LOG(L"unregisterProxyCb: %08X:%08X => %d\n", cbHwnd, cbMessage, ret);	
	LeaveCriticalSection(&(shmem_dll->lock));
	return ret;
}


BOOL TouchPanelCallbackInternal(TOUCH_PANEL_SAMPLE_FLAGS flags, INT	x, INT	y)
{
	_LOG(L"tpcb: (%d,%d; %02X)\n", x, y, flags);

	if (!pfnTouchPanelCallbackOriginal) return FALSE;
	if (!TouchPanelPowerFlag) return FALSE;
	DWORD msgResult = 2;
	if (shmem_dll->cbsUsed > 0)
	{		
		WPARAM wParam = flags;
		LPARAM lParam = MAKELONG(x, y);
		EnterCriticalSection(&(shmem_dll->lock));
		for (int i=shmem_dll->cbsUsed-1; i>=0; i--)
		{
			_LOG(L"SendMessage(%08X,%08X)\n", shmem_dll->cbs[i].tpcbHWND, shmem_dll->cbs[i].tpcbMessage);
			if (SendMessageTimeout(shmem_dll->cbs[i].tpcbHWND, shmem_dll->cbs[i].tpcbMessage, wParam, lParam, SMTO_NORMAL, 2000, &msgResult))
			{
				_LOG(L"SendMessage(%08X,%08X) => %d\n", shmem_dll->cbs[i].tpcbHWND, shmem_dll->cbs[i].tpcbMessage, msgResult);
				if (msgResult < 2) break; 
			}
			else 
			{
				_LOG(L"SendMessage to callback wnd(%08X:%08X) failed\n", shmem_dll->cbs[i].tpcbHWND, shmem_dll->cbs[i].tpcbMessage);
				removeProxyCallback(i);
			}
		}
		LeaveCriticalSection(&(shmem_dll->lock));
	}
	if (msgResult < 2) return (msgResult ? TRUE : FALSE); 
	return pfnTouchPanelCallbackOriginal(flags, x, y);
}

BOOL TouchPanelGetDeviceCaps(INT iIndex, LPVOID lpOutput)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_GET_DEVICE_CAPS, TouchPanelGetDeviceCaps);
	return pfnTouchPanelGetDeviceCaps(iIndex, lpOutput);
}

BOOL TouchPanelSetMode(INT iIndex, LPVOID lpInput)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_SET_MODE, TouchPanelSetMode);
	return pfnTouchPanelSetMode(iIndex, lpInput);
}

BOOL TouchPanelInitializeCursor(PFN_DISP_DRIVER_MOVE_CURSOR pFn)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_INITIALIZE_CURSOR, TouchPanelInitializeCursor);
	return pfnTouchPanelInitializeCursor(pFn);
}

BOOL TouchPanelEnable(PFN_TOUCH_PANEL_CALLBACK pFn)
{
	if (!powerHandlerInitialized) 
	{
		powerHandlerInitialized = true;
		TouchPanelPowerHandler(false);
	}
	if (pFn == 0) return FALSE;
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_ENABLE, TouchPanelEnable);
	pfnTouchPanelCallbackOriginal = pFn;
	return pfnTouchPanelEnable(TouchPanelCallbackInternal);
}

VOID TouchPanelDisable()
{
	pfnTouchPanelCallbackOriginal = 0;
	GET_PROC_PTR_RNOTH(PFN_TOUCH_PANEL_DISABLE, TouchPanelDisable);
	pfnTouchPanelDisable();
}

BOOL TouchPanelReadCalibrationPoint(INT	*pUncalibratedX, INT *pUncalibratedY)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_READ_CALIBRATION_POINT, TouchPanelReadCalibrationPoint);
	return pfnTouchPanelReadCalibrationPoint(pUncalibratedX, pUncalibratedY);
}

VOID TouchPanelReadCalibrationAbort()
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_PANEL_READ_CALIBRATION_ABORT, TouchPanelReadCalibrationAbort);
	pfnTouchPanelReadCalibrationAbort();
}

BOOL TouchPanelSetCalibration(INT32	cCalibrationPoints,	INT32	*pScreenXBuffer, INT32	*pScreenYBuffer, INT32	*pUncalXBuffer,	INT32	*pUncalYBuffer)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_SET_CALIBRATION, TouchPanelSetCalibration);
	return pfnTouchPanelSetCalibration(cCalibrationPoints, pScreenXBuffer, pScreenYBuffer, pUncalXBuffer, pUncalYBuffer);
}


void TouchPanelCalibrateAPoint(INT32   UncalX, INT32   UncalY, INT32   *pCalX, INT32   *pCalY)
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_PANEL_CALIBRATE_A_POINT, TouchPanelCalibrateAPoint);
	pfnTouchPanelCalibrateAPoint(UncalX, UncalY, pCalX, pCalY);
}

void TouchPanelPowerHandler(BOOL	bOff)
{
	TouchPanelPowerFlag = !bOff;
	//pfnTouchPanelCallbackOriginal = 0;
	GET_PROC_PTR_RNOTH(PFN_TOUCH_PANEL_POWER_HANDLER, TouchPanelPowerHandler);
	pfnTouchPanelPowerHandler(bOff);
}


LPVOID TouchGetQueuePtr()
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_GET_QUEUE_PTR, TouchGetQueuePtr);
	return pfnTouchGetQueuePtr();
}

HWND TouchGetFocusWnd()
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_GET_FOCUS_WND, TouchGetFocusWnd);
	return pfnTouchGetFocusWnd();
}

HWND TouchGetLastTouchFocusWnd()
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_GET_LAST_TOUCH_FOCUS_WND, TouchGetLastTouchFocusWnd);
	return pfnTouchGetLastTouchFocusWnd();
}

void TouchReset(BOOL bSetAllValuesToDefault)
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_RESET, TouchReset);
	pfnTouchReset(bSetAllValuesToDefault);
}

void TouchCreateEvent(int iX, int iY)
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_CREATE_EVENT, TouchCreateEvent);
	pfnTouchCreateEvent(iX, iY);
}

HWND TouchGetRegisteredWindow()
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_GET_REGISTERED_WINDOW, TouchGetRegisteredWindow);
	return pfnTouchGetRegisteredWindow();
}

BOOL TouchRegisterWindow(HWND hClientWnd)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_REGISTER_WINDOW, TouchRegisterWindow);
	return pfnTouchRegisterWindow(hClientWnd);
}

void TouchUnregisterWindow(HWND hClientWnd)
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_UNREGISTER_WINDOW, TouchUnregisterWindow);
	pfnTouchUnregisterWindow(hClientWnd);
}

void TouchSetValue(DWORD dwName, DWORD dwValue)
{
	GET_PROC_PTR_RNOTH(PFN_TOUCH_SET_VALUE, TouchSetValue);
	pfnTouchSetValue(dwName, dwValue);
}

LRESULT TouchGetValue(DWORD dwName, DWORD dwValue)
{
	GET_PROC_PTR_RZERO(PFN_TOUCH_GET_VALUE, TouchGetValue);
	return pfnTouchGetValue(dwName, dwValue);
}


static bool deleteCriticalSection;
extern "C" HINSTANCE LoadDriver(LPCWSTR lpszFileName);//defined in pkfuncs.h

BOOL TouchPanelDllEntry(HANDLE  hinstDll, DWORD   fdwReason, LPVOID  lpvReserved)
{
    BOOL ReturnCode = TRUE;

    switch ( fdwReason )
    {
        case DLL_PROCESS_ATTACH:
			_LOG(L"Process attach\n");
            DisableThreadLibraryCalls((HMODULE) hinstDll);
			g_hTouchLib = LoadDriver(TOUCH_DRV_FN);
			GET_PROC_PTR_RZERO(PFN_TOUCH_PANEL_POWER_HANDLER, TouchPanelPowerHandler);
			if (g_hTouchLib)
			{
				shmem_map = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(SharedMem), L"touchpx/shmem");
				if (!shmem_map) ReturnCode = FALSE;
				else
				{
					bool doInit = (GetLastError()!=ERROR_ALREADY_EXISTS);
					shmem_dll = (PSharedMem)MapViewOfFile(shmem_map, FILE_MAP_WRITE, 0, 0, 0);
					if (!shmem_dll) ReturnCode = FALSE;
					else
					{
						if (doInit) 
						{
							ZeroMemory(shmem_dll, sizeof(SharedMem));
							deleteCriticalSection = true;
							InitializeCriticalSection(&(shmem_dll->lock));
						}
						else
							deleteCriticalSection = false;
					}
				}
			}
			else
			{
				ReturnCode = FALSE;
			}
            break;


        case DLL_PROCESS_DETACH:
			_LOG(L"Process detach\n");
			ReturnCode = FreeLibrary(g_hTouchLib);
			if (deleteCriticalSection) DeleteCriticalSection(&(shmem_dll->lock));
			if (shmem_dll) UnmapViewOfFile(shmem_dll);
			if (shmem_map) CloseHandle(shmem_map);			
            break;
    }
	_LOG(L"DllEntry ret: %d\n", ReturnCode);
    return ( ReturnCode );
}

BOOL WINAPI DllMain (HANDLE hinstDLL, DWORD dwReason, LPVOID lpvReserved)
{
    return TouchPanelDllEntry(hinstDLL, dwReason, lpvReserved);
}


#ifdef __cplusplus
   }
#endif //ifdef __cplusplus