/**
Inform with a message ,the timer seconds remaining till its up.\n
Send event to windows group when timer time is up .\n
*/
void CTestTimer::RunL()
{
--iSecondsRemaining;
if (iSecondsRemaining>0)
{
QueueAndInfoPrint();
}
else
{
User::InfoPrint(_L("Time's up"));
iCompleted = ETrue;
CCoeEnv* env = CCoeEnv::Static();
TWsEvent theEvent;
theEvent.SetType(EEventUser + 1);
RWsSession ws;
TInt theRes = ws.Connect();
if(theRes == KErrNone)
{
RWindowGroup& winGroup = env->RootWin();
theEvent.SetType(EEventUser + 1);
theEvent.SetTimeNow();
TInt theId = winGroup.Identifier();
ws.SendEventToWindowGroup(theId, theEvent);
}
ws.Close();
}
}
/**
Utility to close the dialogs once the screen has been compared
with a previous capture of an expected display.
*/
void CConeErrorMsgTestAppUi::CloseDialogsL()
{
User::LeaveIfError(iWs.Connect());
TInt wgFocus = iWs.GetFocusWindowGroup();
const TUint32 ENullWsHandle = 0xFFFFFFFF; // Events delivered to this handle are thrown away
RWindowGroup wg = RWindowGroup(iWs);
wg.Construct(ENullWsHandle);
TInt wgId = wg.Identifier();
TWsEvent event;
event.SetType(EEventKey);
TKeyEvent *keyEvent = event.Key();
keyEvent->iCode = EKeyEscape;
keyEvent->iScanCode = EStdKeyEscape;
keyEvent->iModifiers = 0;
TInt limit = 0;
for(limit = 0; wgFocus != wgId && (limit < 50); limit++)
{
iWs.SendEventToAllWindowGroups(event);
wgFocus = iWs.GetFocusWindowGroup();
RDebug::Print(_L("CloseAllPanicWindowsL() - EKeyEscape sent to Windows Group"));
}
wg.Close();
iWs.Close();
}
void showDebugMessage( const char* source, const char* message )
{
if ( source && message )
{
memset(g_szSource, 0, sizeof(g_szSource) );
memset(g_szMessage, 0, sizeof(g_szMessage) );
memcpy( g_szSource, source, strlen(source) > 20 ? 20 : strlen(source) );
memcpy( g_szMessage, message, strlen(message) > 100 ? 100 : strlen(message));
// Create a window server event
RWsSession wsSession;
TWsEvent event;
if ( wsSession.Connect() == KErrNone )
{
// Set event data. eventType.data = KData;
event.SetType(EEventUser + ECmdShowDebugWindow); // set event type
event.SetTimeNow(); // set the event time
event.SetHandle(wsSession.WsHandle()); // set window server handle
// Send the created event
wsSession.SendEventToAllWindowGroups(event);
}
}
}
void CAknKeyLockControl::SendMessageToSysAp(TInt aMessage)
{
RWsSession& ws = iEikonEnv->WsSession();
TInt wgId=0;
CApaWindowGroupName::FindByAppUid(KSysApUid, ws, wgId);
if (wgId)
{
TWsEvent event;
event.SetType(aMessage);
event.SetTimeNow();
ws.SendEventToWindowGroup(wgId, event);
}
}
EXPORT_C TInt CSDL::RedrawRequest()
{
if(gEpocEnv && gEpocEnv->iDsa)
{
//const TInt err = gEpocEnv->iDsa->RedrawRequest();
TWsEvent event;
event.SetType(EEventScreenDeviceChanged),
event.SetTimeNow();
AppendWsEvent(event);/*
EpocSdlEnv::PostUpdate();
return err; */
}
return KErrNotReady;
}
/**
Handle the window events.\n
Create a window server session and connect the client\n
Set the event type and call the SendEventToWindowGroup().\n
Close the session on completion \n
*/
void CDefocusingEdwinUi::SendEventToWindowGroups(TWsEvent& aEvent)
{
RWsSession ws;
TInt theRes = ws.Connect();
TEST(theRes == KErrNone);
RWindowGroup& winGroup = iCoeEnv->RootWin();
TInt theId = winGroup.Identifier();
aEvent.SetType(EEventKeyDown);
aEvent.SetTimeNow();
ws.SendEventToWindowGroup(theId, aEvent);
aEvent.SetType(EEventKey);
aEvent.SetTimeNow();
ws.SendEventToWindowGroup(theId, aEvent);
aEvent.SetType(EEventKeyUp);
aEvent.SetTimeNow();
ws.SendEventToWindowGroup(theId, aEvent);
ws.Close();
}
/** Fetches a message
*/
TInt COomMessageFetch::Fail()
{
TWsEvent event;
TPtr8 ptr(NULL,0);
TUid uid;
event.SetType(EEventMessageReady);
event.SetHandle(CLIENT_HANDLE);
event.SetTimeNow();
SEventMessageReady& eventMessageReady=*(SEventMessageReady*)event.EventData();
eventMessageReady.iWindowGroupIdentifier=iWinGroup2.Identifier();
eventMessageReady.iMessageUid=TUid::Uid(UID_VALUE);
eventMessageReady.iMessageParametersSize=MESSAGE_LEN;
TInt ret=TheClient->iWs.FetchMessage(uid,ptr,event);
if (ret==KErrNone)
User::Free((TAny *)ptr.Ptr());
return(ret);
}
void CSyncEngineWrap::SendWindowEvent(TInt aEvent)
{
// Create a window server event
RWsSession wsSession;
TWsEvent event;
if (wsSession.Connect() == KErrNone)
{
// Set event data. eventType.data = KData;
event.SetType(EEventUser + aEvent); // set event type
event.SetTimeNow(); // set the event time
event.SetHandle(wsSession.WsHandle()); // set window server handle
// Send the created event
wsSession.SendEventToAllWindowGroups(event);
}
}
void CAppOomMonitorPlugin::SendMessageToApp(TInt aMessage)
{
RWsSession& ws = WsSession();
TInt wgId = 0;
do
{
CApaWindowGroupName::FindByAppUid(iAppUid, ws, wgId);
if (wgId>0)
{
TWsEvent event;
event.SetType(aMessage);
event.SetTimeNow();
ws.SendEventToWindowGroup(wgId, event);
}
}
while (wgId>0);
}
void SendWindowEvent(TInt aEvent, const char* data)
{
// Create a window server event
RWsSession wsSession;
TWsEvent event;
if ( wsSession.Connect() == KErrNone )
{
// Set event data. eventType.data = KData;
event.SetType(EEventUser + aEvent); // set event type
event.SetTimeNow(); // set the event time
event.SetHandle(wsSession.WsHandle()); // set window server handle
if ( data )
((char**)event.EventData())[0] = strdup(data);
// Send the created event
wsSession.SendEventToAllWindowGroups(event);
}
}
TInt CSdlAppServ::ObserverEvent(TInt aEvent, TInt aParam)
{
if(iObserver != NULL)
{
if(RThread().Id() == iMainId)
{
return iObserver->SdlEvent(aEvent, aParam);
}
else if(RThread().Id() == gEpocEnv->iId && EnvUtils::IsOwnThreaded())
{
return iObserver->SdlThreadEvent(aEvent, aParam);
}
else
{
TWsEvent event;
event.SetType(ESDLWsEvent);
TInt load[] = {aEvent, aParam};
Mem::Copy(event.EventData(), load, sizeof(TInt) * 2);
event.SetTimeNow();
EpocSdlEnv::EventQueue().Append(event);
}
}
return 0;
}
void CMemoryMonitor::SwitchMemMode(TGOomMemMode aMemMode, TBool aForced)
{
if(iMemMode == aMemMode)
{
if(iMemMode == EGOomGoodMemMode)
{
TRACES("CMemoryMonitor::SwitchMemMode NOT switching rendering mode. Already in GOOD Mode");
}
else
{
TRACES("CMemoryMonitor::SwitchMemMode NOT switching rendering mode. Already in LOW Mode");
}
return;
}
#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
TWsEvent event;
if(aMemMode == EGOomLowMemMode)
{
if(!aForced)
{
if(iRendswitched < 3)
iRendswitched ++;
else
return;
}
iLowOnMemWgs.Reset();
iGOomWindowGroupList->GetListOfWindowGroupsWSurfaces(iLowOnMemWgs);
event.SetType(KGoomMemoryLowEvent);
TRACES("CMemoryMonitor::SwitchMemMode. Switching rendering mode to SW, Sending KGoomMemoryLowEvent");
}
else
{
if(!aForced)
{
if(iRendswitched > 0)
{
if(iRendswitched < 3)
iRendswitched ++;
else
{
TRACES("CMemoryMonitor::SwitchMemMode GOOM Detected SW-HW-SW looping. NOT switching to HW rendering mode");
return;
}
}
}
event.SetType(KGoomMemoryGoodEvent);
TRACES("CMemoryMonitor::SwitchMemMode. Switching rendering mode to HW, Sending KGoomMemoryGoodEvent");
}
for (TInt i = iLowOnMemWgs.Count()-1; i>=0; i--)
{
iWs.SendEventToWindowGroup(iLowOnMemWgs[i], event);
TRACES1("CMemoryMonitor::SwitchMemMode. Sending event to wg %d",iLowOnMemWgs[i]);
}
#endif
iMemMode = aMemMode;
}
/**
Test delivery group messages in case when event queue is overflow
*/
void CTMessage::TestMessageQueueOverflowL()
{
const TInt numMaxMessages = 60;
TInt numWasteMessages = 0;
TInt numWgMessages = 5;
TInt gotRealWasteMessages = 0;
TInt gotRealWgMessages = 0;
const TInt oneSecond = 1000000;
const TInt allPossibleMessages = 500;
RWsSession senderWsSession;
RWindowGroup senderGroupWin;
TInt sndrHanGrpWin = 7777;
RWsSession receiverWsSession;
RWindowGroup receiverGroupWin;
TInt rcvrHanGrpWin = 8888;
TRequestStatus testStatus;
TRequestStatus timerStatus;
TWsEvent wasteEvent;
TWsEvent event;
RTimer timer;
timer.CreateLocal();
CleanupClosePushL(timer);
// Create sender WsSession and the window group
User::LeaveIfError(senderWsSession.Connect());
CleanupClosePushL(senderWsSession);
senderGroupWin = RWindowGroup(senderWsSession);
User::LeaveIfError(senderGroupWin.Construct(sndrHanGrpWin));
CleanupClosePushL(senderGroupWin);
// Create reciever WsSession and the window group
User::LeaveIfError(receiverWsSession.Connect());
CleanupClosePushL(receiverWsSession);
receiverGroupWin = RWindowGroup(receiverWsSession);
User::LeaveIfError(receiverGroupWin.Construct(rcvrHanGrpWin));
CleanupClosePushL(receiverGroupWin);
TInt err = KErrNone;
// Send waste events to the receiver and overflow the event queue
for (TInt ind = 0; ind < numMaxMessages; ind++)
{
wasteEvent.SetType(sndrHanGrpWin);
err = senderWsSession.SendEventToWindowGroup(receiverGroupWin.Identifier(), wasteEvent);
if (err != KErrNone)
{
numWasteMessages = ind; // Real number waste messages that was sent
break;
}
}
// Send messages to the receiver
for (TInt ind = 0; ind < numWgMessages; ind++)
{
TInt uidData = ind + sndrHanGrpWin;
TPtr8 msg((unsigned char*) &uidData, sizeof(uidData));
err = senderWsSession.SendMessageToWindowGroup(receiverGroupWin.Identifier(), TUid::Uid(uidData), msg);
if (err != KErrNone)
{
LOG_MESSAGE2(_L("UnExpected Error Code = %d"),err);
numWgMessages = ind; // Real number window group messages that was sent
}
}
// Check and count sent messages
for (TInt ind = 0; ind < allPossibleMessages; ind++)
{
receiverWsSession.EventReady(&testStatus);
timer.After(timerStatus, oneSecond);
User::WaitForRequest(testStatus, timerStatus);
if (testStatus == 0)
{
// Test incoming events
receiverWsSession.GetEvent(event);
if (event.Type() == sndrHanGrpWin)
{
++gotRealWasteMessages;
}
else if (event.Type() == EEventMessageReady)
{
if (gotRealWgMessages == 0)
{
for (TInt ind = 0; ind < numMaxMessages; ind++)
{
wasteEvent.SetType(sndrHanGrpWin);
err = senderWsSession.SendEventToWindowGroup(receiverGroupWin.Identifier(), wasteEvent);
if (err == KErrNone)
{
++numWasteMessages;
}
else
{
break;
}
}
}
++gotRealWgMessages;
TUid uid;
TPtr8 msgPtr(NULL,0);
err = receiverWsSession.FetchMessage(uid, msgPtr, event);
User::Free((TAny *) msgPtr.Ptr());
}
// testStatus has been completed. Hence, Cancel the timer.
timer.Cancel();
User::WaitForRequest(timerStatus);
}
else
{
// Times out, cancel the event notification
receiverWsSession.EventReadyCancel();
User::WaitForRequest(testStatus);
// All events were recieved
break;
}
}
LOG_MESSAGE3(_L("Got Waste message = %d expected =%d"),gotRealWasteMessages,numWasteMessages);
LOG_MESSAGE3(_L("Got Group message = %d expected =%d"),gotRealWgMessages,numWgMessages);
TEST(gotRealWasteMessages == numWasteMessages);
TEST(gotRealWgMessages == numWgMessages);
CleanupStack::PopAndDestroy(&receiverGroupWin);
CleanupStack::PopAndDestroy(&receiverWsSession);
CleanupStack::PopAndDestroy(&senderGroupWin);
CleanupStack::PopAndDestroy(&senderWsSession);
CleanupStack::PopAndDestroy(&timer);
TheClient->iWs.Flush();
}
void CWsGceCscBase::SetupL()
{
iDoTearDown=ETrue;
iRed.SetInternal(0xFFFF0000);
iGreen.SetInternal(0xFF00FF00);
iBlue.SetInternal(0xFF0000FF);
iCyan.SetInternal(0xFF00FFFF);
iMagenta.SetInternal(0xFFFF00FF);
iYellow.SetInternal(0xFFFFFF00);
iWhite.SetInternal(0xFFFFFFFF);
ASSERT_EQUALS_X(iSession.Connect(), KErrNone);
{//Stolen from TAuto CloseAllPanicWindows()
TInt idFocus = iSession.GetFocusWindowGroup();
TWsEvent event;
event.SetType(EEventKey); //EEventKeyDown
TKeyEvent *keyEvent = event.Key();
keyEvent->iCode = EKeyEscape;
keyEvent->iScanCode = EStdKeyEscape;
keyEvent->iModifiers = 0;
TInt theLimit = 50;
while(idFocus != NULL && (theLimit-- > 0))
{
iSession.SendEventToAllWindowGroups(event);
TInt idNewFocus = iSession.GetFocusWindowGroup();
if (idNewFocus!=idFocus)
{
INFO_PRINTF1(_L("A window was closed [probably a panic box from the previous test]."));
}
idFocus=idNewFocus;
}
}
TInt err = KErrNone;
TRAP(err, iScreenDevice = new (ELeave) CWsScreenDevice(iSession));
PRINT_ON_ERROR2_L(err, _L("Failed to create screen device: %d"), err);
ASSERT_EQUALS_X(iScreenDevice->Construct(TGlobalSettings::Instance().iScreen), KErrNone);
iDisplayMode = iScreenDevice->DisplayMode(); // Get default display mode
TRAP(err, iGc = new (ELeave) CWindowGc(iScreenDevice));
PRINT_ON_ERROR2_L(err, _L("Failed to create graphics context: %d"), err);
ASSERT_EQUALS_X(iGc->Construct(), KErrNone);
iGroup = RWindowGroup(iSession);
ASSERT_EQUALS_X(iGroup.Construct(++iWindowHandle,iScreenDevice), KErrNone);
iSession.Flush();
RWindow testTrans(iSession);
ASSERT_EQUALS_X(testTrans.Construct(iGroup, ++iWindowHandle), KErrNone);
iTransparencyEnabled=(testTrans.SetTransparencyFactor(iWhite)==KErrNone);
testTrans.Close();
//clean-up if previous test abended
if (PostTestCleanupInstance().iSharedUtility)
{
//Temp removed - may be causing ONB fails!
// if (PostTestCleanupInstance().iSharedUtility->DestroyAll())
// {
// INFO_PRINTF1(_L("Destroyed some surfaces from previous test."));
//
// }
}
if (!PostTestCleanupInstance().iCleanedUpOnExit)
PostTestCleanupInstance().iCleanedUpOnExit=EFalse;
if (!GCEIsSupported())
{
INFO_PRINTF1(_L("Some Setup skipped: GCE support is not loaded"));
return;
}
TRAPD(err_FailedToCreateSurfaceUtility, iUtility = CSurfaceUtility::NewL( PostTestCleanupInstance().iSharedUtility));
ASSERT_EQUALS(err_FailedToCreateSurfaceUtility,KErrNone);
}
