// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// 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\kernel\eventq.cpp

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#include <e32btrace.h>

/******************************************************

 * Event Queue

 ******************************************************/

/** Release the event queue mutex and panic the current thread with a KERN-EXEC panic.

*/ 

void EventQueuePanic(TInt aReason)

	{

	NKern::FMSignal(&K::EventQueueMutex);

	Kern::PanicCurrentThread(KLitKernExec, aReason);

	}

void K::CreateEventQueue(TInt aSize)

//

// Create the event queue

//

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("CreateEventQueue"));

	K::EventBufferStart=(TRawEvent *)Kern::Alloc(sizeof(TRawEvent)*aSize);

	if (!K::EventBufferStart)

		K::Fault(K::ECreateEventQueueFailed);

	K::EventBufferEnd=K::EventBufferStart+aSize;

	K::EventHeadPtr=K::EventTailPtr=K::EventBufferStart;

	if (Kern::CreateClientDataRequest(K::EventRequest) != KErrNone)

		K::Fault(K::ECreateEventQueueFailed);

	}

TInt ExecHandler::AddEvent(const TRawEvent &aEvent)

//

// Add an event to the queue.

//

	{

	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::AddEvent"));

	if(!Kern::CurrentThreadHasCapability(ECapabilitySwEvent,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::AddEvent")))

		return KErrPermissionDenied;

	TRawEvent event;

	kumemget32(&event,&aEvent,sizeof(TRawEvent));

	TRawEvent::TType type = event.Type();

	if( (type==TRawEvent::ESwitchOff || type==TRawEvent::ECaseOpen || type==TRawEvent::ECaseClose || type==TRawEvent::ERestartSystem) && 

		!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::AddEvent")))

		return KErrPermissionDenied;

#ifdef BTRACE_TRAWEVENT		

	BTraceContext4(BTrace::ERawEvent, BTrace::EUserAddEvent ,(TUint32)type);

#endif

	NKern::ThreadEnterCS();	

	TInt r=Kern::AddEvent(event);

	NKern::ThreadLeaveCS();

	return r;

	}

/**	Adds an event to the event queue.

	Invoking this will reset the user inactivity timer.

	@param	"const TRawEvent& aEvent" a reference to the event to be added to the event queue.

	@return KErrNone, if successful; KErrOverflow if event queue is already full.

	@pre No fast mutex can be held.

	@pre Calling thread must be in a critical section.

	@pre Kernel must be unlocked

	@pre interrupts enabled

	@pre Call in a thread context

*/

EXPORT_C TInt Kern::AddEvent(const TRawEvent& aEvent)

	{

	return Kern::AddEvent(aEvent, ETrue);

	}

/**	Adds an event to the event queue.

	@param	"const TRawEvent& aEvent" a reference to the event to be added to the event queue.

	@param	"TBool aResetUserActivity" Specifies whether this event should reset the user inactivity timer. 

			For most cases this should be set to ETrue

	@return KErrNone, if successful; KErrOverflow if event queue is already full.

	@pre No fast mutex can be held.

	@pre Calling thread must be in a critical section.

	@pre Kernel must be unlocked

	@pre interrupts enabled

	@pre Call in a thread context

*/

EXPORT_C TInt Kern::AddEvent(const TRawEvent& aEvent, TBool aResetUserActivity)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::AddEvent");	

	__KTRACE_OPT(KEVENT,Kern::Printf("Kern::AddEvent %x, %x",K::EventHeadPtr,K::EventTailPtr));

	if (aResetUserActivity)

		{

		K::InactivityQ->Reset();

		if (K::PowerModel)

			K::PowerModel->RegisterUserActivity(aEvent);

		}

#ifdef BTRACE_TRAWEVENT		

	BTraceContext4(BTrace::ERawEvent, BTrace::EKernelAddEvent ,(TUint32)aEvent.Type());

#endif

	NKern::FMWait(&K::EventQueueMutex);

    TInt r=KErrOverflow;

	TRawEvent *pE=K::EventHeadPtr+1;

	if (pE>=K::EventBufferEnd)

		pE=K::EventBufferStart;

	if (pE!=K::EventTailPtr)

		{

		*K::EventHeadPtr=aEvent;

		K::EventHeadPtr=pE;

        r=KErrNone;

		}

	K::TryDeliverEvent();

	return r;

	}

void K::TryDeliverEvent()

//

// Deliver an event if one is pending.

// Enter with event queue mutex held, leave with it released.

//

	{

	if (K::EventHeadPtr!=K::EventTailPtr && K::EventRequest->IsReady())

		{

		K::EventRequest->Data() = *K::EventTailPtr;

		K::EventTailPtr++;

		if (K::EventTailPtr>=K::EventBufferEnd)

			K::EventTailPtr=K::EventBufferStart;

		Kern::QueueRequestComplete(K::EventThread,K::EventRequest,KErrNone);

		__KTRACE_OPT(KEVENT,Kern::Printf("Delivered event"));

		}

	NKern::FMSignal(&K::EventQueueMutex);

	}

void ExecHandler::CaptureEventHook()

//

// Capture the event hook.

// Enter and leave with system unlocked.

//

	{

	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::CaptureEventHook"));

	if(TheCurrentThread->iOwningProcess!=K::TheWindowServerProcess)

		{

		NKern::LockSystem();

		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::CaptureEventHook"));

		}

	NKern::FMWait(&K::EventQueueMutex);

	if (!K::EventThread)

		K::EventThread=TheCurrentThread;

	else

		EventQueuePanic(EEventAlreadyCaptured);

	NKern::FMSignal(&K::EventQueueMutex);

	}

void ExecHandler::ReleaseEventHook()

//

// Release the event hook.

// Enter and leave with system unlocked.

//

	{

	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::ReleaseEventHook"));

	DThread* pT=TheCurrentThread;

	NKern::FMWait(&K::EventQueueMutex);

	if (K::EventThread==pT)

		{

		K::EventThread=NULL;

		Kern::QueueRequestComplete(K::EventThread,K::EventRequest,KErrCancel);

		}

	else

		EventQueuePanic(EEventNotCaptured);

	NKern::FMSignal(&K::EventQueueMutex);

	}

void ExecHandler::RequestEvent(TRawEventBuf& aEvent, TRequestStatus& aStatus)

//

// Request the next event.

// Enter and leave with system unlocked.

//

	{

   	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::RequestEvent"));

	NKern::FMWait(&K::EventQueueMutex);

	if (K::EventThread!=TheCurrentThread)

		EventQueuePanic(EEventNotCaptured);

	if (K::EventRequest->SetStatus(&aStatus) != KErrNone)

		EventQueuePanic(EEventRequestPending);

	// This could be simpler if the API was changed to pass a pointer to a TRawEvent instead of a

	// TRawEventBuf descriptor.  We cheat here and assume the descriptor is always a TRawEventBuf;

	// this should be safe since the API specifies a TRawEventBuf.	

	K::EventRequest->SetDestPtr(((TUint8*)&aEvent) + sizeof(TDes8));

	K::TryDeliverEvent();

	}

void ExecHandler::RequestEventCancel()

//

// Cancel the event request.

// Enter and leave with system unlocked.

//

	{

	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::RequestEventCancel"));

	NKern::FMWait(&K::EventQueueMutex);

	if (K::EventThread!=TheCurrentThread)

		EventQueuePanic(EEventNotCaptured);

	Kern::QueueRequestComplete(K::EventThread,K::EventRequest,KErrCancel);

	NKern::FMSignal(&K::EventQueueMutex);

	}

/** Gets the mouse or digitiser X-Y position.

	@return The position.

	@pre	Call in any context.

 */

EXPORT_C TPoint TRawEvent::Pos() const

	{

	TPoint p;

	p.iX=iU.pos.x;

	p.iY=iU.pos.y;

	return p;

	}

/** Gets the 3D pointing device Cartesian coordinates.

	@return The position.

	@pre	Call in any context.

 */

EXPORT_C TPoint3D TRawEvent::Pos3D() const

	{

	TPoint3D p;

	p.iX=iU.pos.x;

	p.iY=iU.pos.y;

	p.iZ=iU.pos3D.z;

	return p;

	}

/** Gets the angular spherical polar coordinates of the 3D pointer end that is closer to the screen.

    @return The angular spherical polar coordinates of the point defined by the end of the 3D pointing device that is closer to the screen.

	@pre	Call in any context.

 */

EXPORT_C TAngle3D TRawEvent::Tilt() const

	{

	TAngle3D p;

	p.iPhi=iU.pos3D.phi;

	p.iTheta=iU.pos3D.theta;

	return p;

	}

/** Gets the rotation angle of 3D pointing device.

    @return The rotation angle of the 3D pointing device.

	@pre	Call in any context.

 */

EXPORT_C TInt TRawEvent::Rotation() const

	{

	return (iU.pos3D.alpha);

	}

/** Sets the event up as a scancode event.

	@param	aType	The event type.

	@param	aScanCode The scancode.

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::Set(TType aType,TInt aScanCode)

	{

	iType=(TUint8)aType;

	iU.key.scanCode=aScanCode;

	iU.key.repeats=0;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext8(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aScanCode);

#endif

	iTicks=Kern::TickCount();

	}

/** Sets the event up as a repeating scancode event.

	@param	aType	The event type.

	@param	aScanCode The scancode.

	@param	aRepeats  The repeat count.

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::SetRepeat(TType aType,TInt aScanCode,TInt aRepeats)

	{

	iType=(TUint8)aType;

	iU.key.scanCode=aScanCode;

	iU.key.repeats=aRepeats;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext12(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aScanCode, (TUint32)aRepeats);

#endif

	iTicks=Kern::TickCount();

	}

/** Sets the event up as a mouse/pen event.

	@param	aType	The event type.

	@param	aX		The X position.

	@param	aY		The Y position.

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::Set(TType aType,TInt aX,TInt aY)

	{

	iType=(TUint8)aType;

	iU.pos.x=aX;

	iU.pos.y=aY;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext12(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aX,(TUint32)aY);

#endif

	iTicks=Kern::TickCount();

	}

/** Sets the event up as a 3D pointer linear move event.

	@param	aType	The event type.

	@param	aX		The X position.

	@param	aY		The Y position.

	@param	aZ		The Z position (defaults to 0 on 2D detection devices).

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::Set(TType aType,TInt aX,TInt aY,TInt aZ)

	{

	iType=(TUint8)aType;

	iU.pos.x=aX;

	iU.pos.y=aY;

	iU.pos3D.z=aZ;

#ifdef BTRACE_TRAWEVENT	

	//Form the Trace Data

	TUint32 traceData[2];

    traceData[0] =aY;

	traceData[1] =aZ;

    BTraceContextN(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aX,traceData, sizeof(traceData));    

#endif

	iTicks=Kern::TickCount();

	}

/** Sets up an event without parameters.

	@param	aType	The event type.

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::Set(TType aType)

	{

	iType=(TUint8)aType;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext4(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType);

#endif 

	iTicks=Kern::TickCount();

	}

/** Sets the event up as a 3D pointer linear move and tilt and rotation change event.

	@param	aType	The event type.

	@param	aX		The X position (or TPhi polar coordinate).

	@param	aY		The Y position (or Theta polar coordinate).

	@param	aZ		The Z position (or rotation).

	@param	aPhi	The Phi polar coordinate.

	@param	aTheta	The Theta polar coordinate.

	@param	aAlpha	The rotation angle.

	@pre	Call in any context.

 */

EXPORT_C void TRawEvent::Set(TType aType,TInt aX,TInt aY,TInt aZ,TInt aPhi,TInt aTheta,TInt aAlpha)

	{

	iType=(TUint8)aType;

	iU.pos.x=aX;

	iU.pos.y=aY;

	iU.pos3D.z=aZ;

	iU.pos3D.phi=aPhi;

	iU.pos3D.theta=aTheta;

	iU.pos3D.alpha=aAlpha;

#ifdef BTRACE_TRAWEVENT	

	//Form the Trace Data

	TUint32 traceData[5];

    traceData[0] =aY;

	traceData[1] =aZ;

	traceData[2] =aPhi;

	traceData[3] =aTheta;

	traceData[4] =aAlpha;

	BTraceContextN(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aX,traceData, sizeof(traceData));		

#endif

	iTicks=Kern::TickCount();

	}

/** Sets the event up as 3D pointer tilt change event.

	@param	aType	The event type.

	@param	aPhi	The Phi coordinate.

	@param	aTheta	The Theta coordinate.

	@pre	Call in any context.

*/

EXPORT_C void TRawEvent::SetTilt(TType aType,TInt aPhi,TInt aTheta)

	{

	iType=(TUint8)aType;

	iU.pos3D.phi=aPhi;

	iU.pos3D.theta=aTheta;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext12(BTrace::ERawEvent, BTrace::ESetTiltEvent ,(TUint32)aType, (TUint32)aPhi,(TUint32)aTheta);

#endif

	iTicks=Kern::TickCount();

	}

/** Sets the event up as 3D pointer rotation event.

	@param	aType	The event type.

	@param	aAlpha	The rotation angle.

	@pre	Call in any context.

*/

EXPORT_C void TRawEvent::SetRotation(TType aType,TInt aAlpha)

	{

	iType=(TUint8)aType;

	iU.pos3D.alpha=aAlpha;

#ifdef BTRACE_TRAWEVENT	

	BTraceContext8(BTrace::ERawEvent, BTrace::ESetRotationtEvent,(TUint32)aType, (TUint32)aAlpha);

#endif

	iTicks=Kern::TickCount();

	}

/** Returns the scancode.

	@return The scancode.

	@pre	Call in any context.

 */

EXPORT_C TInt TRawEvent::ScanCode() const

	{

	return iU.key.scanCode;

	}

/** Returns the repeat count.

	@return The repeat count.

	@pre	Call in any context.

 */

EXPORT_C TInt TRawEvent::Repeats() const

	{

	return iU.key.repeats;

	}

/** Sets the event up as a 3D pointer linear move event with pointer number 

	@param	aType	The event type.

	@param	aX		The X position.

	@param	aY		The Y position.

	@param	aZ		The Z position .

	@param  aPointerNumber   The pointer number for the event 

	@pre	Call in any context.

*/

EXPORT_C void TRawEvent::Set (TType aType, TInt aX, TInt aY, TInt aZ, TUint8 aPointerNumber)

	{

	iType=(TUint8)aType;

	iU.pos3D.x=aX;

	iU.pos3D.y=aY;

	iU.pos3D.z=aZ;

	iPointerNumber=aPointerNumber;	

#ifdef BTRACE_TRAWEVENT	

	//Form the Trace Data

	TUint32 traceData[3];

    traceData[0] =aY;

	traceData[1] =aZ;

	traceData[2] =aPointerNumber;

    BTraceContextN(BTrace::ERawEvent, BTrace::ESetEvent ,(TUint32)aType, (TUint32)aX,traceData, sizeof(traceData));    	

#endif

	iTicks=Kern::TickCount();

	}