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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Top level window server code

// 

//

#include "EVENT.H"

#include <hal.h>

#include <w32adll.h>

#include <w32click.h>

#include "server.h"

#include "windowgroup.h"

#include "KEYCLICK.H"

#include "wstop.h"

#include "panics.h"

#include "screen.h"

#include "inifile.h"

#include "password.h"

#include <w32std.h>

#include "pointer.h"

#include "debugbar.h"

#include "wstraces.h"

#include "Graphics/wsgraphicdrawerinternal.h"

GLREF_D CDebugLogBase *wsDebugLog;

GLREF_C void StateDump();

GLREF_C void HeapDump();

#define IMPOSSIBLE 0xFFFFFFFF

const TWsWinCmdCaptureKey ImpossibleKeyPress=

	{

	IMPOSSIBLE,	// Impossible to hit key combination, used for disabling Hot Keys

	IMPOSSIBLE,

	IMPOSSIBLE};

const TWsWinCmdCaptureKey DefaultHotKeys[TWindowServerEvent::ENumHotKeys]={

	{	// Enable logging

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	5}, // E

	{	// Disable logging

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	4}, // D

	{	// Window server internal dump to log

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	23},// W

	{	// The key of death

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	11},// K

	{	// Shutdown window server

#if defined(_DEBUG)

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	24},// X

#else

	IMPOSSIBLE,	// Impossible to hit key combination, effectively disables shutdown key in release builds

	IMPOSSIBLE,

	IMPOSSIBLE},

#endif

	{	// Heap dump

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	8}, // H

	{	// Inc Contrast

	0,

	0,

	EKeyIncContrast},

	{	// Dec Contrast

	0,

	0,

	EKeyDecContrast},

	{	// Off

	0,

	0,

	EKeyOff},

	{	// Backlight on 

	0,

	0,

	EKeyBacklightOn},

	{	// Backlight off

	0,

	0,

	EKeyBacklightOff},

	{	// Backlight toggle

	0,

	0,

	EKeyBacklightToggle},

	{	// Screen Dimension Change

	0,

	0,

	EKeyScreenDimension0},

	{

	0,

	0,

	EKeyScreenDimension1},

	{

	0,

	0,

	EKeyScreenDimension2},

	{

	0,

	0,

	EKeyScreenDimension3},

#if defined(_DEBUG)

	{	// Display mode cycle

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	21},// U

	{	// Orientation cycle

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	15},// O

#else

	{	// Display mode cycle

	IMPOSSIBLE,	// Impossible to hit key combination

	IMPOSSIBLE,

	IMPOSSIBLE},

	{	// Orientation cycle

	IMPOSSIBLE,	// Impossible to hit key combination

	IMPOSSIBLE,

	IMPOSSIBLE},

#endif

	{	// Inc Brightness

	0,

	0,

	EKeyIncBrightness},

	{	// Dec Brightness

	0,

	0,

	EKeyDecBrightness},

	{	// Cycle focus screen

	EModifierFunc|EModifierCtrl|EModifierShift,

	EModifierFunc|EModifierCtrl|EModifierShift,

	9}, // I

	};

CKeyTranslator *TWindowServerEvent::iKeyTranslator=NULL;

TEventRequestQueue TWindowServerEvent::iSwitchOnQueue;

TEventRequestQueue TWindowServerEvent::iErrorMessageQueue;

TEventRequestQueue TWindowServerEvent::iModifierChangedQueue;

TEventRequestQueue TWindowServerEvent::iGroupChangedQueue;

TEventRequestQueue TWindowServerEvent::iFocusChangedQueue;

TEventRequestQueue TWindowServerEvent::iGroupListChangedQueue;

TEventRequestQueue TWindowServerEvent::iScreenDeviceChangedQueue;

TTime TWindowServerEvent::iPrevOomMessageTime;

CCaptureKeys *TWindowServerEvent::iCaptureKeys;

CWsHotKey *TWindowServerEvent::iHotKeys;

TInt TWindowServerEvent::iModifierState;

CRawEventReceiver *TWindowServerEvent::iEventReceiver;

CArrayPtrFlat<MEventHandler> *TWindowServerEvent::iEventHandlers;

CArrayFixFlat<SNotificationHandler> *TWindowServerEvent::iNotificationHandlers;

TInt TWindowServerEvent::iPotentialEventHandlers=0;

TUint32 TWindowServerEvent::iBinaryFlags=0x00;

RArray<TDrawerHandler>* TWindowServerEvent::iDrawerHandlers;

RArray<TWsEventHandler> TWindowServerEvent::iWsEventHandlers;

TInt TWindowServerEvent::iEventHandlerCount=0;

TRepeatKey CKeyboardRepeat::iCurrentRepeat;

TRepeatKey CKeyboardRepeat::iAlternateRepeat;

TInt CKeyboardRepeat::iRepeatRollover=1;

CKeyboardRepeat::TRepeatType CKeyboardRepeat::iRepeating=ERepeatNone;

CKeyboardRepeat *CKeyboardRepeat::iThis=NULL;

TTimeIntervalMicroSeconds32 CKeyboardRepeat::iInitialTime;

TTimeIntervalMicroSeconds32 CKeyboardRepeat::iTime;

CWsWindowGroup *CKeyboardRepeat::iFocus=NULL;

TBool CKeyboardRepeat::iAlternateRepeatExists=EFalse;

CWsCaptureLongKey* CKeyboardRepeat::iLongCapture=NULL;

void TWindowServerEvent::DeleteHotKeys()

	{

	CWsHotKey *hotKey=iHotKeys;

	while(hotKey)

		{

		CWsHotKey *next=hotKey->iNext;

		delete hotKey;

		hotKey=next;

		}

	iHotKeys=NULL;

	}

void TWindowServerEvent::DeleteStatics()

	{

	DeleteHotKeys();

	delete iCaptureKeys;

	CKeyboardRepeat::Destroy();

	delete iKeyTranslator;

	delete iEventReceiver;

	delete iEventHandlers;

	delete iNotificationHandlers;

	iDrawerHandlers->Close();

	delete iDrawerHandlers;

	}

void TWindowServerEvent::InitStaticsL()

//

// Create the CEvent active object.

//

	{

#if defined(__WINS__)

	WS_ASSERT_DEBUG(TWindowServerEvent::ENumHotKeys==EHotKeyLastKeyType+1, EWsPanicUnknownCaptureKey);

#endif

	iEventReceiver=new(ELeave) CRawEventReceiver(EEventPriority);

	iEventReceiver->ConstructL();

	iKeyTranslator=CKeyTranslator::New();

	User::LeaveIfNull(iKeyTranslator);

//  Change keyboard mapping according to information the HAL

	TInt keyboardIndex;

	if (HAL::Get(HALData::EKeyboardIndex,keyboardIndex)==KErrNone)

		{

		_LIT(KLitKeyDataDllName,"EKDATA.%02d");

		TBuf<16> keyDataDllName;

		keyDataDllName.Format(KLitKeyDataDllName,keyboardIndex);

		iKeyTranslator->ChangeKeyData(keyDataDllName);

		}

	iCaptureKeys=new(ELeave) CCaptureKeys;

	iCaptureKeys->Construct();

	for (TInt index=0;index<TWindowServerEvent::ENumHotKeys;index++)

		ConstructDefaultHotKeyL(index,DefaultHotKeys[index]);

	CKeyboardRepeat::NewL();

	CKeyboardRepeat::SetRepeatTime(EDefaultInitialRepeatTime, EDefaultRepeatTime);

	iEventHandlers=new(ELeave) CArrayPtrFlat<MEventHandler>(2);

	iNotificationHandlers=new(ELeave) CArrayFixFlat<SNotificationHandler>(2);

	iDrawerHandlers = new(ELeave) RArray<TDrawerHandler>(4);

	}

void TWindowServerEvent::LinkHotKey(CWsHotKey *aWsHotKey)

	{

	aWsHotKey->SetLink(iHotKeys);

	iHotKeys=aWsHotKey;

	}

void TWindowServerEvent::ConstructDefaultHotKeyL(TInt aHotKey, const TWsWinCmdCaptureKey &aSystemKey)

	{

	CWsHotKey* hotKey=new(ELeave) CWsHotKey(aHotKey, ETrue);

	// hotKey is pushed onto the cleanup stack in method ConstructLD.

	hotKey->ConstructLD(aSystemKey);

	LinkHotKey(hotKey);

	}

CWsHotKey* TWindowServerEvent::ClearHotKeysL(TInt aHotKey)

	{

	if (aHotKey>ENumHotKeys)

		{

		User::Leave(KErrArgument);

		}

	CWsHotKey** pHotKey= &iHotKeys;

	CWsHotKey* defaultHotKey=NULL;

	while(*pHotKey)

		{

		TBool unlinked=EFalse;

		if ((*pHotKey)->HotKeyType()==aHotKey)

			{

			CWsHotKey *free=*pHotKey;

			if (free->IsDefault())

				{

				free->SetL(ImpossibleKeyPress);

				defaultHotKey=free;

				}

			else

				{

				*pHotKey=(*pHotKey)->iNext;

				delete free;

				unlinked=ETrue;

				}

			}

		if (!unlinked)

			{

			pHotKey=&(*pHotKey)->iNext;

			}

		}

	return(defaultHotKey);

	}

void TWindowServerEvent::ResetDefaultHotKeyL(TInt aHotKey)

	{

	if ((aHotKey<0) || (aHotKey>=ENumHotKeys))

		{

		User::Leave(KErrArgument);

		}

	CWsHotKey* defaultHotKey=ClearHotKeysL(aHotKey);

	WS_ASSERT_DEBUG(defaultHotKey, EWsPanicDefaultHotKeyNotFound);

	defaultHotKey->SetL(DefaultHotKeys[aHotKey]);

	}

void TWindowServerEvent::SetHotKeyL(const TWsClCmdSetHotKey &aHotKey)

	{

	if (aHotKey.type>ENumHotKeys)

		User::Leave(KErrArgument);

//

	CWsHotKey *hotKey=new(ELeave) CWsHotKey(aHotKey.type, EFalse);

//

	TWsWinCmdCaptureKey captureKey;

	captureKey.modifiers=aHotKey.modifiers;

	captureKey.modifierMask=aHotKey.modifierMask;

	captureKey.key=aHotKey.keycode;

	hotKey->ConstructLD(captureKey);

//

	LinkHotKey(hotKey);

	}

void TWindowServerEvent::AddEventHandler(MEventHandler *aEventHandler)

	{

#if defined(_DEBUG)

	TRAPD(err,iEventHandlers->AppendL(aEventHandler));

	WS_ASSERT_DEBUG(err==KErrNone, EWsPanicEventHandlerInconsistency);

#else

	iEventHandlers->AppendL(aEventHandler);		//Shouldn't leave

#endif

	}

void TWindowServerEvent::RemoveEventHandler(const MEventHandler *aEventHandler)

	{

	TInt count=iEventHandlers->Count();

	TInt ii;

	for(ii=0;ii<count;++ii)

		{

		if ((*iEventHandlers)[ii]==aEventHandler)

			{

			if (iEventHandlerCount>0)  

				{

				iBinaryFlags |= ERemovedEventHandlerWhileProcessingRawEvents;

				(*iEventHandlers)[ii]=NULL; // replace the Handler with null to keep size of the array

				}

			else 

				{

				iEventHandlers->Delete(ii);

				}

			return;

			}

		}

	}

void TWindowServerEvent::PotentialEventHandlerL(TInt aNum)

	{

	iPotentialEventHandlers+=aNum;

	WS_ASSERT_DEBUG(iPotentialEventHandlers>=iEventHandlers->Count(), EWsPanicEventHandlerInconsistency);

	TRAPD(err,iEventHandlers->SetReserveL(iPotentialEventHandlers));

	if (err!=KErrNone)

		{

		if (aNum>0)

			User::Leave(err);

		}

	else if (iPotentialEventHandlers==0)

		iEventHandlers->Compress();

	}

void SendSwitchOnEvent(TEventRequestItem *aQptr, TInt aEvent, TInt )

	{

	aQptr->iWindow->QueueEvent(aEvent);

	}

/*void SendSwitchOffEvent(TEventRequestItem *aQptr, TInt , TInt )

	{

	aQptr->iWindow->QueueEvent(EEventSwitchOff);

	}*/

void SendErrorMessage(TEventRequestItem *aQptr, TInt aCategory, TInt aError)

	{

	TWsEvent event;

	event.SetType(EEventErrorMessage);

	event.SetHandle(aQptr->iWindow->ClientHandle());

	event.ErrorMessage()->iErrorCategory=(TWsErrorMessage::TErrorCategory)aCategory;

	event.ErrorMessage()->iError=aError;

	event.SetTimeNow();

	aQptr->iWindow->EventQueue()->QueueEvent(event,EEventPriorityHigh);

	}

void SendModifierChangedEvent(TEventRequestItem *aQptr, TInt aChanged, TInt )

	{

	TInt tmpChanged=aChanged&aQptr->iParam;

	if (tmpChanged)

		{

		TWsEvent event;

		event.SetType(EEventModifiersChanged);

		event.SetHandle(aQptr->iWindow->ClientHandle());

		event.ModifiersChanged()->iChangedModifiers=tmpChanged;

		event.ModifiersChanged()->iModifiers=TWindowServerEvent::GetStoredModifierState();

		event.SetTimeNow();

		aQptr->iWindow->EventQueue()->QueueEvent(event,EEventPriorityHigh);

		}

	}

void TWindowServerEvent::ProcessEventQueue(TEventRequestQueue &aQueue, TSendEventFunc aFunc, TInt aParam1, TInt aParam2)

	{

	TSglQueIter<TEventRequestItem> iter(aQueue.Queue());

	TEventRequestItem *qPtr;

	CWsWindowGroup *focusWin=CWsTop::FocusWindowGroup();

	while((qPtr=iter++)!=NULL)

		{

		if (qPtr->iCircumstances==EEventControlAlways || 

			(qPtr->iCircumstances==EEventControlOnlyWithKeyboardFocus && qPtr->iWindow->WinGroup()==focusWin) ||

			(qPtr->iCircumstances==EEventControlOnlyWhenVisible && !qPtr->iWindow->TreeIsObscured()))

			aFunc(qPtr, aParam1, aParam2);

		}

	}

void TWindowServerEvent::NotifyOom()

	{

	TTime now;

	now.UniversalTime();

	TTimeIntervalSeconds interval;

	TInt err=now.SecondsFrom(iPrevOomMessageTime,interval);

	if (err!=KErrNone || interval.Int()<0 || interval.Int()>EOomEventSecondGap)

		{

		ProcessErrorMessages(TWsErrorMessage::EDrawingRegion,KErrNoMemory);

		iPrevOomMessageTime=now;

		}

	}

TBool TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::TErrorCategory aCategory, TInt aError)

	{

	if (aError!=KErrNone)

		{

		ProcessEventQueue(iErrorMessageQueue, SendErrorMessage, aCategory, aError);

		return ETrue;

		}

	return EFalse;

	}

void TWindowServerEvent::ProcessModifierChanges()

	{

	TInt newState=iKeyTranslator->GetModifierState();

	if (newState!=iModifierState)

		{

		TInt changed=iModifierState^newState;

		iModifierState=newState;

		ProcessEventQueue(iModifierChangedQueue, SendModifierChangedEvent, changed, 0);

		}

	}

TEventQueueWalkRet FindScreenDeviceChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

	{

	if (aEvent->Type()==EEventScreenDeviceChanged && aEvent->Handle()==*(TUint *)aHandlePtr)

		*(TUint *)aHandlePtr=0;	// Indicates event found

	return(EEventQueueWalkOk);

	}

void TWindowServerEvent::SendScreenDeviceChangedEvents(CScreen* aScreen)

	{

	TSglQueIter<TEventRequestItem> iter(iScreenDeviceChangedQueue .Queue());

	TEventRequestItem *qPtr;

	while((qPtr=iter++)!=NULL)

		SendScreenDeviceChangedEvent(qPtr->iWindow);

	if(CClick::IsHandler())

		{

		TClickMakerData clickMakerData;

		clickMakerData.screenDeviceMode=aScreen->ScreenSizeMode();

		CClick::OtherEvent(EEventScreenDeviceChanged, &clickMakerData);

		}

	TWsEvent wsEvent;

	wsEvent.SetType(EEventScreenDeviceChanged);

	TWindowServerEvent::PublishNotification(wsEvent);

	TWservCrEvent crEvent(TWservCrEvent::EScreenSizeModeChanged,aScreen->ScreenSizeMode());

	TWindowServerEvent::NotifyDrawer(crEvent);

	}

void TWindowServerEvent::SendScreenDeviceChangedEvent(const CWsWindowBase *aWindow)

	{

	CEventQueue *queue=aWindow->EventQueue();

	TUint32 handle=aWindow->ClientHandle();

	queue->WalkEventQueue(&FindScreenDeviceChangedEvent,&handle);

	if (handle!=NULL)	// Indicates event not found

		queue->QueueEvent(handle, EEventScreenDeviceChanged);

	}

TEventQueueWalkRet FindGroupChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

	{

	if (aEvent->Type()==EEventWindowGroupsChanged && aEvent->Handle()==*(TUint *)aHandlePtr)

		{

		*(TUint *)aHandlePtr=0;	// Indicates event found

		}

	return(EEventQueueWalkOk);

	}

void TWindowServerEvent::SendGroupChangedEvents()

	{

	TSglQueIter<TEventRequestItem> iter(iGroupChangedQueue.Queue());

	TEventRequestItem *qPtr;

	while((qPtr=iter++)!=NULL)

		{

		const CWsWindowBase *win=qPtr->iWindow;

		CEventQueue *queue=win->EventQueue();

		TUint32 handle=win->ClientHandle();

		queue->WalkEventQueue(&FindGroupChangedEvent,&handle);

		if (handle!=NULL)	// Indicates event not found

			{

			queue->QueueEvent(handle, EEventWindowGroupsChanged);

			}

		}

	}	

TEventQueueWalkRet FindFocusChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

	{

	if (aEvent->Type()==EEventFocusGroupChanged && aEvent->Handle()==*(TUint *)aHandlePtr)

		{

		*(TUint *)aHandlePtr=0;	// Indicates event found

		}

	return(EEventQueueWalkOk);

	}

void TWindowServerEvent::SendFocusChangedEvents()

	{

	TInt identifier=0;	// Zero Identifier indicates, currently there is no focused window group

	CScreen* currentFocusScreen=CWsTop::CurrentFocusScreen();	

	TInt screenNumber=currentFocusScreen->ScreenNumber();

	CWsWindowGroup* currentFocusWG=currentFocusScreen->FocusWindowGroup();

	WS_ASSERT_DEBUG(currentFocusWG, EWsPanicNoScreen);

	if(currentFocusWG)