// Copyright (c) 1994-2010 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 "W32STD.H"

#include <e32uid.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 "pointer.h"

#include "debugbar.h"

#include "advancedpointereventhelper.h"

#include "graphics/wsgraphicdrawerinternal.h"

#include "debughelper.h"

GLREF_D CDebugLogBase *wsDebugLog;

GLREF_C void StateDump();

GLREF_C void HeapDump();

_LIT(KDefaultKeyRouterPluginName, "keyrouter.dll");

_LIT(KWSERVIniFileVarKeyRouterPlugin, "KEYROUTERPLUGIN");

#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;

CKeyEventRouter* TWindowServerEvent::iKeyEventRouter;

RLibrary TWindowServerEvent::iKeyEventRouterLibrary;

CWsHotKey *TWindowServerEvent::iHotKeys;

TInt TWindowServerEvent::iModifierState;

CRawEventReceiver *TWindowServerEvent::iEventReceiver;

RArray<TWindowServerEvent::TRawEventHandler> 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;

TRepeatKey CKeyboardRepeat::iLongRepeat;

TInt CKeyboardRepeat::iRepeatRollover=1;

CKeyboardRepeat::TRepeatType CKeyboardRepeat::iRepeating=ERepeatNone;

CKeyboardRepeat *CKeyboardRepeat::iThis=NULL;

TTimeIntervalMicroSeconds32 CKeyboardRepeat::iInitialTime;

TTimeIntervalMicroSeconds32 CKeyboardRepeat::iTime;

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;

	delete iKeyEventRouter;

	iKeyEventRouterLibrary.Close();

	CKeyboardRepeat::Destroy();

	delete iKeyTranslator;

	delete iEventReceiver;

	iEventHandlers.Close();

	delete iNotificationHandlers;

	iDrawerHandlers->Close();

	delete iDrawerHandlers;

	iWsEventHandlers.Close();

	}

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);

		}

	// CCaptureKeys is no longer used but a dummy object is required for

	// calls to CKeyTranslator::TranslateKey() until capture functionality

	// has been removed from ektran.dll.

	iCaptureKeys=new(ELeave) CCaptureKeys;

	iCaptureKeys->Construct();

	// Load the key event routing plug-in. The DLL name may be overridden

	// by setting the keyword KEYROUTERPLUGIN in wsini.ini.

	TPtrC pluginName(KDefaultKeyRouterPluginName);

	WsIniFile->FindVar(KWSERVIniFileVarKeyRouterPlugin, pluginName);

	const TUidType uidType(KDynamicLibraryUid, KKeyRouterPluginUid);

	TInt err = iKeyEventRouterLibrary.Load(pluginName, uidType);

	if (wsDebugLog)

		{

		TLogMessageText buf;

		if (err == KErrNone)

			{

			_LIT(KLogLoadOk, "Loaded plugin '%S' UID3 0x%x");

			const TFileName& pluginPathname = iKeyEventRouterLibrary.FileName();

			const TUid uid3 = iKeyEventRouterLibrary.Type()[2];

			buf.Format(KLogLoadOk, &pluginPathname, uid3.iUid);

			}

		else

			{

			_LIT(KLogLoadError, "Failed to load plugin '%S' (error %d)");

			buf.Format(KLogLoadError, &pluginName, err);

			}

		wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant, buf);

		}

	if (err != KErrNone)

		{

#ifdef _DEBUG

		_LIT(KLoadError, "WServ: failed to load plugin '%S' (error %d)");

		RDebug::Print(KLoadError, &pluginName, err);

#endif

		User::Leave(err);

		}

	// Create the key event router

	typedef CKeyEventRouter* (*TCreateFunc)();

	TCreateFunc newL = reinterpret_cast<TCreateFunc>(iKeyEventRouterLibrary.Lookup(1));

	if (newL == NULL)

		{

		User::Leave(KErrNotFound);

		}

	iKeyEventRouter = (*newL)();

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

		ConstructDefaultHotKeyL(index,DefaultHotKeys[index]);

	CKeyboardRepeat::NewL();

	CKeyboardRepeat::SetRepeatTime(EDefaultInitialRepeatTime, EDefaultRepeatTime);

	iEventHandlers=RArray<TRawEventHandler>(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;

	captureKey.priority = 0;

	hotKey->ConstructLD(captureKey);

//

	LinkHotKey(hotKey);

	}

void TWindowServerEvent::AddEventHandler(MEventHandler *aEventHandler, TBool aAdvancedPointersEnabled)

	{

#if defined(_DEBUG)

	TRAPD(err,iEventHandlers.AppendL(TRawEventHandler(aEventHandler, aAdvancedPointersEnabled)));

	WS_ASSERT_DEBUG(err==KErrNone, EWsPanicEventHandlerInconsistency);

#else

	iEventHandlers.AppendL(TRawEventHandler(aEventHandler, aAdvancedPointersEnabled));	//Shouldn't leave

#endif

#ifdef LOG_WSERV_EVENTS

	RDebug::Printf("_WSEVENT_POINTER: TWindowServerEvent::AddEventHandler Added handler = %d AdvancedPointerEnabled = %d", iEventHandlers.Count(),aAdvancedPointersEnabled);

#endif

	}

void TWindowServerEvent::RemoveEventHandler(const MEventHandler *aEventHandler)

	{

	TInt count=iEventHandlers.Count();

	TInt ii;

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

		{

		if (iEventHandlers[ii].iEventHandler==aEventHandler)

			{

#ifdef LOG_WSERV_EVENTS

		    RDebug::Printf("_WSEVENT_POINTER: TWindowServerEvent::RemoveEventHandler Removed handler = %d",ii);

#endif

			if (iEventHandlerCount>0)  

				{

				iBinaryFlags |= ERemovedEventHandlerWhileProcessingRawEvents;

				iEventHandlers[ii].iEventHandler=NULL; // replace the Handler with null to keep size of the array

				}

			else 

				{

				iEventHandlers.Remove(ii);

				}

			return;

			}

		}

	}

void TWindowServerEvent::PotentialEventHandlerL(TInt aNum)

	{

	iPotentialEventHandlers+=aNum;

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

	TRAPD(err,iEventHandlers.Reserve(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();

	if(currentFocusWG)

		{

		identifier=currentFocusWG->Identifier();

		}

	TWindowServerEvent::NotifyDrawer(TWservCrEvent(TWservCrEvent::EWindowGroupChanged,

		screenNumber, reinterpret_cast<TAny*>(identifier)));

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

	TEventRequestItem *qPtr;

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

		{

		const CWsWindowBase *win=qPtr->iWindow;

		CEventQueue *queue=win->EventQueue();

		TUint32 handle=win->ClientHandle();

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

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

			{

			queue->QueueEvent(handle, EEventFocusGroupChanged);

			}

		}

	}

TEventQueueWalkRet FindGroupListChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

	{

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

		{

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

		}

	return(EEventQueueWalkOk);

	}

void TWindowServerEvent::SendGroupListChangedEvents()

	{

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

	TEventRequestItem *qPtr;

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

		{

		const CWsWindowBase *win=qPtr->iWindow;

		CEventQueue *queue=win->EventQueue();

		TUint32 handle=win->ClientHandle();

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

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

			{

			queue->QueueEvent(handle, EEventWindowGroupListChanged);

			}

		}

	}	

TEventQueueWalkRet OverrideVisibilityChangedEvent(TAny *aNewEvent, TWsEvent *aOldEvent)

	{

	// This replaces the first visibility event it finds for the given window with the

	// one given.  This is fine, so long as the meaning of all visibility events remains

	// independent of the ones before.

	TWsEvent* newEvent = static_cast<TWsEvent*>(aNewEvent);

	if (aOldEvent->Type()==EEventWindowVisibilityChanged && aOldEvent->Handle()==newEvent->Handle())

		{

		aOldEvent->SetTimeNow();

		aOldEvent->VisibilityChanged()->iFlags = newEvent->VisibilityChanged()->iFlags;

		newEvent->SetHandle(NULL);

		}

	return EEventQueueWalkOk;

	}

void TWindowServerEvent::SendVisibilityChangedEvents(CWsWindowBase* aWin, TUint aFlags)

	{

	CEventQueue *queue=aWin->EventQueue();

	TWsEvent event;

	event.SetType(EEventWindowVisibilityChanged);

	event.SetHandle(aWin->ClientHandle());

	event.SetTimeNow();

	TWsVisibilityChangedEvent* visevent = event.VisibilityChanged();

	visevent->iFlags = aFlags;

	queue->WalkEventQueue(&OverrideVisibilityChangedEvent,&event);

	if (event.Handle()!=NULL)

		{

		queue->QueueEvent(event);

		}

	}

TEventQueueWalkRet OverrideDisplayChangedEvent(TAny *aNewEvent, TWsEvent *aOldEvent)

	{

	TWsEvent* newEvent = static_cast<TWsEvent*>(aNewEvent);

	if (aOldEvent->Type() == EEventDisplayChanged && 

			aOldEvent->DisplayChanged()->iDisplayNumber == newEvent->DisplayChanged()->iDisplayNumber)

		{

		aOldEvent->SetTimeNow();

		aOldEvent->DisplayChanged()->iConfigurationChangeId = newEvent->DisplayChanged()->iConfigurationChangeId;

		aOldEvent->DisplayChanged()->iResolutionListChangeId = newEvent->DisplayChanged()->iResolutionListChangeId;

		newEvent->DisplayChanged()->iDisplayNumber = KErrNotFound; //So the new event won't be placed on event queue again

		}

	return EEventQueueWalkOk;

	}

TBool TWindowServerEvent::SendDisplayChangedEvents(CWsClient* aWsClient, TInt aDisplayNumber, TInt aConfigurationChangeId, TInt aResolutionListChangeId)

	{

	CEventQueue *queue = aWsClient->EventQueue();

	TWsEvent event;

	event.SetType(EEventDisplayChanged);

	event.SetTimeNow();

    // fill in the handle otherwise CONE will discard the notification

    CWsObjectIx* clientObjList = aWsClient->ObjectIndex();

    const TWsObject* ptr=clientObjList->FirstObject();

    const TWsObject* end=ptr+clientObjList->Length();

    while(++ptr<end)    // first one should always have a NULL object

        {

        const CWsObject* obj=ptr->iObject;

        if (obj && obj->Type()==WS_HANDLE_GROUP_WINDOW)

            {

            event.SetHandle(ptr->iHandle);

            break;

            }

        }	

	TWsDisplayChangedEvent* dispEvent = event.DisplayChanged();

	dispEvent->iDisplayNumber = aDisplayNumber;

	dispEvent->iConfigurationChangeId = aConfigurationChangeId;

	dispEvent->iResolutionListChangeId = aResolutionListChangeId;

	queue->WalkEventQueue(&OverrideDisplayChangedEvent, &event);

	//place the new event on the queue only when its display number is valid (!=KErrNotFound)

	if(event.DisplayChanged()->iDisplayNumber >= 0)

		{

		return queue->QueueEvent(event);

		}

	return ETrue;

	}

void TWindowServerEvent::QueueKeyEvent(CWsWindowGroup *aWin, TWsEvent &aEvent, TWservEventPriorities aPriority)

	{

#ifdef LOG_WSERV_EVENTS

    RDebug::Print(_L("_WSEVENT_KEY: TWindowServerEvent::QueueKeyEvent, Queuing event name %S for application read, window handle: %d"), &WsEventName(aEvent), CWsTop::FocusWindowGroup()->ClientHandle());

#endif

	aEvent.SetTimeNow();

	aWin->EventQueue()->QueueEvent(aEvent, aPriority);

	}

/**

Process a key press event.

This function is called for every input key event and uses the Key Event

Routing plug-in to check for short and long key capture and determine the

destination window group for the queued event(s).

Window server hotkeys are also processed.

Note that the key repeat timer is started here but the key repeat events

generated by the timer go directly to QueueKeyPress().

@param	aKeyEvent		Input key event

@param	aCheckRepeat	Check for key repeat and long key capture

@param	aRepeats		Repeat count

*/

void TWindowServerEvent::ProcessKeyPress(const TKeyEvent& aKeyEvent, TBool aCheckRepeat, TInt aRepeats)

 	{

	CWsWindowGroup* focusWin = CWsTop::FocusWindowGroup();

	TUid focusAppUid = focusWin ? TUid::Uid(focusWin->Client()->SecureId().iId) : KNullUid;

	// Route the key event and check for short key capture.

	// Note that the Key Routing plugin may translate or block key events.

	TKeyEventRouterInput input(ECaptureTypeKey, aKeyEvent, focusWin, focusAppUid);

	TKeyEventRouterOutput output;

#ifdef _DEBUG

	// RouteKey() must not fail. Check for leaves in case the plug-in

	// is badly behaved.

	TRAPD(err, iKeyEventRouter->RouteKey(input, output));

	WS_ASSERT_DEBUG(err == KErrNone, EWsPanicKeyEventRouterLeave);

#else

	iKeyEventRouter->RouteKey(input, output);

#endif

	WS_ASSERT_DEBUG(output.iResult == ERouted || output.iResult == ECaptured || output.iResult == EConsumed, EWsPanicKeyEventRouterBadResult);

	if (output.iResult == EConsumed)

		{

		focusWin = NULL;

		}

	else

		{

		focusWin = static_cast<CWsWindowGroup*>(output.iWindowGroup);

		}

	WS_ASSERT_DEBUG((focusWin == NULL || focusWin->Type() == WS_HANDLE_GROUP_WINDOW) && (output.iResult != ERouted || focusWin == CWsTop::FocusWindowGroup()), EWsPanicKeyEventRouterBadWindowGroup);

	// Ensure that short event is not marked with EModifierLongKey

	output.iKeyEvent.iModifiers &= ~EModifierLongKey;

	// Generate key click unless the event is consumed. This is consistent

	// with the behaviour when CKeyTranslator::TranslateKey() yields no

	// translation for a particular scan code. (Click events for key up/down

	// will still be generated by QueueKeyUpDown()). Note however that a long

	// key press may still be captured even if the short event is consumed.

	if (CClick::IsHandler() && output.iResult != EConsumed)

		{

		output.iKeyEvent.iRepeats = aRepeats;

		CClick::KeyEvent(EEventKey, output.iKeyEvent);

		}

	if (output.iResult == ECaptured)

		{

		if (output.iWindowGroup == NULL)	// Captured by Wserv itself

			{

			_LIT(KWSERVDebugLogCapturedKey,"WSERV Captured Key");

			CScreen* focusScreen=CWsTop::CurrentFocusScreen();

			TInt screenNo=focusScreen->ScreenNumber();

			if (wsDebugLog)

				wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVDebugLogCapturedKey);

			CWsHotKey *hotKey=iHotKeys;

			while(hotKey)

				{

				if (hotKey->KeyHandle() == reinterpret_cast<TInt>(output.iCaptureHandle))

					{

					switch(hotKey->HotKeyType())

						{

						case EHotKeyEnableLogging:

							CWsTop::EnableLogging();

							break;

						case EHotKeyDisableLogging:

							CWsTop::DisableLogging();

							break;

						case EHotKeyStateDump:

							StateDump();

							break;

						case EHotKeyHeapDump:

							HeapDump();

							break;

						case EHotKeyOfDeath:

							if (!CWsPassword::PasswordModeActive())

								{

								const TBool currentJustInTimeValue=User::JustInTime();

								if (currentJustInTimeValue)

									{

									User::SetJustInTime(EFalse);

									}

								CWsTop::KillForegroundSession();

								if (currentJustInTimeValue)

									{

									User::SetJustInTime(ETrue);

									}

								}

							break;

						case EHotKeyShutDown:

							CWsTop::Exit();

							break;

						case EHotKeyIncContrast:

							focusScreen->IncContrast();

							break;

						case EHotKeyDecContrast:

							focusScreen->DecContrast();

							break;

						case EHotKeyOff:

							CWsTop::HandleSwitchOff(EEventKeySwitchOff,ETrue);

							break;

						case EHotKeyBacklightToggle:

							{

							TInt state;

							if (!ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Get(screenNo,HALData::EBacklightState,state)))

								ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Set(screenNo,HALData::EBacklightState,!state));

							}

							break;

						case EHotKeyBacklightOn:

							ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Set(screenNo,HALData::EBacklightState,ETrue));

							break;

						case EHotKeyBacklightOff:

							ProcessErrorMessages(TWsErrorMessage::EBackLight, HAL::Set(screenNo,HALData::EBacklightState,EFalse));

							break;

						case EHotKeyScreenDimension0:

						case EHotKeyScreenDimension1:

						case EHotKeyScreenDimension2:

						case EHotKeyScreenDimension3:

							focusScreen->doSetScreenMode(hotKey->HotKeyType()-EHotKeyScreenDimension0);

							break;

						case EHotKeyCycleDisplaySize:

							focusScreen->CycleDisplaySize();

							break;

						case EHotKeyCycleOrientation:

							focusScreen->CycleOrientation();

							break;

						case EHotKeyIncBrightness:

							focusScreen->IncBrightness();

							break;

						case EHotKeyDecBrightness:

							focusScreen->DecBrightness();

							break;

						case EHotKeyCycleFocusScreen:

							CWsTop::SetCurrentFocusScreen((CWsTop::CurrentFocusScreen()->ScreenNumber()+1)%CWsTop::NumberOfScreens());

							break;

						}

					return;

					}

				hotKey=hotKey->iNext;

				}

			WS_PANIC_ALWAYS(EWsPanicUnknownCaptureKey);

			return;

			}

		_LIT(KWSERVDebugLogKeyCapturedByApp,"Key captured by app %d");

		if (wsDebugLog)

			wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVDebugLogKeyCapturedByApp,focusWin->Identifier());

		if (CWsPassword::PasswordModeActive() && focusWin!=CWsPassword::PasswordWindow()->WinGroup())

			return;

		}

	CWsCaptureLongKey* longCapture = NULL;

	TKeyEventRouterOutput longOutput;

	if (aCheckRepeat)

		{

		// Check for long key capture.

		// Note that a long key event can only result from capture, there is

		// no default detection or routing of long events.

		input.iType = ECaptureTypeLongKey;

#ifdef _DEBUG

		TRAPD(err, iKeyEventRouter->RouteKey(input, longOutput));

		WS_ASSERT_DEBUG(err == KErrNone, EWsPanicKeyEventRouterLeave);

#else

		iKeyEventRouter->RouteKey(input, longOutput);

#endif

		if (longOutput.iResult == ECaptured)

			{

			longCapture = static_cast<CWsCaptureLongKey*>(longOutput.iCaptureHandle);

			// Mark long key events with EModifierLongKey so that applications

			// can easily distinguish short and long events.

			longOutput.iKeyEvent.iModifiers |= EModifierLongKey;

			// Start timer to detect long key press

			CKeyboardRepeat::StartRepeat(aKeyEvent.iScanCode, output, &longOutput);

			}

		else if (output.iResult != EConsumed && output.iKeyEvent.iModifiers & EModifierAutorepeatable)

			{

			// Start timer for key repeat

			CKeyboardRepeat::StartRepeat(aKeyEvent.iScanCode, output, NULL);

			}

		}

	// Queue the short event

	if (!longCapture || longCapture->iFlags & ELongCaptureShortEventImmediately)

		{

		QueueKeyPress(output, EFalse, aRepeats);

		}

	}

/**

Queue a key press event.

This function is called for each key event produced by ProcessKeyPress(),

for every key repeat and long key event generated by the timer and also for

delayed short key events from KeyUp().

@param	aOutput			Output key event from routing plug-in

@param	aIsRepeat		Event is due to key repeat

@param	aRepeats		Repeat count

*/

void TWindowServerEvent::QueueKeyPress(const TKeyEventRouterOutput& aOutput, TBool aIsRepeat, TInt aRepeats)

 	{

	if (aOutput.iResult == EConsumed)

		{

		// Don't deliver this key

		return;

		}

	TWsEvent event;

	TKeyEvent& keyEvent = *event.Key();

	keyEvent = aOutput.iKeyEvent;

	keyEvent.iRepeats = aRepeats;

	CWsWindowGroup* focusWin = static_cast<CWsWindowGroup*>(aOutput.iWindowGroup);

	WS_ASSERT_DEBUG(focusWin == NULL || focusWin->Type() == WS_HANDLE_GROUP_WINDOW, EWsPanicKeyEventRouterBadWindowGroup);

	if (aIsRepeat && aOutput.iResult != ECaptured && focusWin != CWsTop::FocusWindowGroup())

		CKeyboardRepeat::CancelRepeat(NULL);		// Repeat is going to different window so cancel it and don't deliver this key

	else if (focusWin != NULL && focusWin->CheckForPriorityKey(keyEvent) == EFalse)

		{

		event.SetType(EEventKey);

		event.SetHandle(focusWin->ClientHandle());

		if (aRepeats!=0)

			{

			CEventQueue* queue=focusWin->EventQueue();

			queue->Wait();

			const TWsEvent* prev=queue->PeekLastEvent();

			if (prev != NULL && prev->Type() == EEventKey && prev->Key()->iRepeats > 0 && prev->Key()->iCode == keyEvent.iCode)

				{

				prev->Key()->iRepeats += aRepeats;

				queue->Signal();

				if (CClick::IsHandler())

					CClick::KeyEvent(EEventKeyRepeat, *prev->Key());

				return;

				}

			queue->Signal();

			if (CClick::IsHandler())

				CClick::KeyEvent(EEventKeyRepeat,keyEvent);

			}

		QueueKeyEvent(focusWin, event, EEventPriorityLow);

		}

	}

/**

Queue a key up/down event.

@param	aRawEvent		Raw event

*/

void TWindowServerEvent::QueueKeyUpDown(const TRawEvent &aRawEvent)

 	{

#ifdef LOG_WSERV_EVENTS