Symaptic: os/graphics/windowing/windowserver/nonnga/SERVER/EVENT.CPP@260cb5ec6c19

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Top level window server code

    15 //

    16 //

    18 #include "EVENT.H"

    20 #include <hal.h>

    21 #include <w32adll.h>

    22 #include <w32click.h>

    23 #include "server.h"

    24 #include "windowgroup.h"

    25 #include "KEYCLICK.H"

    26 #include "wstop.h"

    27 #include "panics.h"

    28 #include "screen.h"

    29 #include "inifile.h"

    30 #include "password.h"

    31 #include <w32std.h>

    32 #include "pointer.h"

    33 #include "debugbar.h"

    34 #include "wstraces.h"

    35 #include "Graphics/wsgraphicdrawerinternal.h"

    38 GLREF_D CDebugLogBase *wsDebugLog;

    40 GLREF_C void StateDump();

    41 GLREF_C void HeapDump();

    43 #define IMPOSSIBLE 0xFFFFFFFF

    45 const TWsWinCmdCaptureKey ImpossibleKeyPress=

    46 	{

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

    48 	IMPOSSIBLE,

    49 	IMPOSSIBLE};

    51 const TWsWinCmdCaptureKey DefaultHotKeys[TWindowServerEvent::ENumHotKeys]={

    52 	{	// Enable logging

    53 	EModifierFunc|EModifierCtrl|EModifierShift,

    54 	EModifierFunc|EModifierCtrl|EModifierShift,

    55 	5}, // E

    56 	{	// Disable logging

    57 	EModifierFunc|EModifierCtrl|EModifierShift,

    58 	EModifierFunc|EModifierCtrl|EModifierShift,

    59 	4}, // D

    60 	{	// Window server internal dump to log

    61 	EModifierFunc|EModifierCtrl|EModifierShift,

    62 	EModifierFunc|EModifierCtrl|EModifierShift,

    63 	23},// W

    64 	{	// The key of death

    65 	EModifierFunc|EModifierCtrl|EModifierShift,

    66 	EModifierFunc|EModifierCtrl|EModifierShift,

    67 	11},// K

    68 	{	// Shutdown window server

    69 #if defined(_DEBUG)

    70 	EModifierFunc|EModifierCtrl|EModifierShift,

    71 	EModifierFunc|EModifierCtrl|EModifierShift,

    72 	24},// X

    73 #else

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

    75 	IMPOSSIBLE,

    76 	IMPOSSIBLE},

    77 #endif

    78 	{	// Heap dump

    79 	EModifierFunc|EModifierCtrl|EModifierShift,

    80 	EModifierFunc|EModifierCtrl|EModifierShift,

    81 	8}, // H

    82 	{	// Inc Contrast

    83 	0,

    84 	0,

    85 	EKeyIncContrast},

    86 	{	// Dec Contrast

    87 	0,

    88 	0,

    89 	EKeyDecContrast},

    90 	{	// Off

    91 	0,

    92 	0,

    93 	EKeyOff},

    94 	{	// Backlight on

    95 	0,

    96 	0,

    97 	EKeyBacklightOn},

    98 	{	// Backlight off

    99 	0,

   100 	0,

   101 	EKeyBacklightOff},

   102 	{	// Backlight toggle

   103 	0,

   104 	0,

   105 	EKeyBacklightToggle},

   106 	{	// Screen Dimension Change

   107 	0,

   108 	0,

   109 	EKeyScreenDimension0},

   110 	{

   111 	0,

   112 	0,

   113 	EKeyScreenDimension1},

   114 	{

   115 	0,

   116 	0,

   117 	EKeyScreenDimension2},

   118 	{

   119 	0,

   120 	0,

   121 	EKeyScreenDimension3},

   122 #if defined(_DEBUG)

   123 	{	// Display mode cycle

   124 	EModifierFunc|EModifierCtrl|EModifierShift,

   125 	EModifierFunc|EModifierCtrl|EModifierShift,

   126 	21},// U

   127 	{	// Orientation cycle

   128 	EModifierFunc|EModifierCtrl|EModifierShift,

   129 	EModifierFunc|EModifierCtrl|EModifierShift,

   130 	15},// O

   131 #else

   132 	{	// Display mode cycle

   133 	IMPOSSIBLE,	// Impossible to hit key combination

   134 	IMPOSSIBLE,

   135 	IMPOSSIBLE},

   136 	{	// Orientation cycle

   137 	IMPOSSIBLE,	// Impossible to hit key combination

   138 	IMPOSSIBLE,

   139 	IMPOSSIBLE},

   140 #endif

   141 	{	// Inc Brightness

   142 	0,

   143 	0,

   144 	EKeyIncBrightness},

   145 	{	// Dec Brightness

   146 	0,

   147 	0,

   148 	EKeyDecBrightness},

   149 	{	// Cycle focus screen

   150 	EModifierFunc|EModifierCtrl|EModifierShift,

   151 	EModifierFunc|EModifierCtrl|EModifierShift,

   152 	9}, // I

   153 	};

   155 CKeyTranslator *TWindowServerEvent::iKeyTranslator=NULL;

   156 TEventRequestQueue TWindowServerEvent::iSwitchOnQueue;

   157 TEventRequestQueue TWindowServerEvent::iErrorMessageQueue;

   158 TEventRequestQueue TWindowServerEvent::iModifierChangedQueue;

   159 TEventRequestQueue TWindowServerEvent::iGroupChangedQueue;

   160 TEventRequestQueue TWindowServerEvent::iFocusChangedQueue;

   161 TEventRequestQueue TWindowServerEvent::iGroupListChangedQueue;

   162 TEventRequestQueue TWindowServerEvent::iScreenDeviceChangedQueue;

   163 TTime TWindowServerEvent::iPrevOomMessageTime;

   164 CCaptureKeys *TWindowServerEvent::iCaptureKeys;

   165 CWsHotKey *TWindowServerEvent::iHotKeys;

   166 TInt TWindowServerEvent::iModifierState;

   167 CRawEventReceiver *TWindowServerEvent::iEventReceiver;

   168 CArrayPtrFlat<MEventHandler> *TWindowServerEvent::iEventHandlers;

   169 CArrayFixFlat<SNotificationHandler> *TWindowServerEvent::iNotificationHandlers;

   170 TInt TWindowServerEvent::iPotentialEventHandlers=0;

   171 TUint32 TWindowServerEvent::iBinaryFlags=0x00;

   172 RArray<TDrawerHandler>* TWindowServerEvent::iDrawerHandlers;

   173 RArray<TWsEventHandler> TWindowServerEvent::iWsEventHandlers;

   174 TInt TWindowServerEvent::iEventHandlerCount=0;

   175 TRepeatKey CKeyboardRepeat::iCurrentRepeat;

   176 TRepeatKey CKeyboardRepeat::iAlternateRepeat;

   177 TInt CKeyboardRepeat::iRepeatRollover=1;

   178 CKeyboardRepeat::TRepeatType CKeyboardRepeat::iRepeating=ERepeatNone;

   179 CKeyboardRepeat *CKeyboardRepeat::iThis=NULL;

   180 TTimeIntervalMicroSeconds32 CKeyboardRepeat::iInitialTime;

   181 TTimeIntervalMicroSeconds32 CKeyboardRepeat::iTime;

   182 CWsWindowGroup *CKeyboardRepeat::iFocus=NULL;

   183 TBool CKeyboardRepeat::iAlternateRepeatExists=EFalse;

   184 CWsCaptureLongKey* CKeyboardRepeat::iLongCapture=NULL;

   187 void TWindowServerEvent::DeleteHotKeys()

   188 	{

   189 	CWsHotKey *hotKey=iHotKeys;

   190 	while(hotKey)

   191 		{

   192 		CWsHotKey *next=hotKey->iNext;

   193 		delete hotKey;

   194 		hotKey=next;

   195 		}

   196 	iHotKeys=NULL;

   197 	}

   199 void TWindowServerEvent::DeleteStatics()

   200 	{

   201 	DeleteHotKeys();

   202 	delete iCaptureKeys;

   203 	CKeyboardRepeat::Destroy();

   204 	delete iKeyTranslator;

   205 	delete iEventReceiver;

   206 	delete iEventHandlers;

   207 	delete iNotificationHandlers;

   208 	iDrawerHandlers->Close();

   209 	delete iDrawerHandlers;

   210 	}

   212 void TWindowServerEvent::InitStaticsL()

   213 //

   214 // Create the CEvent active object.

   215 //

   216 	{

   217 #if defined(__WINS__)

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

   219 #endif

   220 	iEventReceiver=new(ELeave) CRawEventReceiver(EEventPriority);

   221 	iEventReceiver->ConstructL();

   222 	iKeyTranslator=CKeyTranslator::New();

   223 	User::LeaveIfNull(iKeyTranslator);

   225 //  Change keyboard mapping according to information the HAL

   226 	TInt keyboardIndex;

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

   228 		{

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

   230 		TBuf<16> keyDataDllName;

   231 		keyDataDllName.Format(KLitKeyDataDllName,keyboardIndex);

   232 		iKeyTranslator->ChangeKeyData(keyDataDllName);

   233 		}

   235 	iCaptureKeys=new(ELeave) CCaptureKeys;

   236 	iCaptureKeys->Construct();

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

   238 		ConstructDefaultHotKeyL(index,DefaultHotKeys[index]);

   239 	CKeyboardRepeat::NewL();

   240 	CKeyboardRepeat::SetRepeatTime(EDefaultInitialRepeatTime, EDefaultRepeatTime);

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

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

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

   244 	}

   246 void TWindowServerEvent::LinkHotKey(CWsHotKey *aWsHotKey)

   247 	{

   248 	aWsHotKey->SetLink(iHotKeys);

   249 	iHotKeys=aWsHotKey;

   250 	}

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

   253 	{

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

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

   256 	hotKey->ConstructLD(aSystemKey);

   257 	LinkHotKey(hotKey);

   258 	}

   260 CWsHotKey* TWindowServerEvent::ClearHotKeysL(TInt aHotKey)

   261 	{

   262 	if (aHotKey>ENumHotKeys)

   263 		{

   264 		User::Leave(KErrArgument);

   265 		}

   266 	CWsHotKey** pHotKey= &iHotKeys;

   267 	CWsHotKey* defaultHotKey=NULL;

   268 	while(*pHotKey)

   269 		{

   270 		TBool unlinked=EFalse;

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

   272 			{

   273 			CWsHotKey *free=*pHotKey;

   274 			if (free->IsDefault())

   275 				{

   276 				free->SetL(ImpossibleKeyPress);

   277 				defaultHotKey=free;

   278 				}

   279 			else

   280 				{

   281 				*pHotKey=(*pHotKey)->iNext;

   282 				delete free;

   283 				unlinked=ETrue;

   284 				}

   285 			}

   286 		if (!unlinked)

   287 			{

   288 			pHotKey=&(*pHotKey)->iNext;

   289 			}

   290 		}

   291 	return(defaultHotKey);

   292 	}

   294 void TWindowServerEvent::ResetDefaultHotKeyL(TInt aHotKey)

   295 	{

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

   297 		{

   298 		User::Leave(KErrArgument);

   299 		}

   300 	CWsHotKey* defaultHotKey=ClearHotKeysL(aHotKey);

   301 	WS_ASSERT_DEBUG(defaultHotKey, EWsPanicDefaultHotKeyNotFound);

   302 	defaultHotKey->SetL(DefaultHotKeys[aHotKey]);

   303 	}

   305 void TWindowServerEvent::SetHotKeyL(const TWsClCmdSetHotKey &aHotKey)

   306 	{

   307 	if (aHotKey.type>ENumHotKeys)

   308 		User::Leave(KErrArgument);

   309 //

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

   311 //

   312 	TWsWinCmdCaptureKey captureKey;

   313 	captureKey.modifiers=aHotKey.modifiers;

   314 	captureKey.modifierMask=aHotKey.modifierMask;

   315 	captureKey.key=aHotKey.keycode;

   316 	hotKey->ConstructLD(captureKey);

   317 //

   318 	LinkHotKey(hotKey);

   319 	}

   321 void TWindowServerEvent::AddEventHandler(MEventHandler *aEventHandler)

   322 	{

   323 #if defined(_DEBUG)

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

   325 	WS_ASSERT_DEBUG(err==KErrNone, EWsPanicEventHandlerInconsistency);

   326 #else

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

   328 #endif

   329 	}

   331 void TWindowServerEvent::RemoveEventHandler(const MEventHandler *aEventHandler)

   332 	{

   333 	TInt count=iEventHandlers->Count();

   334 	TInt ii;

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

   336 		{

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

   338 			{

   339 			if (iEventHandlerCount>0)

   340 				{

   341 				iBinaryFlags |= ERemovedEventHandlerWhileProcessingRawEvents;

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

   343 				}

   344 			else

   345 				{

   346 				iEventHandlers->Delete(ii);

   347 				}

   348 			return;

   349 			}

   350 		}

   351 	}

   353 void TWindowServerEvent::PotentialEventHandlerL(TInt aNum)

   354 	{

   355 	iPotentialEventHandlers+=aNum;

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

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

   358 	if (err!=KErrNone)

   359 		{

   360 		if (aNum>0)

   361 			User::Leave(err);

   362 		}

   363 	else if (iPotentialEventHandlers==0)

   364 		iEventHandlers->Compress();

   365 	}

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

   368 	{

   369 	aQptr->iWindow->QueueEvent(aEvent);

   370 	}

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

   373 	{

   374 	aQptr->iWindow->QueueEvent(EEventSwitchOff);

   375 	}*/

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

   378 	{

   379 	TWsEvent event;

   380 	event.SetType(EEventErrorMessage);

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

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

   383 	event.ErrorMessage()->iError=aError;

   384 	event.SetTimeNow();

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

   386 	}

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

   389 	{

   390 	TInt tmpChanged=aChanged&aQptr->iParam;

   391 	if (tmpChanged)

   392 		{

   393 		TWsEvent event;

   394 		event.SetType(EEventModifiersChanged);

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

   396 		event.ModifiersChanged()->iChangedModifiers=tmpChanged;

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

   398 		event.SetTimeNow();

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

   400 		}

   401 	}

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

   404 	{

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

   406 	TEventRequestItem *qPtr;

   407 	CWsWindowGroup *focusWin=CWsTop::FocusWindowGroup();

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

   409 		{

   410 		if (qPtr->iCircumstances==EEventControlAlways ||

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

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

   413 			aFunc(qPtr, aParam1, aParam2);

   414 		}

   415 	}

   417 void TWindowServerEvent::NotifyOom()

   418 	{

   419 	TTime now;

   420 	now.UniversalTime();

   421 	TTimeIntervalSeconds interval;

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

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

   424 		{

   425 		ProcessErrorMessages(TWsErrorMessage::EDrawingRegion,KErrNoMemory);

   426 		iPrevOomMessageTime=now;

   427 		}

   428 	}

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

   431 	{

   432 	if (aError!=KErrNone)

   433 		{

   434 		ProcessEventQueue(iErrorMessageQueue, SendErrorMessage, aCategory, aError);

   435 		return ETrue;

   436 		}

   437 	return EFalse;

   438 	}

   440 void TWindowServerEvent::ProcessModifierChanges()

   441 	{

   442 	TInt newState=iKeyTranslator->GetModifierState();

   443 	if (newState!=iModifierState)

   444 		{

   445 		TInt changed=iModifierState^newState;

   446 		iModifierState=newState;

   447 		ProcessEventQueue(iModifierChangedQueue, SendModifierChangedEvent, changed, 0);

   448 		}

   449 	}

   451 TEventQueueWalkRet FindScreenDeviceChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

   452 	{

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

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

   455 	return(EEventQueueWalkOk);

   456 	}

   458 void TWindowServerEvent::SendScreenDeviceChangedEvents(CScreen* aScreen)

   459 	{

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

   461 	TEventRequestItem *qPtr;

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

   463 		SendScreenDeviceChangedEvent(qPtr->iWindow);

   464 	if(CClick::IsHandler())

   465 		{

   466 		TClickMakerData clickMakerData;

   467 		clickMakerData.screenDeviceMode=aScreen->ScreenSizeMode();

   468 		CClick::OtherEvent(EEventScreenDeviceChanged, &clickMakerData);

   469 		}

   470 	TWsEvent wsEvent;

   471 	wsEvent.SetType(EEventScreenDeviceChanged);

   472 	TWindowServerEvent::PublishNotification(wsEvent);

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

   474 	TWindowServerEvent::NotifyDrawer(crEvent);

   475 	}

   477 void TWindowServerEvent::SendScreenDeviceChangedEvent(const CWsWindowBase *aWindow)

   478 	{

   479 	CEventQueue *queue=aWindow->EventQueue();

   480 	TUint32 handle=aWindow->ClientHandle();

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

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

   483 		queue->QueueEvent(handle, EEventScreenDeviceChanged);

   484 	}

   486 TEventQueueWalkRet FindGroupChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

   487 	{

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

   489 		{

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

   491 		}

   492 	return(EEventQueueWalkOk);

   493 	}

   495 void TWindowServerEvent::SendGroupChangedEvents()

   496 	{

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

   498 	TEventRequestItem *qPtr;

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

   500 		{

   501 		const CWsWindowBase *win=qPtr->iWindow;

   502 		CEventQueue *queue=win->EventQueue();

   503 		TUint32 handle=win->ClientHandle();

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

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

   506 			{

   507 			queue->QueueEvent(handle, EEventWindowGroupsChanged);

   508 			}

   509 		}

   510 	}

   512 TEventQueueWalkRet FindFocusChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

   513 	{

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

   515 		{

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

   517 		}

   518 	return(EEventQueueWalkOk);

   519 	}

   521 void TWindowServerEvent::SendFocusChangedEvents()

   522 	{

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

   524 	CScreen* currentFocusScreen=CWsTop::CurrentFocusScreen();

   525 	TInt screenNumber=currentFocusScreen->ScreenNumber();

   526 	CWsWindowGroup* currentFocusWG=currentFocusScreen->FocusWindowGroup();

   527 	WS_ASSERT_DEBUG(currentFocusWG, EWsPanicNoScreen);

   528 	if(currentFocusWG)

   529 		{

   530 		identifier=currentFocusWG->Identifier();

   531 		}

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

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

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

   536 	TEventRequestItem *qPtr;

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

   538 		{

   539 		const CWsWindowBase *win=qPtr->iWindow;

   540 		CEventQueue *queue=win->EventQueue();

   541 		TUint32 handle=win->ClientHandle();

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

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

   544 			{

   545 			queue->QueueEvent(handle, EEventFocusGroupChanged);

   546 			}

   547 		}

   548 	}

   550 TEventQueueWalkRet FindGroupListChangedEvent(TAny *aHandlePtr, TWsEvent *aEvent)

   551 	{

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

   553 		{

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

   555 		}

   556 	return(EEventQueueWalkOk);

   557 	}

   559 void TWindowServerEvent::SendGroupListChangedEvents()

   560 	{

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

   562 	TEventRequestItem *qPtr;

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

   564 		{

   565 		const CWsWindowBase *win=qPtr->iWindow;

   566 		CEventQueue *queue=win->EventQueue();

   567 		TUint32 handle=win->ClientHandle();

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

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

   570 			{

   571 			queue->QueueEvent(handle, EEventWindowGroupListChanged);

   572 			}

   573 		}

   574 	}

   576 TEventQueueWalkRet OverrideVisibilityChangedEvent(TAny *aNewEvent, TWsEvent *aOldEvent)

   577 	{

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

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

   580 	// independent of the ones before.

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

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

   583 		{

   584 		aOldEvent->SetTimeNow();

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

   586 		newEvent->SetHandle(NULL);

   587 		}

   588 	return EEventQueueWalkOk;

   589 	}

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

   592 	{

   593 	CEventQueue *queue=aWin->EventQueue();

   594 	TWsEvent event;

   595 	event.SetType(EEventWindowVisibilityChanged);

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

   597 	event.SetTimeNow();

   598 	TWsVisibilityChangedEvent* visevent = event.VisibilityChanged();

   599 	visevent->iFlags = aFlags;

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

   601 	if (event.Handle()!=NULL)

   602 		{

   603 		queue->QueueEvent(event);

   604 		}

   605 	}

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

   608 	{

   609 	aEvent.SetTimeNow();

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

   611 	}

   613 void TWindowServerEvent::QueueKeyPress(const TKeyData& aKey, TInt aScanCode, CWsWindowGroup* aRepeatFocus, TBool aCheckRepeat,TInt aRepeats)

   614  	{

   615 	CWsWindowGroup* focusWin=CWsTop::FocusWindowGroup();

   616 	TWsEvent event;

   617 	TKeyEvent& keyEvent=*event.Key();

   618 	keyEvent.iCode=aKey.iKeyCode;

   619 	keyEvent.iScanCode=aScanCode;

   620 	keyEvent.iModifiers=aKey.iModifiers;

   621 	keyEvent.iRepeats=aRepeats;

   622 	if (!aRepeatFocus && CClick::IsHandler())

   623 		CClick::KeyEvent(EEventKey,keyEvent);

   624 	CWsCaptureLongKey* longCapture=NULL;

   625 	if (aCheckRepeat)

   626 		longCapture=CWsCaptureLongKey::CheckForCapture(aKey.iKeyCode, aKey.iModifiers);

   627 	if (aKey.iIsCaptureKey)

   628 		{

   629 		if (aKey.iApp==NULL)	// Captured by Wserv itself

   630 			{

   631 			_LIT(KWSERVDebugLogCapturedKey,"WSERV Captured Key");

   632 			CScreen* focusScreen=CWsTop::CurrentFocusScreen();

   633 			TInt screenNo=focusScreen->ScreenNumber();

   635 			if (wsDebugLog)

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

   637 			CWsHotKey *hotKey=iHotKeys;

   638 			while(hotKey)

   639 				{

   640 				if (hotKey->KeyHandle()==aKey.iHandle)

   641 					{

   642 					switch(hotKey->HotKeyType())

   643 						{

   644 						case EHotKeyEnableLogging:

   645 							CWsTop::EnableLogging();

   646 							break;

   647 						case EHotKeyDisableLogging:

   648 							CWsTop::DisableLogging();

   649 							break;

   650 						case EHotKeyStateDump:

   651 							StateDump();

   652 							break;

   653 						case EHotKeyHeapDump:

   654 							HeapDump();

   655 							break;

   656 						case EHotKeyOfDeath:

   657 							if (!CWsPassword::PasswordModeActive())

   658 								{

   659 								const TBool currentJustInTimeValue=User::JustInTime();

   660 								if (currentJustInTimeValue)

   661 									{

   662 									User::SetJustInTime(EFalse);

   663 									}

   664 								CWsTop::KillForegroundSession();

   665 								if (currentJustInTimeValue)

   666 									{

   667 									User::SetJustInTime(ETrue);

   668 									}

   669 								}

   670 							break;

   671 						case EHotKeyShutDown:

   672 							CWsTop::Exit();

   673 							break;

   674 						case EHotKeyIncContrast:

   675 							focusScreen->IncContrast();

   676 							break;

   677 						case EHotKeyDecContrast:

   678 							focusScreen->DecContrast();

   679 							break;

   680 						case EHotKeyOff:

   681 							CWsTop::HandleSwitchOff(EEventKeySwitchOff,ETrue);

   682 							break;

   683 						case EHotKeyBacklightToggle:

   684 							{

   685 							TInt state;

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

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

   688 							}

   689 							break;

   690 						case EHotKeyBacklightOn:

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

   692 							break;

   693 						case EHotKeyBacklightOff:

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

   695 							break;

   696 						case EHotKeyScreenDimension0:

   697 						case EHotKeyScreenDimension1:

   698 						case EHotKeyScreenDimension2:

   699 						case EHotKeyScreenDimension3:

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

   701 							break;

   702 						case EHotKeyCycleDisplaySize:

   703 							focusScreen->CycleDisplaySize();

   704 							break;

   705 						case EHotKeyCycleOrientation:

   706 							focusScreen->CycleOrientation();

   707 							break;

   708 						case EHotKeyIncBrightness:

   709 							focusScreen->IncBrightness();

   710 							break;

   711 						case EHotKeyDecBrightness:

   712 							focusScreen->DecBrightness();

   713 							break;

   714 						case EHotKeyCycleFocusScreen:

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

   716 							break;

   717 						}

   718 					return;

   719 					}

   720 				hotKey=hotKey->iNext;

   721 				}

   722 			WS_PANIC_ALWAYS(EWsPanicUnknownCaptureKey);

   723 			return;

   724 			}

   725 		focusWin=((CWsWindowGroup *)aKey.iApp);

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

   727 		if (wsDebugLog)

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

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

   730 			return;

   731 		}

   732 	if (aRepeatFocus && aRepeatFocus!=focusWin)

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

   734 	else if (focusWin!=NULL && focusWin->CheckForPriorityKey(aKey,aScanCode)==EFalse)

   735 		{

   736 		if (longCapture || (aCheckRepeat && !aRepeatFocus && aKey.iModifiers&EModifierAutorepeatable))

   737 			{

   738 			if (CKeyboardRepeat::StartRepeat(aKey,aScanCode,focusWin,longCapture))

   739 				return;

   740 			}

   741 		event.SetType(EEventKey);

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

   743 		if (aRepeats!=0)

   744 			{

   745 			CEventQueue* queue=focusWin->EventQueue();

   746 			queue->Wait();

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

   748 			if (prev!=NULL && prev->Type()==EEventKey && prev->Key()->iRepeats>0)

   749 				{

   750 			//WS_ASSERT_DEBUG(prev->Key()->iScanCode==aScanCode, EWsPanicKeyRepeat); //This ASSERT can be triggered by using new functionality, need to find a way to make it tell the difference.

   751 				event= *prev;

   752 				event.Key()->iRepeats+=aRepeats;

   753 				queue->UpdateLastEvent(event);

   754 				if (CClick::IsHandler())

   755 					CClick::KeyEvent(EEventKeyRepeat,*event.Key());

   756 				return;

   757 				}

   758 			queue->Signal();

   759 			event.Key()->iRepeats=aRepeats;

   760 			if (CClick::IsHandler())

   761 				CClick::KeyEvent(EEventKeyRepeat,keyEvent);

   762 			}

   763 		QueueKeyEvent(focusWin, event, EEventPriorityLow);

   764 		}

   765 	}

   767 void TWindowServerEvent::QueueKeyUpDown(const TRawEvent &aRawEvent)

   768  	{

   769 	CWsWindowGroup *focusWin=CWsCaptureKeyUpsAndDowns::CheckForCapture(aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE, iModifierState);

   770 	if (!focusWin)	// If not captured

   771 		focusWin=CWsTop::FocusWindowGroup();

   772 	TWsEvent event;

   773 	TEventCode type=aRawEvent.Type()==TRawEvent::EKeyUp ? EEventKeyUp : EEventKeyDown;

   774 	event.Key()->iCode=0;

   775 #if defined(__WINS__)

   776 	if (focusWin && !focusWin->WsOwner()->RemoveKeyCode())

   777 		event.Key()->iScanCode=aRawEvent.ScanCode();

   778 	else

   779 #endif

   780 	event.Key()->iScanCode=aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE;

   781 	event.Key()->iModifiers=iModifierState;

   782 	event.Key()->iRepeats=0;

   783 	if (CClick::IsHandler())

   784 		CClick::KeyEvent(type,*event.Key());

   785 	if (focusWin!=NULL)

   786 		{

   787 		event.SetType(type);

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

   789 		QueueKeyEvent(focusWin, event, EEventPriorityHigh);

   790 		}

   791 	}

   793 LOCAL_D void GetPointerEvent(TPointerEvent::TType& aType, const TRawEvent &aRawEvent, TBool& aHandled)

   794 	{

   795 	aHandled=ETrue;

   796 	switch(aRawEvent.Type())

   797 		{

   798 	case TRawEvent::EButton1Down:

   799 		aType=TPointerEvent::EButton1Down;

   800 		break;

   801 	case TRawEvent::EButton1Up:

   802 		aType=TPointerEvent::EButton1Up;

   803 		break;

   804 	case TRawEvent::EButton2Down:

   805 		aType=TPointerEvent::EButton2Down;

   806 		break;

   807 	case TRawEvent::EButton2Up:

   808 		aType=TPointerEvent::EButton2Up;

   809 		break;

   810 	case TRawEvent::EButton3Down:

   811 		aType=TPointerEvent::EButton3Down;

   812 		break;

   813 	case TRawEvent::EButton3Up:

   814 		aType=TPointerEvent::EButton3Up;

   815 		break;

   816 	case TRawEvent::EPointerMove:

   817 		aType=TPointerEvent::EMove;

   818 		break;

   819 	case TRawEvent::EPointerSwitchOn:

   820 		aType=TPointerEvent::ESwitchOn;

   821 		break;

   822 	default:

   823 		aHandled=EFalse;

   824 		}

   825 	}

   827 TBool TWindowServerEvent::MousePress(const TRawEvent &aRawEvent, const CWsWindowGroup *aGroupWin)

   828 	//

   829 	//Return EFalse if known not to be a Mouse Event

   830 	//

   831 	{

   832 	TBool handled=ETrue;

   833 	TPointerEvent::TType type;

   834 	GetPointerEvent(type, aRawEvent, handled);

   835 	if (handled)

   836 		{

   837 		TPoint xy(aRawEvent.Pos());

   838 		WsPointer::ProcessEvent(type, xy, iKeyTranslator->GetModifierState(), aGroupWin, ETrue);

   839 		}

   840 	return handled;

   841 	}

   843 LOCAL_D void SendEventToKeyClick(const TRawEvent& aRawEvent)

   844 	{

   845 	switch(aRawEvent.Type())

   846 		{

   847 		case TRawEvent::EKeyDown:

   848 		case TRawEvent::EKeyUp:

   849 			{

   850 			TKeyEvent keyEvent;

   851 			keyEvent.iCode=0;

   852 			keyEvent.iScanCode=aRawEvent.ScanCode();

   853 			keyEvent.iModifiers=0;

   854 			keyEvent.iRepeats=0;

   855 			CClick::KeyEvent(EEventKey,keyEvent);

   856 			}

   857 			break;

   858 		case TRawEvent::EButton1Down:

   859 		case TRawEvent::EButton1Up:

   860 		case TRawEvent::EButton2Down:

   861 		case TRawEvent::EButton2Up:

   862 		case TRawEvent::EButton3Down:

   863 		case TRawEvent::EButton3Up:

   864 		case TRawEvent::EPointerMove:

   865 		case TRawEvent::EPointerSwitchOn:

   866 			{

   867 			TBool handled=ETrue;

   868 			TPointerEvent::TType type;

   869 			GetPointerEvent(type, aRawEvent, handled);

   870 			if (handled)

   871 				{

   872 				TPointerEvent pointerEvent;

   873 				pointerEvent.iType=type;

   874 				pointerEvent.iModifiers=0;

   875 				pointerEvent.iPosition=aRawEvent.Pos();

   876 				pointerEvent.iParentPosition=TPoint(KMinTInt32,KMinTInt32);

   877 				CClick::PointerEvent(pointerEvent.iPosition,pointerEvent);

   878 				}

   879 			}

   880 			break;

   881 		default:

   882 			break;

   883 		}

   884 	}

   886 void TWindowServerEvent::ProcessRawEvent(const TRawEvent& aRawEvent)

   887 //

   888 // Event has completed.

   889 //

   890 	{

   891 	WS_TRACE_SERVER_PROCESSRAWEVENT();

   892 	TInt count=iEventHandlers->Count();

   893 	TInt ii;

   894 	TBool eventHandled = EFalse;

   895 	iEventHandlerCount++;

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

   897 		{

   898 		if ((*iEventHandlers)[ii] != NULL && (*iEventHandlers)[ii]->OfferRawEvent(aRawEvent))

   899 			{

   900 			if (CClick::IsHandler())

   901 				{

   902 				SendEventToKeyClick(aRawEvent);

   903 				}

   904 			eventHandled = ETrue;

   905 			break;

   906 			}

   907 		}

   908 	if (--iEventHandlerCount == 0)

   909 		{

   910 		if (ERemovedEventHandlerWhileProcessingRawEvents & iBinaryFlags) // Handler was deleted while previous loop

   911 			{

   912 			iBinaryFlags &= ~ERemovedEventHandlerWhileProcessingRawEvents;

   913 			for(ii=count-1;ii>=0;--ii)

   914 				{

   915 				if ((*iEventHandlers)[ii]==NULL) iEventHandlers->Delete(ii);

   916 				}

   917 			}

   918 		}

   919 	if (eventHandled)

   920 		{

   921 		return;

   922 		}

   923 	switch(aRawEvent.Type())

   924 		{

   925 		case TRawEvent::ERedraw:

   926 			CWsTop::RedrawScreens();

   927 			break;

   928 		case TRawEvent::ESwitchOn:

   929 		case TRawEvent::ECaseOpen:

   930 			{

   931 			TInt event=EEventCaseOpened;

   932 			CKeyboardRepeat::CancelRepeat(NULL);

   933 			CWsPassword::SwitchOn();

   934 			if (aRawEvent.Type()==TRawEvent::ESwitchOn)

   935 				{

   936 				UserSvr::WsSwitchOnScreen();

   937 				HAL::Set(HALData::EDisplayState,1);

   938 				event=EEventSwitchOn;

   939 				}

   940 			ProcessEventQueue(iSwitchOnQueue, SendSwitchOnEvent, event, 0);

   941 			break;

   942 			}

   943 		case TRawEvent::ESwitchOff:

   944 		case TRawEvent::ECaseClose:

   945 			{

   946 			TBool switchOff=(aRawEvent.Type()==TRawEvent::ESwitchOff);

   947 			CWsTop::HandleSwitchOff(switchOff? EEventSwitchOff:EEventCaseClosed,switchOff);

   948 			break;

   949 			}

   950 #ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

   951 		case TRawEvent::ERestartSystem:

   952 			{ /* restart event being handled */

   953 			CWsTop::HandleSwitchOff(EEventRestartSystem,ETrue);

   954 			break;

   955 			}

   956 #endif

   957 		case TRawEvent::EInactive:

   958 #ifndef __WINS__

   959 			CWsTop::WindowServer()->AnimationScheduler()->OnInactive();

   960 #endif

   961 			CKeyboardRepeat::CancelRepeat(NULL);

   962 			break;

   963 		case TRawEvent::EActive:

   964 #ifndef __WINS__

   965 			CWsTop::WindowServer()->AnimationScheduler()->OnActive();

   966 #endif

   967 			break;

   968 		case TRawEvent::EKeyDown:

   969 			{

   970 			_LIT(KWSERVDebugLogKeyDownArrival,"Key down arrives %d");

   971 			if(CDebugBar* dbg = CWsTop::Screen()->DebugBar())

   972 				dbg->OnKeyEvent();

   973 			if (wsDebugLog)

   974 				wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVDebugLogKeyDownArrival,aRawEvent.ScanCode());

   975 			CKeyboardRepeat::KeyDown();

   976 			TKeyData keyData;

   977 			TBool translated=iKeyTranslator->TranslateKey(aRawEvent.ScanCode(), EFalse,*iCaptureKeys,keyData);

   978 			ProcessModifierChanges();

   979 			QueueKeyUpDown(aRawEvent);

   980 			if (translated)

   981 				QueueKeyPress(keyData,aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE,NULL,ETrue,0);

   982 			}

   983 			break;

   984 		case TRawEvent::EKeyUp:

   985 			{

   986 			_LIT(KWSERVDebugLogKeyUpArrival,"Key up arrives %d");

   987 			if(CDebugBar* dbg = CWsTop::Screen()->DebugBar())

   988 				dbg->OnKeyEvent();

   989 			if (wsDebugLog)

   990 				wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVDebugLogKeyUpArrival,aRawEvent.ScanCode());

   991 			TKeyData keyData;

   992 			CKeyboardRepeat::KeyUp(aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE);

   993 			TBool translated=iKeyTranslator->TranslateKey(aRawEvent.ScanCode(), ETrue,*iCaptureKeys,keyData);

   994 			ProcessModifierChanges();

   995 			QueueKeyUpDown(aRawEvent);

   996 			if (translated)

   997 				{

   998 				CKeyboardRepeat::CancelRepeat(NULL);

   999 				QueueKeyPress(keyData,aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE,NULL,EFalse,0);

  1000 				}

  1001 			}

  1002 			break;

  1003 		case TRawEvent::EButton1Down:

  1004 		case TRawEvent::EButton2Down:

  1005 		case TRawEvent::EButton3Down:

  1006 		case TRawEvent::EPointerSwitchOn:

  1007 #ifndef __WINS__

  1008 			CWsTop::WindowServer()->AnimationScheduler()->OnActive();

  1009 #endif

  1010 			// fall through

  1011 		case TRawEvent::EButton1Up:

  1012 		case TRawEvent::EButton2Up:

  1013 		case TRawEvent::EButton3Up:

  1014 		case TRawEvent::EPointerMove:

  1015 			#if defined(_DEBUG)

  1016 				WS_ASSERT_DEBUG(MousePress(aRawEvent,NULL), EWsPanicEventType);

  1017 			#else

  1018 				MousePress(aRawEvent,NULL);

  1019 			#endif

  1020 			break;

  1021 		case TRawEvent::EUpdateModifiers:

  1022 			iKeyTranslator->UpdateModifiers(aRawEvent.Modifiers());

  1023 			break;

  1024 		case TRawEvent::EKeyRepeat:

  1025  			{

  1026  			_LIT(KWSERVDebugLogRepeatingKeyArrival,"Repeating key arrives %d");

  1027  			if (wsDebugLog)

  1028  				wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,KWSERVDebugLogRepeatingKeyArrival,aRawEvent.ScanCode());

  1029  			TKeyData keyData;

  1030  			keyData.iModifiers=iKeyTranslator->GetModifierState();

  1031 			keyData.iApp=0;

  1032 			keyData.iHandle=0;

  1033 			keyData.iIsCaptureKey=EFalse;

  1034 			keyData.iKeyCode=aRawEvent.ScanCode();

  1035 			iCaptureKeys->ProcessCaptureKeys(keyData);

  1036 			QueueKeyPress(keyData, aRawEvent.ScanCode() __REMOVE_WINS_CHARCODE,NULL,EFalse,aRawEvent.Repeats());

  1037  			}

  1038  			break;

  1039 		default:

  1040 			break;

  1041 		}

  1042 	}

  1044 void TWindowServerEvent::ProcessKeyEvent(const TKeyEvent &aKeyEvent,TInt aRepeats)

  1045 	{

  1046 	TKeyData keyData;

  1047 	keyData.iModifiers=aKeyEvent.iModifiers;

  1048 	keyData.iApp=0;

  1049 	keyData.iHandle=0;

  1050 	keyData.iIsCaptureKey=EFalse;

  1051 	keyData.iKeyCode=aKeyEvent.iCode;

  1052 	if (CKeyboardRepeat::IsAreadyActive())

  1053 		{

  1054 		CKeyboardRepeat::CancelRepeat(NULL);

  1055 		}

  1056 	iCaptureKeys->ProcessCaptureKeys(keyData);

  1057 	QueueKeyPress(keyData,aKeyEvent.iScanCode,NULL,aRepeats==0,aRepeats);

  1058 	}

  1060 void TWindowServerEvent::AddCaptureKeyL(const TCaptureKey &aCaptureKey)

  1061 	{

  1062 	iCaptureKeys->AddCaptureKeyL(aCaptureKey,aCaptureKey.iKeyCodePattern.iFiller);

  1063 	}

  1065 void TWindowServerEvent::SetCaptureKey(TUint32 aHandle, const TCaptureKey &aCaptureKey)

  1066 	{

  1067 	iCaptureKeys->SetCaptureKey(aHandle, aCaptureKey,aCaptureKey.iKeyCodePattern.iFiller);

  1068 	}

  1070 void TWindowServerEvent::CancelCaptureKey(TUint32 aHandle)

  1071 	{

  1072 	iCaptureKeys->CancelCaptureKey(aHandle);

  1073 	}

  1075 TInt TWindowServerEvent::GetModifierState()

  1076 	{

  1077 	return(iKeyTranslator->GetModifierState());

  1078 	}

  1080 void TWindowServerEvent::SetModifierState(TEventModifier aModifier,TModifierState aState)

  1081 	{

  1082 	iKeyTranslator->SetModifierState(aModifier,aState);

  1083 	}

  1085 TInt TWindowServerEvent::AddNotificationHandler(CAnim* aAnim, TUint32 aNotifications)

  1086 	{

  1087 	SNotificationHandler notif;

  1088 	notif.iAnim = aAnim;

  1089 	notif.iNotifications = aNotifications;

  1091 	// update the entry if the anim is already in the array

  1092 	TInt count=iNotificationHandlers->Count();

  1093 	TInt ii;

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

  1095 		{

  1096 		if ((*iNotificationHandlers)[ii].iAnim==aAnim)

  1097 			{

  1098 			(*iNotificationHandlers)[ii]=notif;

  1099 			return KErrNone;

  1100 			}

  1101 		}

  1103 	// otherwise add it to the array

  1104 	TRAPD(err,iNotificationHandlers->AppendL(notif));

  1105 	return err;

  1106 	}

  1108 void TWindowServerEvent::RemoveNotificationHandler(CAnim* aAnim)

  1109 	{

  1110 	TInt count=iNotificationHandlers->Count();

  1111 	TInt ii;

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

  1113 		{

  1114 		if ((*iNotificationHandlers)[ii].iAnim==aAnim)

  1115 			{

  1116 			iNotificationHandlers->Delete(ii);

  1117 			return;

  1118 			}

  1119 		}

  1120 	}

  1122 void TWindowServerEvent::PublishNotification(const TWsEvent& aWsEvent)

  1123 	{

  1124 	TInt count=iNotificationHandlers->Count();

  1125 	TInt ii;

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

  1127 		{

  1128 		SNotificationHandler notif = (*iNotificationHandlers)[ii];

  1129 		switch (aWsEvent.Type())

  1130 			{

  1131 		case EEventDirectScreenAccessBegin:

  1132 		case EEventDirectScreenAccessEnd:

  1133 			if (notif.iNotifications & EDirectScreenAccess)

  1134 				{

  1135 				notif.iAnim->HandleNotification(aWsEvent);

  1136 				}

  1137 			break;

  1138 		case EEventHeartbeatTimerStateChange:

  1139 			if (notif.iNotifications & EHeartbeatTimer)

  1140 				{

  1141 				notif.iAnim->HandleNotification(aWsEvent);

  1142 				}

  1143 			break;

  1144 		case EEventScreenDeviceChanged:

  1145 			if (notif.iNotifications & EScreenDeviceChange)

  1146 				{

  1147 				notif.iAnim->HandleNotification(aWsEvent);

  1148 				}

  1149 			break;

  1150 		default:

  1151 			break;

  1152 			}

  1153 		}

  1155 	}

  1157 TBool TWindowServerEvent::DrawerCompareFunc(const TDrawerHandler& lhs, const TDrawerHandler& rhs)

  1158 	{

  1159 	return lhs.iDrawer == rhs.iDrawer;

  1160 	}

  1162 TInt TWindowServerEvent::RegisterDrawerHandler(CWsGraphicDrawer* aDrawer, TUint32 aEvents)

  1163 	{

  1164 	TInt idx = iDrawerHandlers->Find(TDrawerHandler(aDrawer, aEvents),

  1165 		TIdentityRelation<TDrawerHandler>(TWindowServerEvent::DrawerCompareFunc));

  1166 	if (idx != KErrNotFound)

  1167 		{

  1168 		// replace event mask for this drawer

  1169 		(*iDrawerHandlers)[idx].iEvents = aEvents;

  1170 		idx = KErrNone;

  1171 		}

  1172 	else

  1173 		idx = iDrawerHandlers->Append(TDrawerHandler(aDrawer,aEvents));

  1175 	return idx;

  1176 	}

  1178 TInt TWindowServerEvent::UnregisterDrawerHandler(CWsGraphicDrawer* aDrawer)

  1179 	{

  1180 	TInt idx = iDrawerHandlers->Find(TDrawerHandler(aDrawer,0),

  1181 		TIdentityRelation<TDrawerHandler>(TWindowServerEvent::DrawerCompareFunc));

  1182 	if (idx == KErrNotFound)

  1183 		return idx;

  1184 	(*iDrawerHandlers)[idx].iDrawer = NULL;		//NotifyDrawer() will clean up the array

  1185 	return KErrNone;

  1186 	}

  1188 TInt TWindowServerEvent::RegisterWsEventHandler(MWsEventHandler * aHandler, TUint32 aEvents)

  1189 	{

  1190 	TWsEventHandler handler(aHandler, aEvents);

  1191 	TInt idx = iWsEventHandlers.Find(handler, TIdentityRelation<TWsEventHandler>(TWsEventHandler::CompareHandler));

  1192 	if (idx < 0)

  1193 		{

  1194 		TInt err = iWsEventHandlers.Append(handler);

  1195 		return err;

  1196 		}

  1197 	else

  1198 		{

  1199 		iWsEventHandlers[idx].iEvents = aEvents;

  1200 		return KErrNone;

  1201 		}

  1202 	}

  1204 TInt TWindowServerEvent::UnregisterWsEventHandler(MWsEventHandler * aHandler)

  1205 	{

  1206 	TWsEventHandler handler(aHandler, 0);

  1207 	TInt idx = iWsEventHandlers.Find(handler, TIdentityRelation<TWsEventHandler>(TWsEventHandler::CompareHandler));

  1208 	if (idx < 0)

  1209 		return idx;

  1210 	iWsEventHandlers[idx].iEvents = NULL;	//NotifyDrawer() will clean up the array

  1211 	return KErrNone;

  1212 	}

  1215 void TWindowServerEvent::NotifyDrawer(const TWservCrEvent& aEvent)

  1216 	{

  1217 	TInt drawerCount = iDrawerHandlers->Count();

  1218 	for (TInt idx = 0; idx < drawerCount; idx++)

  1219 		{

  1220 		TDrawerHandler hd = (*iDrawerHandlers)[idx];

  1221 		if (!hd.iDrawer)

  1222 			{                					//If the handler has been removed

  1223 			iDrawerHandlers->Remove(idx);       //Remove from the array

  1224 			drawerCount -= 1;   				//Update the counters

  1225 			idx -= 1;

  1226 			}

  1227 		else

  1228 			{

  1229 			if (hd.iEvents & aEvent.Type())

  1230 				{

  1231 			    hd.iDrawer->HandleEvent(aEvent);

  1232 			    }

  1233 			}

  1234 		}

  1236 	TInt eventHandlerCount = iWsEventHandlers.Count();

  1237 	for (TInt idx = 0; idx < eventHandlerCount; ++idx)

  1238 		{

  1239 		TWsEventHandler* eh = &iWsEventHandlers[idx];

  1240 		if (!eh->iEvents)

  1241 			{								//If the handler has been removed

  1242 			iWsEventHandlers.Remove(idx);	//Remove from the array

  1243 			drawerCount -= 1;				//Update the counters

  1244 			idx -= 1;

  1245 			}

  1246 		else

  1247 			{

  1248 			if (eh->iEvents & aEvent.Type())

  1249 				{

  1250 				eh->iHandler->DoHandleEvent(aEvent);

  1251 				}

  1252 			}

  1253 		}

  1254 	}

  1256 void TWindowServerEvent::NotifyScreenDrawingEvent(const TRegion* aRegion)

  1257 	{

  1258 	if (aRegion && !aRegion->IsEmpty())

  1259 		{

  1260 		TWservCrEvent event(TWservCrEvent::EScreenDrawing,0,const_cast<TRegion*>(aRegion));

  1261 		NotifyDrawer(event);

  1262 		}

  1263 	}

  1265 void TWindowServerEvent::NotifyScreenDrawingEvent(const TRect& aRect)

  1266 	{

  1267 	TRegionFix<1> reg(aRect);

  1268 	TWservCrEvent event(TWservCrEvent::EScreenDrawing,0,&reg);

  1269 	NotifyDrawer(event);

  1270 	}

  1272 //

  1273 // CRawEventReceiver //

  1274 //

  1276 CRawEventReceiver::CRawEventReceiver(TInt aPriority) : CActive(aPriority)

  1277 //

  1278 // Constructor

  1279 //

  1280 	{

  1281 	__DECLARE_NAME(_S("CRawEventReceiver"));

  1282 	}

  1284 CRawEventReceiver::~CRawEventReceiver()

  1285 	{

  1286 	CActive::Cancel();

  1287 	}

  1289 void CRawEventReceiver::ConstructL()

  1290 	{

  1291 	CActiveScheduler::Add(this);

  1292 	UserSvr::CaptureEventHook();

  1293 	Request();

  1294 	}

  1296 void CRawEventReceiver::Request()

  1297 //

  1298 // Issue a request for the next event.

  1299 //

  1300 	{

  1301 	UserSvr::RequestEvent(iEventBuf,iStatus);

  1302 	SetActive();

  1303 	}

  1305 void CRawEventReceiver::DoCancel()

  1306 //

  1307 // Cancel a pending event.

  1308 //

  1309 	{

  1310 	UserSvr::RequestEventCancel();

  1311 	}

  1313 void CRawEventReceiver::RunL()

  1314 	{

  1315 //__PROFILE_START(11);

  1316 	if (WsPointer::PreProcessEvent(iEventBuf.Event()

  1317 #if defined(__WINS__)

  1318 													,ETrue

  1319 #endif

  1320 														  ))

  1321 		TWindowServerEvent::ProcessRawEvent(iEventBuf.Event());

  1322 	Request();

  1323 //__PROFILE_END(11);

  1324 	}

  1326 //

  1327 // TEventRequestQueue //

  1328 //

  1330 TEventRequestQueue::TEventRequestQueue() : iQueue(_FOFF(TEventRequestItem,iQue))

  1331 	{}

  1333 inline TSglQue<TEventRequestItem> &TEventRequestQueue::Queue()

  1334 	{return(iQueue);}

  1336 TEventRequestItem *TEventRequestQueue::FindInEventRequestQueueList(const CWsWindowBase &aWindow)

  1337 //

  1338 // Return a pointer to the link in the queue for the window, or NULL if not in the queue

  1339 //

  1340 	{

  1341 	TSglQueIter<TEventRequestItem> iter(iQueue);

  1342 	TEventRequestItem *qPtr;

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

  1344 		if (qPtr->iWindow==&aWindow)

  1345 			break;

  1346 	return(qPtr);

  1347 	}

  1349 void TEventRequestQueue::AddToEventRequestListL(const CWsWindowBase &aWindow, TInt aParam, TEventControl aCircumstances)

  1350 //

  1351 // Add a link to the on event list

  1352 //

  1353 	{

  1354 	TEventRequestItem *item=FindInEventRequestQueueList(aWindow);

  1355 	if (!item)

  1356 		{

  1357 		item=new(ELeave) TEventRequestItem;

  1358 		item->iWindow= &aWindow;

  1359 		item->iParam=aParam;

  1360 		item->iCircumstances=aCircumstances;

  1361 		iQueue.AddFirst(*item);

  1362 		}

  1363 	item->iCircumstances=aCircumstances;

  1364 	item->iParam=aParam;	// Just update the parameter if already exists

  1365 	}

  1367 void TEventRequestQueue::RemoveFromEventRequestListL(const CWsWindowBase &aWindow)

  1368 //

  1369 // Remove a link from the on event list

  1370 //

  1371 	{

  1372 	TEventRequestItem *qPtr=FindInEventRequestQueueList(aWindow);

  1373 	if (qPtr)

  1374 		{

  1375 		iQueue.Remove(*qPtr);

  1376 		delete qPtr;

  1377 		}

  1378 	}

  1380 //

  1381 // Keyboard auto repeat class //

  1382 //

  1384 CKeyboardRepeat::CKeyboardRepeat() : CTimer(EKeyRepeatPriority)

  1385 	{}

  1387 void CKeyboardRepeat::NewL()

  1388 	{

  1389 	iThis=new(ELeave) CKeyboardRepeat();

  1390 	iThis->ConstructL();

  1391 	CActiveScheduler::Add(iThis);

  1392 	_LIT(KWSERVIniFileVarRepeatRollover,"REPEATROLLOVER");

  1393 	WsIniFile->FindVar(KWSERVIniFileVarRepeatRollover,iRepeatRollover);

  1394 	}

  1396 void CKeyboardRepeat::Destroy()

  1397 	{

  1398 	delete iThis;

  1399 	}

  1401 void CKeyboardRepeat::GetRepeatTime(TTimeIntervalMicroSeconds32 &aInitialTime, TTimeIntervalMicroSeconds32 &aTime)

  1402 	{

  1403 	aInitialTime=iInitialTime;

  1404 	aTime=iTime;

  1405 	}

  1407 void CKeyboardRepeat::SetRepeatTime(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)

  1408 	{

  1409 	iInitialTime=aInitialTime;

  1410 	iTime=aTime;

  1411 	}

  1413 void CKeyboardRepeat::RunL()

  1414 	{

  1415 	User::ResetInactivityTime();

  1416 	//WS_ASSERT_DEBUG(iRepeating!=ERepeatNone, EWsPanicTemp);

  1417 	TBool timer=ETrue;

  1418 	if (iRepeating>=ERepeatLong)

  1419 		{

  1420 		// Defensive programming - iLongCapture should never be NULL if iRepeating >= ERepeatLong

  1421 		if (iLongCapture)

  1422 			{

  1423 			iCurrentRepeat.iKey.iApp=REINTERPRET_CAST(TUint32,iLongCapture->iWindowGroup);

  1424 			iCurrentRepeat.iKey.iHandle=0;

  1425 			iCurrentRepeat.iKey.iIsCaptureKey=ETrue;

  1426 			iCurrentRepeat.iKey.iKeyCode=iLongCapture->iData.outputKey;

  1427 			timer=iLongCapture->iData.flags&ELongCaptureRepeatEvents;

  1428 			iRepeating=ERepeatLongRepeated;

  1429 			}

  1430 		else

  1431 			{

  1432 			// Defensive programming - iLongCapture should never be NULL if iRepeating >= ERepeatLong

  1433 			// Stop key repeat if this incorrect condition occurs

  1434 			timer=EFalse;

  1435 			}

  1436 		}

  1437 	if (timer)

  1438 		After(iTime);

  1439 	else

  1440 		iRepeating=ERepeatNone;

  1441 	TWindowServerEvent::QueueKeyPress(iCurrentRepeat.iKey,iCurrentRepeat.iScanCode,iFocus,EFalse,1);

  1442 	}

  1444 TBool CKeyboardRepeat::StartRepeat(const TKeyData &aKey, TInt aScanCode, CWsWindowGroup *aRepeatFocus, CWsCaptureLongKey* aLongCapture)

  1445 	{

  1446 	TTimeIntervalMicroSeconds32 time;

  1447 	TBool ret=EFalse;

  1448 	iCurrentRepeat.iScanCode=aScanCode;

  1449 	iCurrentRepeat.iKey=aKey;

  1450 	iFocus=aRepeatFocus;

  1451 	if (aLongCapture)

  1452 		{

  1453 		iLongCapture=aLongCapture;

  1454 		iRepeating=ERepeatLong;

  1455 		time=aLongCapture->iData.delay;

  1456 		ret=!(aLongCapture->iData.flags&ELongCaptureShortEventImmediately);

  1457 		}

  1458 	else

  1459 		{

  1460 		iRepeating=ERepeatNormal;

  1461 		time=iInitialTime;

  1462 		}

  1463 	iThis->After(time);

  1464 	return ret;

  1465 	}

  1467 void CKeyboardRepeat::doCancelRepeat()

  1468 	{

  1469 	iRepeating=ERepeatNone;

  1470 	iThis->Cancel();

  1471 	}

  1473 void CKeyboardRepeat::CancelRepeat(CWsWindowGroup *aRepeatFocus)

  1474 	{

  1475 	if (aRepeatFocus==NULL || aRepeatFocus==iFocus)

  1476 		{

  1477 		if (iRepeating)

  1478 			doCancelRepeat();

  1479 		iAlternateRepeatExists=EFalse;

  1480 		}

  1481 	else if (iRepeating >= ERepeatLong)

  1482 		{

  1483 		// Defensive programming - iLongCapture should never be NULL if iRepeating >= ERepeatLong

  1484 		if (iLongCapture && iLongCapture->iWindowGroup == aRepeatFocus)

  1485 			{

  1486 			doCancelRepeat();

  1487 			iAlternateRepeatExists=EFalse;

  1488 			}

  1489 		}

  1490 	}

  1492 void CKeyboardRepeat::CancelRepeat(CWsWindowGroup *aRepeatFocus,TUint aScanCode,TBool aLongCaptureFlag,TUint aModifiers)

  1493 	{

  1494 	// aLongCaptureFlag indicates if CancelRepeat caused by call to CancelCaptureLongKey()

  1495 	if (aLongCaptureFlag)

  1496 		{

  1497 		// long capture key is cancelled

  1498 		if (iRepeating >= ERepeatLong && iCurrentRepeat.iScanCode==aScanCode)

  1499 				{

  1500 				// Defensive programming - iLongCapture should never be NULL if iRepeating >= ERepeatLong

  1501 				if (iLongCapture && aRepeatFocus == iLongCapture->iWindowGroup &&

  1502 					(aModifiers & iLongCapture->iData.modifierMask) == iLongCapture->iData.modifiers)

  1503 					{

  1504 					doCancelRepeat();

  1505 					iAlternateRepeatExists=EFalse;

  1506 					}

  1507 				}

  1508 		}

  1509 	else

  1510 		{

  1511 		// normal capture key is cancelled

  1512 		if (aRepeatFocus==iFocus)

  1513 			{

  1514 			if (iRepeating>=ERepeatNormal && iCurrentRepeat.iScanCode==aScanCode)

  1515 				{

  1516 				doCancelRepeat();

  1517 				}

  1518 			iAlternateRepeatExists=EFalse;

  1519 			}

  1520 		}

  1521 	}

  1523 void CKeyboardRepeat::KeyDown()

  1524 	{

  1525 	if (iRepeating!=ERepeatNone)

  1526 		{

  1527 		if (iRepeating==ERepeatNormal && iRepeatRollover>0) // 1 Allow key repeat rollover

  1528 			{

  1529 			iAlternateRepeat=iCurrentRepeat;

  1530 			iAlternateRepeatExists=ETrue;

  1531 			}

  1532 		doCancelRepeat();

  1533 		}

  1534 	}

  1536 void CKeyboardRepeat::KeyUp(TInt aScanCode)

  1537 	{

  1538 	if (iAlternateRepeatExists && iAlternateRepeat.iScanCode==aScanCode)

  1539 		iAlternateRepeatExists=EFalse;

  1540 	if (iRepeating!=ERepeatNone && iCurrentRepeat.iScanCode==aScanCode)

  1541 		{

  1542 		if (iRepeating==ERepeatLong)

  1543 			{

  1544 			// Defensive programming - iLongCapture should never be NULL if iRepeating >= ERepeatLong

  1545 			if (iLongCapture && !(iLongCapture->iData.flags&ELongCaptureShortEventImmediately))

  1546 				{

  1547 				TWindowServerEvent::QueueKeyPress(iCurrentRepeat.iKey,iCurrentRepeat.iScanCode,NULL,EFalse,0);

  1548 				}

  1549 			}

  1550 		if (iAlternateRepeatExists)

  1551 			{

  1552 			iAlternateRepeatExists=EFalse;

  1553 			iCurrentRepeat=iAlternateRepeat;

  1554 			iRepeating=ERepeatNormal;

  1555 			}

  1556 		else

  1557 			doCancelRepeat();

  1558 		}

  1559 	}

  1561 //

  1562 // CWsHotKey //

  1563 //

  1565 CWsHotKey::CWsHotKey(TInt aHotKeyType, TBool aIsDefault) :

  1566 	iHotKeyType(aHotKeyType),

  1567 	iIsDefault(aIsDefault)

  1568 	{

  1569 	}

  1571 CWsHotKey::~CWsHotKey()

  1572 	{

  1573 	delete iCaptureKey;

  1574 	}

  1576 void CWsHotKey::ConstructLD(const TWsWinCmdCaptureKey &aCaptureKey)

  1577 	{

  1578 	CleanupStack::PushL(this);

  1579 	iCaptureKey=new(ELeave) CWsCaptureKey(NULL);

  1580 	iCaptureKey->ConstructL(aCaptureKey);

  1581 	CleanupStack::Pop();

  1582 	}

  1584 void CWsHotKey::SetL(const TWsWinCmdCaptureKey &aCaptureKey)

  1585 	{

  1586 	iCaptureKey->SetL(aCaptureKey);

  1587 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--