//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++
   tchstub.c   Created April 7 1997
--*/


// Debug guide:  These are the debugging switches used in this driver code.
//
// DEBUG1 - This is used to see which points are sent to which destination.  It prints out every point and
//   the point's desitnation to the debug output, so this is kind of slow.
//
// DEBUG2 - this is a different way to see where the points are going. Warns if any points take 
//   uncommon branches in the code.
//
// WRITE_STATISTICSXXX - these functions collect points, and every so often they write them to a log file
//  This is a good way to find point leaks in case the driver does not sync with the Transriber application
//
// DEBUGTOUCH - This is used to debug the touch screen code.  It provides warnings if there are many
//   long lags with no points while the pen is down, or if there is a poor average point rate.
//   This is on by default in debug builds.
// 


// Basic architecture:
// The points come in through CgrCallback.  
//  If Transcriber is not running, then the points are sent back to the normal touch driver path.
//  Otherwise are then placed on the inner (internal to the touch driver) queue (Q2) by SendPtToSelf.
//
// Points are removed from Q2 by the touch driver thread (TchInnerThread), which passes them to
//  StubCallback2.
//
// StubCallback2 checks to see where the point is, checks with Transcriber about whether the point should
//  be returned to the system.  If so, the point is re-generated and sent via the normal touch driver path.
//  If Transcriber.exe wants the point, it is placed on an external queue (Q1) which is in MemoryMappedFile
//  for interprocess communication with Transcriber.exe

// Transcriber.exe then retrieves points from this queue, paints them on the screen, and sends them
//  to the recognizer.

#include    <windows.h>
#include    <types.h>
#include    <memory.h>
#include    <nkintr.h>
#include    <tchddi.h>
#include    <tchddsi.h>

#include	 "pegc_def.h"  // From main application folder (APP)

#ifdef __cplusplus
extern "C"{
#endif 
#include    <tchstub.h>


//#define  WRITE_STATISTICSLOG   0 // just for experimnents
//#define  WRITE_STATISTICSINNER 0 // for debugging only
//#define  WRITE_STATISTICSSNDPT 0 // for debugging only

#if defined (WRITE_STATISTICSLOG) || defined (WRITE_STATISTICS_INNER) || defined (WRITE_STATISTICSSNDPT)
   #define  MAX_WRITES       20
   #define  MAX_STATS        200
#endif

const TCHAR* const szOldDriverNameValueName		= TEXT("OldDriverName");
#define VADEM_TOUCH_DRIVER_NAME	   TEXT("touchpdd.dll")
#define DEFAULT_TOUCH_DRIVER_NAME	TEXT("touch.dll")

#pragma data_seg(".TOUCHD")
PFN_TOUCH_PANEL_CALLBACK	v_pfnCgrPointCallback = NULL;
HWND  _hClientWnd    = NULL;
HWND  _hLastTouchFocusWnd    = NULL;
short _iClientFlags  = TABLET_ALL_TO_SYSTEM;
DWORD _dwLastSendedTick  = 0;
DWORD _dwLastPostedToClient = 0;
static TOUCH_QUEUE tq2 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static TOUCH_QUEUE* ptq = NULL;
CRITICAL_SECTION Q2CritSect;		// protect the inner queue within the cgrtouch driver
HANDLE	hQ1Mutex;					// protect the outer queue between cgrtouch and app
int		_cProcessNumb = 0;
HANDLE  _hFileMapping = NULL;
LPVOID	_pView = NULL;
HWND*	_phStubWnd = NULL;
HANDLE* _phinstDll = NULL;

static int ints[10] = {0};

static BOOL  bClick=0, bDelay=0; 
static INT   _begX=0, _begY=0;
static DWORD begTick=0;
static bNear = FALSE;
static int   iLastDelayX=0, iLastDelayY=0;
static DWORD dwLastDelayTick=0;

static int _iLastProceedX=0, _iLastProceedY=0, _iLastProceedFlags=0;
static int _iLastPostedX=0, _iLastPostedY=0;
static int _iLastSelfX=-1, _iLastSelfY=-1;
static int _iInRow = 0;
static int _iMinDist = 0;
static int _iMaxDist = 24;
HANDLE g_hTabletEvent = NULL;
HANDLE g_hInnerEvent = NULL;
BOOL _bDeferedDelay = FALSE;
// To track if we are in OOM state.
extern BOOL _bTchThreadHighPriority;

#ifdef DEBUGTOUCH
const int SKIP_THRESHOLD = 40;  		// digitizer resolution is 4x pixel resolution => 10 pixels.
const int LATENCY_THRESHOLD = 30;		// after how many milliseconds is a point considered "overdue"
const int POINT_RATE_THRESHOLD = 100;   // how many points per second minimum do we need? 
                                        //  (200 is better, but 100 should be good enough)
const int SMALL_STROKE_THRESHOLD = 500; // demand that a stroke be at least this many milliseconds 
                                        //  long to measure skips, etc.

CRITICAL_SECTION csErrMsg;              // protect the global error message buffer.

static TCHAR _szErrorMsg[2 * MAX_PATH]; // Buffer for debug error message

const TCHAR* const _tszTranscriberKey   = TEXT("Software\\Microsoft\\Transcriber");
const TCHAR* const _tszNoDbgMsg         = TEXT("TouchNoDebugMesssage");

// Flag to show the touch driver debug message only once per transcriber session.
BOOL _bNoDbgMsg = FALSE;
#endif // DEBUGTOUCH

#pragma data_seg()

DWORD    dwMinPauseBeforeClick         =  1500;
int      iMaxClickDist                 =  23;
int      iMaxDelayDist                 =  18;
DWORD    dwMaxClickTime                =  480;
DWORD    dwMinStartDelayTime           =  480;
DWORD    dwMinInterDelayTime           =  800;
BOOL     _bIgnoreStroke = FALSE;
BOOL     _bIgnoreStroke2 = FALSE;

unsigned char _footprint[12] =
 { 0x40, 0x89, 0x96, 0x19, 0x10, 0x2B, 0x25, 0xF4,
#if CGRTOUCH_ROM_VERSION
   (CGRTOUCH_MAJOR_VERSION|0xC0), (CGRTOUCH_MINOR_VERSION|0x80), CGRTOUCH_RELEASE, 0x80};
#else
   (CGRTOUCH_MAJOR_VERSION|0xC0), (CGRTOUCH_MINOR_VERSION|0x80), CGRTOUCH_RELEASE, 0x4F};
#endif

BOOL IsCgrTouchFile(TCHAR *szFileName);
BOOL IsStubWndExist();
DWORD WINAPI TchWindowThread(DWORD dwParameter);
void StubCallback2(DWORD dwtick0, TOUCH_PANEL_SAMPLE_FLAGS Flags, INT X, INT Y);
BOOL MddTouchPanelEnable(PFN_TOUCH_PANEL_CALLBACK pfnCallback);

#ifdef DEBUGTOUCH
// Thread proc for displaying an error message box, without stopping the touch driver thread,
// If the touch driver thread is blocked, touch driver will not work and user will not be able
// to respond to the error message without a hard keyboard.
DWORD WINAPI TchMessageBoxThread(LPVOID lpParameter)
{
    EnterCriticalSection(&csErrMsg);

	MessageBox(GetForegroundWindow(), _szErrorMsg, TEXT("Transcriber Touch Driver Error"), MB_OK | MB_ICONERROR);

    LeaveCriticalSection(&csErrMsg);

    return 0;
}
#endif // DEBUGTOUCH

// Look at the queue internal to the touch driver, and send the points to StubCallback2
DWORD WINAPI TchInnerThread(DWORD dwParameter)
{
	TOUCH_QUEUE *pTouchQ = &tq2;
	int i;
	
	while(1)
	{
        BOOL fDone = FALSE;
		WaitForSingleObject(g_hInnerEvent, INFINITE); //2000);
		ResetEvent(g_hInnerEvent);

		// process all touch queue points
		EnterCriticalSection(&Q2CritSect);
		while(!fDone) 
		{
	    		i = pTouchQ->iGet;
	    		if(i == pTouchQ->iPut) 
	    		{
	    		 	// no more points
	    			fDone = TRUE;
	    		} 
	    		else 
	    		{
	    			int iNext;
	    			// copy the data out of the critical section so that we can release it
	    			DWORD flags = pTouchQ->elems[i][0];
	    			short x = ((pTouchQ->elems[i][1])>>16);
	    			short y = ((pTouchQ->elems[i][1])&0x0FFFF);

	                     // don't hold the critical section during the callback
	                     //  (priority inversion can fail here)
	        		LeaveCriticalSection(&Q2CritSect);

	        		// handle the point data
	    			StubCallback2(GetTickCount(), flags, x, y);

				// update the queue pointer
	    			iNext = i+1;
	    			if(iNext>=MAX_TOUCHQUEUE) 
	    			{
	    				iNext=0;
	    			}

	              	// re-enter the critical section to update the read pointer
	              	// and go back to the top of the loop.
	    			EnterCriticalSection(&Q2CritSect);
	    			pTouchQ->iGet = iNext;
	    		}
		}

		// no more points, release the critical section
		LeaveCriticalSection(&Q2CritSect);
	}
	
	return 0; //just avoid of copiler's message
}

/* *********************************************************************************************** */
// post the points on the queue used by the app (outside this DLL boundary, in shared memory)
// send points to the main Transcriber App window
void SendPtToWnd(int iFlags, int iX, int iY)    
{
 int iGet = 0;
 int iPut = 0;
 int i;

   if(_bIgnoreStroke &&
      (iFlags&TouchSamplePreviousDownFlag)!=0)
      {
//        MessageBeep((UINT)-1);
        return; 
      }

   WaitForSingleObject(hQ1Mutex, INFINITE);

   iGet = ptq->iGet;
   iPut = ptq->iPut;



#if WRITE_STATISTICSSNDPT
   {
    static int   _iStat1Writes = 0;
    static int   _iStat1Current = 0;
    static short _iStat1Buf[MAX_STATS][5] = {0};
    static int   count = 0;

if (_iStat1Current > 0 && _iStat1Buf[_iStat1Current-1][4] == iPut) OutputDebugString(L"Got same iPut 2 !!!\n");

      _iStat1Buf[_iStat1Current][0] = (short)iFlags;
      _iStat1Buf[_iStat1Current][1] = (short)iX;
      _iStat1Buf[_iStat1Current][2] = (short)iY;
      _iStat1Buf[_iStat1Current][3] = (short)ptq->iGet;
      _iStat1Buf[_iStat1Current][4] = (short)ptq->iPut;
      _iStat1Current++;
      
	  if(_iStat1Current==MAX_STATS)
         {
          HANDLE hFile = INVALID_HANDLE_VALUE;
          int i;

 
		  
		  _iStat1Current = 0;

             hFile = CreateFile(L"\\tchlogSndPt.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
             if(hFile!=INVALID_HANDLE_VALUE)
                {
                 DWORD dw = 0;
				 int   len;
				 int   j;
      
				 SetFilePointer(hFile, 0, NULL, FILE_END);

				   for (i = 0; i < MAX_STATS; i++)
				   {
				    TCHAR str[64];
					unsigned char str2[64];

                    wsprintf(str, L"%d %d %d %d iGet=%d iPut=%d %c%c", count++, (int)_iStat1Buf[i][1], (int)(3000 - _iStat1Buf[i][2]), (int)_iStat1Buf[i][0], 
						     (int)_iStat1Buf[i][3], (int)_iStat1Buf[i][4], (TCHAR)13, (TCHAR)10); 
  		            
					len = _tcslen(str); 
					if(len > 62) 
						len = 62;

					for (j = 0; j < len; j ++) 
						str2[j] = (unsigned char)str[j]; 
					str2[len] = 0;
					
					WriteFile(hFile, str2, len, &dw, NULL);

				   }

                   CloseHandle(hFile);
                }

         }
   }
#endif



   if((iFlags&TouchSampleDownFlag)!=0)
      i = iGet - 3;
   else
      i = iGet - 2;
   
   // ensure there are at least 2 or 3 empty places to write between 
   //  the write pointer and the read pointer - but why???
   //  presumably we want to always keep 2-3 old points available to read in the queue
   //  We do use one point back in the code to end a trace on a timeout - 
   //  could be that 2 or 3 is a stale number.
   if(iPut<i ||
      (iPut>=iGet && iPut<i+MAX_TOUCHQUEUE))
      {
         _bIgnoreStroke = FALSE;



         ptq->elems[iPut][0]=iFlags;
         ptq->elems[iPut][1]=((iX<<16)|iY);

         iPut++;
         
		 if(iPut>=MAX_TOUCHQUEUE)