// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\include\drivers\xyin.h

// Generic digitiser driver header

//

//

/**

 @file

 @internalComponent

*/

#ifndef __M32XYIN_H__

#define __M32XYIN_H__

#include <kernel/kpower.h>

#include <platform.h>

#include <e32hal.h>

#ifdef _DEBUG

//#define __DIGITISER_DEBUG1__

//#define __DIGITISER_DEBUG2__

#endif

#ifdef __DIGITISER_DEBUG1__

#define __KTRACE_XY1(s) s;

#else

#define __KTRACE_XY1(s)

#endif

#ifdef __DIGITISER_DEBUG2__

#define __KTRACE_XY2(s) s;

#else

#define __KTRACE_XY2(s)

#endif

/**

@internalComponent

*/

const TInt KMaxXYSamples=4;

/**

@publishedPartner

@released

*/

struct SDigitiserConfig

	{

	TInt iPenDownDiscard;	// number of samples to discard on entering the detection volume (area if 2 dimensional)

	TInt iPenUpDiscard;		// number of samples to discard on leaving the detection volume (area if 2 dimensional)

	TInt iDriveXRise;		// number of milliseconds to wait when driving horizontal edges

	TInt iDriveYRise;		// number of milliseconds to wait when driving vertical edges

	TInt iMinX;				// minimum valid X value

	TInt iMaxX;				// maximum valid X value

	TInt iSpreadX;			// maximum valid X spread

	TInt iMinY;				// minimum valid Y value

	TInt iMaxY;				// maximum valid Y value

	TInt iSpreadY;			// maximum valid Y spread

	TInt iMaxJumpX;			// maximum X movement per sample (pixels)

	TInt iMaxJumpY;			// maximum Y movement per sample (pixels)

	TInt iAccThresholdX;	// accumulated offset in pixels to cause movement in X direction

	TInt iAccThresholdY;	// accumulated offset in pixels to cause movement in Y direction

	TInt iNumXYSamples;		// number of samples to average

	TBool iDisregardMinMax;	// TRUE if we want to disregard minimum and maximum

	};

/**

@publishedPartner

@prototype

*/

struct SDigitiserConfigV01

	{

	SDigitiserConfig i2dConfig;

	TInt iMinZ;				// minimum valid Z value (distance to screen): 0 when lighlty touching (no pressure applied)

	TInt iMaxZ;				// maximum valid Z value: positive for distance to screen, negative for pressure

	TInt iSpreadZ;			// maximum valid Z spread (in distance to screen units)

	TInt iMaxJumpZ;			// maximum Z movement per sample (in distance to screen units)

	TInt iAccThresholdX;	// accumulated offset in distance to screen units to cause movement in Z direction

	};

/**

@publishedPartner

@released

*/

NONSHARABLE_CLASS(DDigitiser) : public DPowerHandler

	{

public:

/**

@internalComponent

*/

	enum TState

		{

		EIdle=0,			// waiting for pen to go down

		EDiscardOnPenDown,	// discarding just after pen down

		EBufferFilling,		// buffer filling with samples

		EBufferFull,		// delay line is now full

		EPenDown,			// pen-down event has been delivered

		};

public:

	// initialisation

	static DDigitiser* New();

	DDigitiser();

	TInt Create();

	virtual TInt DoCreate()=0;

public:

	// signals from hardware-dependent code

	void RawSampleValid();

	void PenUp();

public:

	// signals to hardware-dependent code

	virtual void WaitForPenDown()=0;

	virtual void WaitForPenUp()=0;

	virtual void WaitForPenUpDebounce()=0;

	virtual void DigitiserOn()=0;

	virtual void DigitiserOff()=0;

public:

	// machine-configuration related things

	virtual TInt DigitiserToScreen(const TPoint& aDigitiserPoint, TPoint& aScreenPoint)=0;

	virtual void ScreenToDigitiser(TInt& aX, TInt& aY)=0;

	virtual TInt SetXYInputCalibration(const TDigitizerCalibration& aCalibration)=0;

	virtual TInt CalibrationPoints(TDigitizerCalibration& aCalibration)=0;

	virtual TInt SaveXYInputCalibration()=0;

	virtual TInt RestoreXYInputCalibration(TDigitizerCalibrationType aType)=0;

	virtual void DigitiserInfo(TDigitiserInfoV01& aInfo)=0;

public:

	// Generic stuff

/**

@internalComponent

*/

	void ProcessRawSample();

/**

@internalComponent

*/

	void ProcessPenUp();

/**

@internalComponent

*/

	TBool SamplesToPoint(TPoint& aPoint);

/**

@internalComponent

*/

	TInt DelayAndConvertSample(const TPoint& aSample, TPoint& aScreenPoint);

/**

@internalComponent

*/

	void IssuePenDownEvent();

/**

@internalComponent

*/

	void IssuePenUpEvent();

	void IssuePenMoveEvent(const TPoint& aPoint);

	virtual void FilterPenMove(const TPoint& aPoint)=0;

	virtual void ResetPenMoveFilter()=0;

/**

@internalComponent

*/

	virtual TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);

/**

@internalComponent

*/

 	void HandleMsg(TMessageBase* aMsg);

public:

	TDfcQue* iDfcQ;

 	TMessageQue iMsgQ;

	TDfc iSampleDfc;				// called when a raw sample is available

	TDfc iPenUpDfc;					// called when the pen goes up

	TInt iX[KMaxXYSamples];			// raw X samples from hardware

	TInt iY[KMaxXYSamples];			// raw Y samples from hardware

	SDigitiserConfig iCfg;			// configuration

	TInt iBufferIndex;				// delay line index

	TPoint* iBuffer;				// delay line for samples

	TPoint iLastPos;				// last pen position

	TState iState;

	TInt iCount;

	TUint8 iPointerOn;

	};

#endif