/*!
Sends \a message through the event filter that was set by
setEventFilter(). If no event filter has been set, this function
returns false; otherwise, this function returns the result of the
event filter function.
Subclasses of QAbstractEventDispatcher \e must call this function
for \e all messages received from the system to ensure
compatibility with any extensions that may be used in the
application.
Note that the type of \a message is platform dependent. See
QAbstractEventDispatcher::EventFilter for details.
\sa setEventFilter()
*/
bool QAbstractEventDispatcher::filterEvent(void *message)
{
Q_D(QAbstractEventDispatcher);
if (d->event_filter) {
// Raise the loopLevel so that deleteLater() calls in or triggered
// by event_filter() will be processed from the main event loop.
QScopedLoopLevelCounter loopLevelCounter(d->threadData);
return d->event_filter(message);
}
return false;
}
/*!
Sends \a message through the event filters that were set by
installNativeEventFilter(). This function returns \c true as soon as an
event filter returns \c true, and false otherwise to indicate that
the processing of the event should continue.
Subclasses of QAbstractEventDispatcher \e must call this function
for \e all messages received from the system to ensure
compatibility with any extensions that may be used in the
application. The type of event \a eventType is specific to the platform
plugin chosen at run-time, and can be used to cast message to the right type.
The \a result pointer is only used on Windows, and corresponds to the LRESULT pointer.
Note that the type of \a message is platform dependent. See
QAbstractNativeEventFilter for details.
\sa installNativeEventFilter(), QAbstractNativeEventFilter::nativeEventFilter()
\since 5.0
*/
bool QAbstractEventDispatcher::filterNativeEvent(const QByteArray &eventType, void *message, long *result)
{
Q_D(QAbstractEventDispatcher);
if (!d->eventFilters.isEmpty()) {
// Raise the loopLevel so that deleteLater() calls in or triggered
// by event_filter() will be processed from the main event loop.
QScopedLoopLevelCounter loopLevelCounter(d->threadData);
for (int i = 0; i < d->eventFilters.size(); ++i) {
QAbstractNativeEventFilter *filter = d->eventFilters.at(i);
if (!filter)
continue;
if (filter->nativeEventFilter(eventType, message, result))
return true;
}
}
return false;
}
OSStatus
QMacInputContext::globalEventProcessor(EventHandlerCallRef, EventRef event, void *)
{
#ifndef QT_MAC_USE_COCOA
QScopedLoopLevelCounter loopLevelCounter(QApplicationPrivate::instance()->threadData);
SRefCon refcon = 0;
GetEventParameter(event, kEventParamTextInputSendRefCon, typeRefCon, 0,
sizeof(refcon), 0, &refcon);
QMacInputContext *context = reinterpret_cast<QMacInputContext*>(refcon);
bool handled_event=true;
UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);
switch(eclass) {
case kEventClassTextInput: {
handled_event = false;
QWidget *widget = QApplicationPrivate::focus_widget;
bool canCompose = widget && (!context || widget->inputContext() == context)
&& !(widget->inputMethodHints() & Qt::ImhDigitsOnly
|| widget->inputMethodHints() & Qt::ImhFormattedNumbersOnly
|| widget->inputMethodHints() & Qt::ImhHiddenText);
if(!canCompose) {
handled_event = false;
} else if(ekind == kEventTextInputOffsetToPos) {
if(!widget->testAttribute(Qt::WA_InputMethodEnabled)) {
handled_event = false;
break;
}
QRect mr(widget->inputMethodQuery(Qt::ImMicroFocus).toRect());
QPoint mp(widget->mapToGlobal(QPoint(mr.topLeft())));
Point pt;
pt.h = mp.x();
pt.v = mp.y() + mr.height();
SetEventParameter(event, kEventParamTextInputReplyPoint, typeQDPoint,
sizeof(pt), &pt);
handled_event = true;
} else if(ekind == kEventTextInputUpdateActiveInputArea) {
if(!widget->testAttribute(Qt::WA_InputMethodEnabled)) {
handled_event = false;
break;
}
if (context->recursionGuard)
break;
ByteCount unilen = 0;
GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText,
0, 0, &unilen, 0);
UniChar *unicode = (UniChar*)NewPtr(unilen);
GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText,
0, unilen, 0, unicode);
QString text((QChar*)unicode, unilen / sizeof(UniChar));
DisposePtr((char*)unicode);
ByteCount fixed_length = 0;
GetEventParameter(event, kEventParamTextInputSendFixLen, typeByteCount, 0,
sizeof(fixed_length), 0, &fixed_length);
if(fixed_length == ULONG_MAX || fixed_length == unilen) {
QInputMethodEvent e;
e.setCommitString(text);
context->currentText = QString();
qt_sendSpontaneousEvent(context->focusWidget(), &e);
handled_event = true;
context->reset();
} else {
ByteCount rngSize = 0;
OSStatus err = GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray, 0,
0, &rngSize, 0);
QVarLengthArray<TextRangeArray> highlight(rngSize);
if (noErr == err) {
err = GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray, 0,
rngSize, &rngSize, highlight.data());
}
context->composing = true;
if(fixed_length > 0) {
const int qFixedLength = fixed_length / sizeof(UniChar);
QList<QInputMethodEvent::Attribute> attrs;
attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,
qFixedLength, text.length()-qFixedLength,
qt_mac_compose_format());
QInputMethodEvent e(text, attrs);
context->currentText = text;
e.setCommitString(text.left(qFixedLength), 0, qFixedLength);
qt_sendSpontaneousEvent(widget, &e);
handled_event = true;
} else {
/* Apple's enums that they have removed from Tiger :(
enum {
kCaretPosition = 1,
kRawText = 2,
kSelectedRawText = 3,
kConvertedText = 4,
kSelectedConvertedText = 5,
kBlockFillText = 6,
kOutlineText = 7,
kSelectedText = 8
};
*/
#ifndef kConvertedText
#define kConvertedText 4
#endif
#ifndef kCaretPosition
#define kCaretPosition 1
#endif
QList<QInputMethodEvent::Attribute> attrs;
if (!highlight.isEmpty()) {
TextRangeArray *data = highlight.data();
for (int i = 0; i < data->fNumOfRanges; ++i) {
int start = data->fRange[i].fStart / sizeof(UniChar);
int len = (data->fRange[i].fEnd - data->fRange[i].fStart) / sizeof(UniChar);
if (data->fRange[i].fHiliteStyle == kCaretPosition) {
attrs << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, start, 0, QVariant());
continue;
}
QTextCharFormat format;
format.setFontUnderline(true);
if (data->fRange[i].fHiliteStyle == kConvertedText)
format.setUnderlineColor(Qt::gray);
else
format.setUnderlineColor(Qt::black);
attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, start, len, format);
}
} else {
attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,
0, text.length(), qt_mac_compose_format());
}
context->currentText = text;
QInputMethodEvent e(text, attrs);
qt_sendSpontaneousEvent(widget, &e);
handled_event = true;
}
}
#if 0
if(!context->composing)
handled_event = false;
#endif
extern bool qt_mac_eat_unicode_key; //qapplication_mac.cpp
qt_mac_eat_unicode_key = handled_event;
} else if(ekind == kEventTextInputUnicodeForKeyEvent) {
EventRef key_ev = 0;
GetEventParameter(event, kEventParamTextInputSendKeyboardEvent, typeEventRef, 0,
sizeof(key_ev), 0, &key_ev);
QString text;
ByteCount unilen = 0;
if(GetEventParameter(key_ev, kEventParamKeyUnicodes, typeUnicodeText, 0, 0, &unilen, 0) == noErr) {
UniChar *unicode = (UniChar*)NewPtr(unilen);
GetEventParameter(key_ev, kEventParamKeyUnicodes, typeUnicodeText, 0, unilen, 0, unicode);
text = QString((QChar*)unicode, unilen / sizeof(UniChar));
DisposePtr((char*)unicode);
}
unsigned char chr = 0;
GetEventParameter(key_ev, kEventParamKeyMacCharCodes, typeChar, 0, sizeof(chr), 0, &chr);
if(!chr || chr >= 128 || (text.length() > 0 && (text.length() > 1 || text.at(0) != QLatin1Char(chr))))
handled_event = !widget->testAttribute(Qt::WA_InputMethodEnabled);
QMacInputContext *context = qobject_cast<QMacInputContext*>(qApp->inputContext());
if (context && context->lastKeydownEvent()) {
qt_keymapper_private()->translateKeyEvent(widget, 0, context->lastKeydownEvent(),
0, false);
context->setLastKeydownEvent(0);
}
}
break; }
default:
break;
}
if(!handled_event) //let the event go through
return eventNotHandledErr;
#else
Q_UNUSED(event);
#endif
return noErr; //we eat the event
}
int QEventDispatcherBlackberry::select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
timespec *timeout)
{
Q_UNUSED(nfds);
Q_D(QEventDispatcherBlackberry);
const BBScopedLoopLevelCounter bbLoopCounter(d);
BpsChannelScopeSwitcher channelSwitcher(d->bps_channel);
// prepare file sets for bps callback
d->ioData->count = 0;
d->ioData->readfds = readfds;
d->ioData->writefds = writefds;
d->ioData->exceptfds = exceptfds;
// reset all file sets
if (readfds)
FD_ZERO(readfds);
if (writefds)
FD_ZERO(writefds);
if (exceptfds)
FD_ZERO(exceptfds);
bps_event_t *event = 0;
unsigned int eventCount = 0;
// If an event handler called through filterEvent() starts a nested event loop by creating a
// new QEventLoop, we will recursively enter this function again. However, each time
// bps_get_event() is called, it destroys the last event it handed out before returning the
// next event. We don't want it to destroy the event that triggered the nested event loop,
// since there may still be more handlers that need to get that event, once the nested event
// loop is done and control returns to the outer event loop.
//
// So we move an event to a holding channel, which takes ownership of the event. Putting
// the event on our own channel allows us to manage when it is destroyed, keeping it alive
// until we know we are done with it. Each recursive call of this function needs to have
// it's own holding channel, since a channel is a queue, not a stack.
//
// However, a recursive call into this function happens very rarely compared to the many
// times this function is called. We don't want to create a holding channel for each time
// this function is called, only when it is called recursively. Thus we have the instance
// variable d->holding_channel to use in the common case. We keep track of recursive calls
// with d->loop_level. If we are in a recursive call, then we create a new holding channel
// for this run.
int holding_channel = d->holding_channel;
if ((d->loop_level > 1) &&
Q_UNLIKELY(bps_channel_create(&holding_channel, 0) != BPS_SUCCESS)) {
qWarning("QEventDispatcherBlackberry: bps_channel_create failed");
holding_channel = -1;
}
// Convert timeout to milliseconds
int timeoutTotal = -1;
if (timeout)
timeoutTotal = timespecToMillisecs(*timeout);
int timeoutLeft = timeoutTotal;
timespec startTime = qt_gettime();
// This loop exists such that we can drain the bps event queue of all native events
// more efficiently than if we were to return control to Qt after each event. This
// is important for handling touch events which can come in rapidly.
forever {
// Only emit the awake() and aboutToBlock() signals in the second iteration. For the
// first iteration, the UNIX event dispatcher will have taken care of that already.
// Also native events are actually processed one loop iteration after they were
// retrieved with bps_get_event().
// Filtering the native event should happen between the awake() and aboutToBlock()
// signal emissions. The calls awake() - filterNativeEvent() - aboutToBlock() -
// bps_get_event() need not to be interrupted by a break or return statement.
if (eventCount > 0) {
if (event) {
emit awake();
filterNativeEvent(QByteArrayLiteral("bps_event_t"), static_cast<void*>(event), 0);
emit aboutToBlock();
if (Q_LIKELY(holding_channel != -1)) {
// We are now done with this BPS event. Destroy it.
destroyHeldBpsEvent(holding_channel);
}
}
// Update the timeout
// Clock source is monotonic, so we can recalculate how much timeout is left
if (timeoutTotal != -1) {
timespec t2 = qt_gettime();
timeoutLeft = timeoutTotal
- (timespecToMillisecs(t2) - timespecToMillisecs(startTime));
if (timeoutLeft < 0)
timeoutLeft = 0;
}
timespec tnext;
if (d->timerList.timerWait(tnext)) {
int timeoutNext = timespecToMillisecs(tnext);
if (timeoutNext < timeoutLeft || timeoutTotal == -1) {
timeoutTotal = timeoutLeft = timeoutNext;
startTime = qt_gettime();
}
}
}
event = 0;
{ // We need to increase loop level in this scope,
// because bps_get_event can also invoke callbacks
QScopedLoopLevelCounter loopLevelCounter(d->threadData);
// Wait for event or file to be ready
const int result = bps_get_event(&event, timeoutLeft);
if (Q_UNLIKELY(result != BPS_SUCCESS))
qWarning("QEventDispatcherBlackberry: bps_get_event failed");
}
if (!event) // In case of !event, we break out of the loop to let Qt process the timers
break; // (since timeout has expired) and socket notifiers that are now ready.
if (bps_event_get_domain(event) == bpsUnblockDomain) {
timeoutTotal = 0; // in order to immediately drain the event queue of native events
event = 0; // (especially touch move events) we don't break out here
} else {
// Move the event to our holding channel so we can manage when it is destroyed.
if (Q_LIKELY(holding_channel != 1) &&
Q_UNLIKELY(bps_channel_push_event(holding_channel, event) != BPS_SUCCESS)) {
qWarning("QEventDispatcherBlackberry: bps_channel_push_event failed");
}
}
++eventCount;
// Make sure we are not trapped in this loop due to continuous native events
// also we cannot recalculate the timeout without a monotonic clock as the time may have changed
const unsigned int maximumEventCount = 12;
if (Q_UNLIKELY((eventCount > maximumEventCount && timeoutLeft == 0)
|| !QElapsedTimer::isMonotonic())) {
if (event) {
filterNativeEvent(QByteArrayLiteral("bps_event_t"), static_cast<void*>(event), 0);
if (Q_LIKELY(holding_channel != -1)) {
// We are now done with this BPS event. Destroy it.
destroyHeldBpsEvent(holding_channel);
}
}
break;
}
}
// If this was a recursive call into this function, a new holding channel was created for
// this run, so destroy it now.
if ((holding_channel != d->holding_channel) &&
Q_LIKELY(holding_channel != -1) &&
Q_UNLIKELY(bps_channel_destroy(holding_channel) != BPS_SUCCESS)) {
qWarning("QEventDispatcherBlackberry: bps_channel_destroy failed");
}
// the number of bits set in the file sets
return d->ioData->count;
}
