bool QWSInputContext::translateIMEvent(QWidget *w, const QWSIMEvent *e)
{
QDataStream stream(e->streamingData);
QString preedit;
QString commit;
stream >> preedit;
stream >> commit;
if (preedit.isEmpty() && QT_PREPEND_NAMESPACE(activeWidget))
w = QT_PREPEND_NAMESPACE(activeWidget);
QInputContext *qic = w->inputContext();
if (!qic)
return false;
QList<QInputMethodEvent::Attribute> attrs;
while (!stream.atEnd()) {
int type = -1;
int start = -1;
int length = -1;
QVariant data;
stream >> type >> start >> length >> data;
if (stream.status() != QDataStream::Ok) {
qWarning("corrupted QWSIMEvent");
//qic->reset(); //???
return false;
}
if (type == QInputMethodEvent::TextFormat)
data = qic->standardFormat(static_cast<QInputContext::StandardFormat>(data.toInt()));
attrs << QInputMethodEvent::Attribute(static_cast<QInputMethodEvent::AttributeType>(type), start, length, data);
}
#ifdef EXTRA_DEBUG
qDebug() << "preedit" << preedit << "len" << preedit.length() <<"commit" << commit << "len" << commit.length()
<< "n attr" << attrs.count();
#endif
if (preedit.isEmpty())
QT_PREPEND_NAMESPACE(activeWidget) = 0;
else
QT_PREPEND_NAMESPACE(activeWidget) = w;
QInputMethodEvent ime(preedit, attrs);
if (!commit.isEmpty() || e->simpleData.replaceLength > 0)
ime.setCommitString(commit, e->simpleData.replaceFrom, e->simpleData.replaceLength);
extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); //qapplication_qws.cpp
qt_sendSpontaneousEvent(w, &ime);
return true;
}
void QKeyMapper::changeKeyboard()
{
instance()->d_func()->clearMappings();
// inform all toplevel widgets of the change
QEvent e(QEvent::KeyboardLayoutChange);
QWidgetList list = QApplication::topLevelWidgets();
for (int i = 0; i < list.size(); ++i) {
QWidget *w = list.at(i);
qt_sendSpontaneousEvent(w, &e);
}
}
void qt_mac_send_modifiers_changed(quint32 modifiers, QObject *object)
{
static quint32 cachedModifiers = 0;
quint32 lastModifiers = cachedModifiers,
changedModifiers = lastModifiers ^ modifiers;
cachedModifiers = modifiers;
//check the bits
static qt_mac_enum_mapper modifier_key_symbols[] = {
{ shiftKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Shift) },
{ rightShiftKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Shift) }, //???
{ controlKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Meta) },
{ rightControlKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Meta) }, //???
{ cmdKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Control) },
{ optionKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Alt) },
{ rightOptionKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Alt) }, //???
{ alphaLockBit, QT_MAC_MAP_ENUM(Qt::Key_CapsLock) },
{ kEventKeyModifierNumLockBit, QT_MAC_MAP_ENUM(Qt::Key_NumLock) },
{ 0, QT_MAC_MAP_ENUM(0) } };
for (int i = 0; i <= 32; i++) { //just check each bit
if (!(changedModifiers & (1 << i)))
continue;
QEvent::Type etype = QEvent::KeyPress;
if (lastModifiers & (1 << i))
etype = QEvent::KeyRelease;
int key = 0;
for (uint x = 0; modifier_key_symbols[x].mac_code; x++) {
if (modifier_key_symbols[x].mac_code == i) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
qDebug("got modifier changed: %s", modifier_key_symbols[x].desc);
#endif
key = modifier_key_symbols[x].qt_code;
break;
}
}
if (!key) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
qDebug("could not get modifier changed: %d", i);
#endif
continue;
}
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
qDebug("KeyEvent (modif): Sending %s to %s::%s: %d - 0x%08x",
etype == QEvent::KeyRelease ? "KeyRelease" : "KeyPress",
object ? object->metaObject()->className() : "none",
object ? object->objectName().toLatin1().constData() : "",
key, (int)modifiers);
#endif
QKeyEvent ke(etype, key, qt_mac_get_modifiers(modifiers ^ (1 << i)), QLatin1String(""));
qt_sendSpontaneousEvent(object, &ke);
}
}
void QMacInputContext::reset()
{
if (recursionGuard)
return;
if (!currentText.isEmpty()){
QInputMethodEvent e;
e.setCommitString(currentText);
qt_sendSpontaneousEvent(focusWidget(), &e);
currentText = QString();
}
recursionGuard = true;
createTextDocument();
composing = false;
ActivateTSMDocument(textDocument);
FixTSMDocument(textDocument);
recursionGuard = false;
}
void LLEmbeddedBrowserWindow::mouseEvent(LLQtWebKit::EMouseEvent mouse_event, int16_t button, int16_t x, int16_t y, LLQtWebKit::EKeyboardModifier modifiers)
{
#if LLEMBEDDEDBROWSER_DEBUG > 10
qDebug() << "LLEmbeddedBrowserWindow" << __FUNCTION__ << x << y;
#endif
QEvent::Type type = event_from_mouse_event(mouse_event);
Qt::MouseButton qt_button = qt_button_from_button_number(button);
Qt::KeyboardModifiers qt_modifiers = convert_modifiers(modifiers);
if(type == QEvent::MouseMove)
{
// Mouse move events should always use "no button".
qt_button = Qt::NoButton;
}
// FIXME: should the current button state be updated before or after constructing the event?
switch(type)
{
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
d->mCurrentMouseButtonState |= qt_button;
break;
case QEvent::MouseButtonRelease:
d->mCurrentMouseButtonState &= ~qt_button;
break;
default:
break;
}
QMouseEvent event(type, QPoint(x, y), qt_button, d->mCurrentMouseButtonState, qt_modifiers);
qt_sendSpontaneousEvent(d->mGraphicsView->viewport(), &event);
}
void RunnerView::handleMouse(MouseMessage* mm)
{
QMouseEvent* me(mm->createMouseEvent());
qt_sendSpontaneousEvent(this, me);
delete me;
}
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
}
// generateTouchEvent - iterates through existing touches and creates a QTouchEvent.
// For the primary finger, it also creates a mouse event if the location has move
void QPAHiddTpHandler::generateTouchEvent()
{
if (m_touches.empty())
return;
QList<QTouchEvent::TouchPoint> touchPoints;
QList<HiddTouch>::const_iterator it;
QWidget* widget = QWidget::mouseGrabber();
if (!widget) {
QWidget* window = QApplication::topLevelAt(m_lastTouchDown);
if (window)
widget = window->childAt(window->mapFromGlobal(m_lastTouchDown));
}
if (!widget) {
QPoint dummyPt(10, 10);
QWidget* window = QApplication::topLevelAt(dummyPt);
if (window)
widget = window->childAt(window->mapFromGlobal(dummyPt));
}
if(!widget) {
widget = QApplication::activeWindow();
if(QApplication::focusWidget())
{
widget = QApplication::focusWidget();
}
}
Qt::KeyboardModifiers keyboardModifiers = QApplication::keyboardModifiers();
if (widget && m_sendPenCancel) {
//printf("Mouse Up for Pen Cancel: %d, %d\n", m_penCancelPoint.x(), m_penCancelPoint.y());
QMouseEvent ev(QEvent::MouseButtonRelease, m_penCancelPoint, m_penCancelPoint, true,
Qt::LeftButton, Qt::NoButton, keyboardModifiers);
qt_sendSpontaneousEvent((QObject*) widget, &ev);
m_sendPenCancel = false;
m_penCancelPoint = QPoint (0,0);
}
for (it = m_touches.begin(); it != m_touches.end(); ++it) {
QTouchEvent::TouchPoint touchPoint;
touchPoint.setId(it->id);
touchPoint.setPos(QPoint(it->x, it->y));
touchPoint.setScreenPos(touchPoint.pos());
switch (it->state) {
case QPAHiddTpHandler::FingerDown:
touchPoint.setState(Qt::TouchPointPressed);
break;
case QPAHiddTpHandler::FingerUp:
touchPoint.setState(Qt::TouchPointReleased);
break;
case QPAHiddTpHandler::FingerMove:
touchPoint.setState(Qt::TouchPointMoved);
break;
default:
touchPoint.setState(Qt::TouchPointStationary);
break;
}
if (it->isPrimary) {
touchPoint.setState(touchPoint.state() | Qt::TouchPointPrimary);
}
touchPoints.append(touchPoint);
// printf ("%s: adding touch point id %d (hiddId %llu) for pos (%d, %d) primary %d\n",
// __func__, it->id, it->hiddId, it->x, it->y, it->isPrimary);
if (it->isPrimary) {
QPoint mousePos = QPoint(it->x, it->y);
if (widget) {
if (it->state == QPAHiddTpHandler::FingerDown) {
uint32_t currTime = m_touchTimer.elapsed();
int dx = mousePos.x() - m_mousePress.x();
int dy = mousePos.y() - m_mousePress.y();
if (((currTime - m_mousePressTime) < (uint32_t) QApplication::doubleClickInterval()) &&
((dx * dx + dy * dy) <= 144)) {
//printf("Mouse Double Click: %d, %d\n", mousePos.x(), mousePos.y());
QMouseEvent ev(QEvent::MouseButtonDblClick, mousePos, mousePos,
Qt::LeftButton, Qt::LeftButton, keyboardModifiers);
qt_sendSpontaneousEvent((QObject*) widget, &ev);
m_mousePressTime = 0;
}
else {
//printf("Mouse Down: %d, %d\n", mousePos.x(), mousePos.y());
QMouseEvent ev(QEvent::MouseButtonPress, mousePos, mousePos,
Qt::LeftButton, Qt::LeftButton, keyboardModifiers);
qt_sendSpontaneousEvent((QObject*) widget, &ev);
m_mousePress = mousePos;
m_mousePressTime = currTime;
}
} else if (it->state == QPAHiddTpHandler::FingerMove) {
//printf("Mouse Move: %d, %d\n", mousePos.x(), mousePos.y());
QMouseEvent ev(QEvent::MouseMove, mousePos, mousePos,
Qt::LeftButton, Qt::LeftButton, keyboardModifiers);
qt_sendSpontaneousEvent((QObject*) widget, &ev);
}
}
}
}
//printf ("sending touch event\n");
qt_translateRawTouchEvent(QApplication::activeWindow(), QTouchEvent::TouchScreen, touchPoints);
for (it = m_touches.begin(); it != m_touches.end(); ++it) {
if (it->isPrimary) {
QPoint mousePos = QPoint(it->x, it->y);
if (widget) {
if (it->state == QPAHiddTpHandler::FingerUp) {
//printf("Mouse Up: %d, %d\n", mousePos.x(), mousePos.y());
QMouseEvent ev(QEvent::MouseButtonRelease, mousePos, mousePos,
Qt::LeftButton, Qt::NoButton, keyboardModifiers);
qt_sendSpontaneousEvent((QObject*) widget, &ev);
}
}
}
}
}
void sendEvent(QWidget* w, QEvent* ev)
{
m_ignoreEvents = true;
qt_sendSpontaneousEvent(w, ev);
m_ignoreEvents = false;
}
void ScrollArea::touchEvent(QTouchEvent *e) {
if (!e->touchPoints().isEmpty()) {
_touchPrevPos = _touchPos;
_touchPos = e->touchPoints().cbegin()->screenPos().toPoint();
}
switch (e->type()) {
case QEvent::TouchBegin:
if (_touchPress || e->touchPoints().isEmpty()) return;
_touchPress = true;
if (_touchScrollState == TouchScrollAuto) {
_touchScrollState = TouchScrollAcceleration;
_touchWaitingAcceleration = true;
_touchAccelerationTime = getms();
touchUpdateSpeed();
_touchStart = _touchPos;
} else {
_touchScroll = false;
_touchTimer.start(QApplication::startDragTime());
}
_touchStart = _touchPrevPos = _touchPos;
_touchRightButton = false;
break;
case QEvent::TouchUpdate:
if (!_touchPress) return;
if (!_touchScroll && (_touchPos - _touchStart).manhattanLength() >= QApplication::startDragDistance()) {
_touchTimer.stop();
_touchScroll = true;
touchUpdateSpeed();
}
if (_touchScroll) {
if (_touchScrollState == TouchScrollManual) {
touchScrollUpdated(_touchPos);
} else if (_touchScrollState == TouchScrollAcceleration) {
touchUpdateSpeed();
_touchAccelerationTime = getms();
if (_touchSpeed.isNull()) {
_touchScrollState = TouchScrollManual;
}
}
}
break;
case QEvent::TouchEnd:
if (!_touchPress) return;
_touchPress = false;
if (_touchScroll) {
if (_touchScrollState == TouchScrollManual) {
_touchScrollState = TouchScrollAuto;
_touchPrevPosValid = false;
_touchScrollTimer.start(15);
_touchTime = getms();
} else if (_touchScrollState == TouchScrollAuto) {
_touchScrollState = TouchScrollManual;
_touchScroll = false;
touchResetSpeed();
} else if (_touchScrollState == TouchScrollAcceleration) {
_touchScrollState = TouchScrollAuto;
_touchWaitingAcceleration = false;
_touchPrevPosValid = false;
}
} else if (window() && widget()) { // one short tap -- like left mouse click, one long tap -- like right mouse click
#ifdef Q_OS_WIN
Qt::MouseButton btn(_touchRightButton ? Qt::RightButton : Qt::LeftButton);
QPoint mapped(widget()->mapFromGlobal(_touchStart)), winMapped(window()->mapFromGlobal(_touchStart));
QMouseEvent pressEvent(QEvent::MouseButtonPress, mapped, winMapped, _touchStart, btn, Qt::MouseButtons(btn), Qt::KeyboardModifiers());
pressEvent.accept();
qt_sendSpontaneousEvent(widget(), &pressEvent);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, mapped, winMapped, _touchStart, btn, Qt::MouseButtons(btn), Qt::KeyboardModifiers());
qt_sendSpontaneousEvent(widget(), &releaseEvent);
if (_touchRightButton) {
QContextMenuEvent contextEvent(QContextMenuEvent::Mouse, mapped, _touchStart);
qt_sendSpontaneousEvent(widget(), &contextEvent);
}
#endif
}
_touchTimer.stop();
_touchRightButton = false;
break;
case QEvent::TouchCancel:
_touchPress = false;
_touchScroll = false;
_touchScrollState = TouchScrollManual;
_touchTimer.stop();
break;
}
}
void AQWebApplication::handleWebEvent(const QString &msgEvent)
{
QStringList args(QStringList::split(AQ_MSG_SEP, msgEvent, true));
AQ::EventType evT = webEventTypeToAQEventType(args[0]);
QWidget *w;
AQWidgetInfo *wInfo;
if (evT != AQ::XProgressDialog) {
w = AQ_WIDGET(args[1].toULongLong(0, 36));
wInfo = createdWidgets_.find(w);
if (!wInfo)
return;
}
switch (evT) {
case AQ::MouseButtonPress: {
QWidget *popup = activePopupWidget();
if (popup && popup != w->topLevelWidget())
popup->close();
w->raise();
w->setActiveWindow();
QPoint local(args[2].toInt(), args[3].toInt());
QPoint global(w->mapToGlobal(local));
QCursor::setPos(global);
QMouseEvent mev(QEvent::MouseButtonPress, local, global, toQtButton(args[4]), toQtButtonState(args[5]));
qt_sendSpontaneousEvent(w, &mev);
break;
}
case AQ::MouseButtonRelease: {
QPoint local(args[2].toInt(), args[3].toInt());
QPoint global(w->mapToGlobal(local));
QCursor::setPos(global);
QMouseEvent mev(QEvent::MouseButtonRelease, local, global, toQtButton(args[4]), toQtButtonState(args[5]));
qt_sendSpontaneousEvent(w, &mev);
break;
}
case AQ::MouseButtonDblClick: {
QPoint local(args[2].toInt(), args[3].toInt());
QPoint global(w->mapToGlobal(local));
QCursor::setPos(global);
QMouseEvent mev(QEvent::MouseButtonDblClick, local, global, toQtButton(args[4]), toQtButtonState(args[5]));
qt_sendSpontaneousEvent(w, &mev);
break;
}
case AQ::MouseMove: {
QPoint local(args[2].toInt(), args[3].toInt());
QPoint global(w->mapToGlobal(local));
QCursor::setPos(global);
QMouseEvent mev(QEvent::MouseMove, local, global, toQtButton(args[4]), toQtButtonState(args[5]));
qt_sendSpontaneousEvent(w, &mev);
break;
}
case AQ::KeyPress:
case AQ::KeyRelease: {
int keyCode = args[2].toInt();
QWidget *keywidget = QWidget::keyboardGrabber();
bool grabbed = false;
if (keywidget) {
grabbed = true;
} else {
keywidget = focusWidget();
if (!keywidget) {
keywidget = activePopupWidget();
if (!keywidget) {
keywidget = activeWindow();
if (!keywidget)
keywidget = w->topLevelWidget();
}
}
}
if (keyCode < 0) {
QKeyEvent kev((QEvent::Type) evT, 0, keyCode, toQtButtonState(args[3]), QChar(-keyCode));
qt_sendSpontaneousEvent(keywidget, &kev);
} else {
if (evT == AQ::KeyPress && !grabbed) {
QKeyEvent a((QEvent::Type) evT, toQtKey(keyCode), keyCode, toQtButtonState(args[3]));
if (qt_tryAccelEvent(keywidget, &a))
return;
}
QKeyEvent kev((QEvent::Type) evT, toQtKey(keyCode), keyCode, toQtButtonState(args[3]));
qt_sendSpontaneousEvent(keywidget, &kev);
}
break;
}
case AQ::Move:
if (w != desktop_) {
ignoreEvents_ = true;
w->move(args[2].toInt(), args[3].toInt());
ignoreEvents_ = false;
}
break;
case AQ::Resize:
if (w != desktop_) {
//ignoreEvents_ = true;
w->resize(args[2].toInt(), args[3].toInt());
//ignoreEvents_ = false;
} else {
int wt = args[2].toInt();
int ht = args[3].toInt();
desktopGeometry_.setRect(0, 0, wt, ht);
desktop()->resize(wt, ht);
postAQEvent(new AQEvent(w, new QResizeEvent(QSize(wt, ht), QSize())));
emit desktop()->resized(0);
if (!initDone_)
QTimer::singleShot(0, this, SLOT(init()));
}
break;
case AQ::XUpload: {
QFileDialog *fd = ::qt_cast<QFileDialog *>(w);
if (fd)
fd->rereadDir();
break;
}
case AQ::XProgressDialog: {
uint pid = args[1].toUInt();
if (args.size() == 2) {
QProgressDialog *pd = progressDialogs_.take(pid);
if (pd) {
pd->close();
pd->deleteLater();
}
} else {
QProgressDialog *pd = progressDialogs_.find(pid);
if (!pd) {
pd = new QProgressDialog(args[2], QString(), args[3].section(';', 1, 1).toInt());
progressDialogs_.insert(pid, pd);
}
pd->setProgress(args[3].section(';', 0, 0).toInt());
}
break;
}
case AQ::WindowStateChange: {
w->setWindowState(args[2].toInt());
break;
}
default: {
QEvent ev((QEvent::Type) evT);
qt_sendSpontaneousEvent(w, &ev);
}
}
}
