bool QEventDispatcherS60::processEvents ( QEventLoop::ProcessEventsFlags flags )
{
bool ret = false;
QT_TRY {
bool oldNoInputEventsValue = m_noInputEvents;
if (flags & QEventLoop::ExcludeUserInputEvents) {
m_noInputEvents = true;
} else {
m_noInputEvents = false;
ret = sendDeferredInputEvents() || ret;
}
ret = QEventDispatcherSymbian::processEvents(flags) || ret;
m_noInputEvents = oldNoInputEventsValue;
} QT_CATCH (const std::exception& ex) {
#ifndef QT_NO_EXCEPTIONS
CActiveScheduler::Current()->Error(qt_symbian_exception2Error(ex));
#endif
}
bool QEventDispatcherSymbian::processEvents ( QEventLoop::ProcessEventsFlags flags )
{
bool handledAnyEvent = false;
bool oldNoSocketEventsValue = m_noSocketEvents;
bool oldInsideTimerEventValue = m_insideTimerEvent;
m_insideTimerEvent = false;
QT_TRY {
Q_D(QAbstractEventDispatcher);
// It is safe if this counter overflows. The main importance is that each
// iteration count is different from the last.
m_iterationCount++;
RThread &thread = d->threadData->symbian_thread_handle;
bool block;
if (flags & QEventLoop::WaitForMoreEvents) {
block = true;
emit aboutToBlock();
} else {
block = false;
}
if (flags & QEventLoop::ExcludeSocketNotifiers) {
m_noSocketEvents = true;
} else {
m_noSocketEvents = false;
handledAnyEvent = sendDeferredSocketEvents();
}
bool handledSymbianEvent = false;
m_interrupt = false;
#ifdef QT_SYMBIAN_PRIORITY_DROP
QElapsedTimer eventTimer;
#endif
while (1) {
if (block) {
// This is where Qt will spend most of its time.
CActiveScheduler::Current()->WaitForAnyRequest();
} else {
if (thread.RequestCount() == 0) {
#ifdef QT_SYMBIAN_PRIORITY_DROP
if (idleDetectorThread()->hasRun()) {
m_lastIdleRequestTimer.start();
idleDetectorThread()->kick();
} else if (m_lastIdleRequestTimer.elapsed() > maxBusyTime) {
User::AfterHighRes(m_delay);
}
#endif
break;
}
// This one should return without delay.
CActiveScheduler::Current()->WaitForAnyRequest();
}
#ifdef QT_SYMBIAN_PRIORITY_DROP
if (idleDetectorThread()->hasRun()) {
if (m_delay > baseDelay)
m_delay -= baseDelay;
m_lastIdleRequestTimer.start();
idleDetectorThread()->kick();
} else if (m_lastIdleRequestTimer.elapsed() > maxBusyTime) {
User::AfterHighRes(m_delay);
// allow delay to be up to 1/4 of execution time
if (!idleDetectorThread()->hasRun() && m_delay*3 < m_avgEventTime)
m_delay += baseDelay;
}
eventTimer.start();
#endif
TInt error;
handledSymbianEvent = CActiveScheduler::RunIfReady(error, KMinTInt);
if (error) {
qWarning("CActiveScheduler::RunIfReady() returned error: %i\n", error);
CActiveScheduler::Current()->Error(error);
}
#ifdef QT_SYMBIAN_PRIORITY_DROP
int eventDur = eventTimer.elapsed()*1000;
// average is calcualted as a 5% decaying exponential average
m_avgEventTime = (m_avgEventTime * 95 + eventDur * 5) / 100;
#endif
if (!handledSymbianEvent) {
qFatal("QEventDispatcherSymbian::processEvents(): Caught Symbian stray signal");
}
handledAnyEvent = true;
if (m_interrupt) {
break;
}
block = false;
};
emit awake();
} QT_CATCH (const std::exception& ex) {
#ifndef QT_NO_EXCEPTIONS
CActiveScheduler::Current()->Error(qt_symbian_exception2Error(ex));
#endif
}
bool QEventDispatcherSymbian::processEvents ( QEventLoop::ProcessEventsFlags flags )
{
bool handledAnyEvent = false;
bool oldNoSocketEventsValue = m_noSocketEvents;
QT_TRY {
Q_D(QAbstractEventDispatcher);
// It is safe if this counter overflows. The main importance is that each
// iteration count is different from the last.
m_iterationCount++;
RThread &thread = d->threadData->symbian_thread_handle;
bool block;
if (flags & QEventLoop::WaitForMoreEvents) {
block = true;
emit aboutToBlock();
} else {
block = false;
}
if (flags & QEventLoop::ExcludeSocketNotifiers) {
m_noSocketEvents = true;
} else {
m_noSocketEvents = false;
handledAnyEvent = sendDeferredSocketEvents();
}
bool handledSymbianEvent = false;
m_interrupt = false;
/*
* This QTime variable is used to measure the time it takes to finish
* the event loop. If we take too long in the loop, other processes
* may be starved and killed. After the first event has completed, we
* take the current time, and if the remaining events take longer than
* a preset time, we temporarily lower the priority to force a context
* switch. For applications that do not take unecessarily long in the
* event loop, the priority will not be altered.
*/
QTime time;
enum {
FirstRun,
SubsequentRun,
TimeStarted
} timeState = FirstRun;
TProcessPriority priority;
while (1) {
if (block) {
// This is where Qt will spend most of its time.
CActiveScheduler::Current()->WaitForAnyRequest();
} else {
if (thread.RequestCount() == 0) {
break;
}
// This one should return without delay.
CActiveScheduler::Current()->WaitForAnyRequest();
}
if (timeState == SubsequentRun) {
time.start();
timeState = TimeStarted;
}
TInt error;
handledSymbianEvent = CActiveScheduler::RunIfReady(error, CActive::EPriorityIdle);
if (error) {
qWarning("CActiveScheduler::RunIfReady() returned error: %i\n", error);
CActiveScheduler::Current()->Error(error);
}
if (!handledSymbianEvent) {
qFatal("QEventDispatcherSymbian::processEvents(): Caught Symbian stray signal");
}
handledAnyEvent = true;
if (m_interrupt) {
break;
}
block = false;
if (timeState == TimeStarted && time.elapsed() > 100) {
priority = m_processHandle.Priority();
m_processHandle.SetPriority(EPriorityBackground);
time.start();
// Slight chance of race condition in the next lines, but nothing fatal
// will happen, just wrong priority.
if (m_processHandle.Priority() == EPriorityBackground) {
m_processHandle.SetPriority(priority);
}
}
if (timeState == FirstRun)
timeState = SubsequentRun;
};
emit awake();
} QT_CATCH (const std::exception& ex) {
#ifndef QT_NO_EXCEPTIONS
CActiveScheduler::Current()->Error(qt_symbian_exception2Error(ex));
#endif
}
