File indexing completed on 2024-05-19 05:35:24

 // krazy:excludeall=qclasses
 
 //////////////////////////////////////////////////////////////////////////////
 // oxygensimulator.cpp
 // simulates event chain passed to the application
 // -------------------
 //
 // SPDX-FileCopyrightText: 2010 Hugo Pereira Da Costa <hugo.pereira@free.fr>
 //
 // SPDX-License-Identifier: MIT
 //////////////////////////////////////////////////////////////////////////////
 
 #include "oxygensimulator.h"
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QCursor>
 #include <QFocusEvent>
 #include <QHoverEvent>
 #include <QMdiSubWindow>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QScrollBar>
 #include <QSlider>
 #include <QStyle>
 #include <QStyleOptionComboBox>
 #include <QStyleOptionSlider>
 #include <QToolButton>
 
 #ifdef Q_OS_WIN
 /* need windows.h include for Sleep function*/
 #include <windows.h>
 #endif
 
 #ifdef Q_OS_UNIX
 #include <ctime>
 #endif
 
 namespace Oxygen
 {
 //_______________________________________________________________________
 bool Simulator::_grabMouse = true;
 int Simulator::_defaultDelay = 250;
 
 //_______________________________________________________________________
 void Simulator::wait(int delay)
 {
     _events.append(Event(Event::Wait, nullptr, delay));
 }
 
 //_______________________________________________________________________
 void Simulator::click(QWidget *receiver, int delay)
 {
     QPoint position;
     if (QCheckBox *checkbox = qobject_cast<QCheckBox *>(receiver)) {
         QStyleOptionButton option;
         option.initFrom(checkbox);
         position = checkbox->style()->subElementRect(QStyle::SE_CheckBoxIndicator, &option, checkbox).center();
 
     } else if (QRadioButton *radiobutton = qobject_cast<QRadioButton *>(receiver)) {
         QStyleOptionButton option;
         option.initFrom(radiobutton);
         position = radiobutton->style()->subElementRect(QStyle::SE_RadioButtonIndicator, &option, radiobutton).center();
 
     } else if (const QMdiSubWindow *window = qobject_cast<QMdiSubWindow *>(receiver)) {
         QStyleOptionTitleBar option;
         option.initFrom(window);
         int titleBarHeight(window->style()->pixelMetric(QStyle::PM_TitleBarHeight, &option, window));
         QRect titleBarRect(QPoint(0, 0), QSize(window->width(), titleBarHeight));
         if (!titleBarRect.isValid())
             return;
         position = titleBarRect.center();
 
     } else {
         position = receiver->rect().center();
     }
 
     click(receiver, position, delay);
 }
 
 //_______________________________________________________________________
 void Simulator::click(QWidget *receiver, const QPoint &position, int delay)
 {
     Event event(Event::Click, receiver, delay);
     event._position = position;
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::slide(QWidget *receiver, const QPoint &position, int delay)
 {
     Event event(Event::Slide, receiver, delay);
     event._position = position;
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::selectItem(QWidget *receiver, int row, int column, int delay)
 {
     Event event(Event::SelectItem, receiver, delay);
     event._position = QPoint(column, row);
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::selectComboBoxItem(QWidget *receiver, int index, int delay)
 {
     Event event(Event::SelectComboBoxItem, receiver, delay);
     event._position.setX(index);
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::selectMenuItem(QWidget *receiver, int index, int delay)
 {
     Event event(Event::SelectMenuItem, receiver, delay);
     event._position.setX(index);
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::selectTab(QTabWidget *tabwidget, int index, int delay)
 {
     const auto children = tabwidget->children();
     for (QObject *child : children) {
         if (QTabBar *tabbar = qobject_cast<QTabBar *>(child)) {
             selectTab(tabbar, index, delay);
             break;
         }
     }
 }
 
 //_______________________________________________________________________
 void Simulator::selectTab(QTabBar *receiver, int index, int delay)
 {
     Event event(Event::SelectTab, receiver, delay);
     event._position.setX(index);
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::writeText(QWidget *receiver, QString text, int delay)
 {
     Event event(Event::WriteText, receiver, delay);
     event._text = text;
     _events.append(event);
 }
 
 //_______________________________________________________________________
 void Simulator::clearText(QWidget *receiver, int delay)
 {
     _events.append(Event(Event::ClearText, receiver, delay));
 }
 
 //_______________________________________________________________________
 void Simulator::run(void)
 {
     if (_events.isEmpty())
         return;
 
     // clear abort state
     _aborted = false;
 
     emit stateChanged(true);
 
     for (const Event &event : std::as_const(_events)) {
         if (_aborted) {
             _events.clear();
             return;
         }
 
         processEvent(event);
     }
 
     // add last event to reset previousWidget and previousPosition
     if (_previousWidget) {
         postEvent(_previousWidget.data(), QEvent::Leave);
         if (_previousWidget.data()->testAttribute(Qt::WA_Hover)) {
             const QPoint oldPosition(_previousWidget.data()->mapFromGlobal(_previousPosition));
             const QPoint newPosition(_previousWidget.data()->mapFromGlobal(QPoint(-1, -1)));
             postHoverEvent(_previousWidget.data(), QEvent::HoverLeave, newPosition, oldPosition);
         }
 
         _previousWidget.clear();
         _previousPosition = QPoint(-1, -1);
     }
 
     _events.clear();
     emit stateChanged(false);
 
     return;
 }
 
 //_______________________________________________________________________
 void Simulator::abort(void)
 {
     _aborted = true;
     emit stateChanged(true);
 }
 
 //_______________________________________________________________________
 void Simulator::timerEvent(QTimerEvent *event)
 {
     if (event->timerId() == _timer.timerId()) {
         _timer.stop();
 
     } else if (event->timerId() == _pendingEventsTimer.timerId()) {
         if (_aborted) {
             qDeleteAll(_pendingEvents);
 
             _pendingEvents.clear();
             _pendingWidget.clear();
 
         } else if (_pendingWidget && _pendingWidget.data()->isVisible()) {
             _pendingEventsTimer.stop();
             for (QEvent *event : std::as_const(_pendingEvents)) {
                 if (event->type() == QEvent::MouseMove) {
                     QPoint position(static_cast<QMouseEvent *>(event)->pos());
                     moveCursor(_pendingWidget.data()->mapToGlobal(position));
                 }
 
                 postQEvent(_pendingWidget.data(), event);
                 postDelay(150);
             }
 
             _pendingEvents.clear();
             _pendingWidget.clear();
         }
 
     } else
         return QObject::timerEvent(event);
 }
 
 //_______________________________________________________________________
 void Simulator::processEvent(const Event &event)
 {
     if (_aborted)
         return;
     if (!event._receiver) {
         if (event._type == Event::Wait) {
             postDelay(event._delay);
         }
 
         return;
     }
 
     QWidget *receiver(event._receiver.data());
     switch (event._type) {
     // click event
     case Event::Click: {
         // enter widget or move cursor to relevant position
         if (!enter(receiver, event._position, event._delay)) {
             moveCursor(receiver->mapToGlobal(event._position));
             postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, event._position);
         }
 
         postMouseClickEvent(receiver, Qt::LeftButton, event._position);
         break;
     }
 
     // slide
     case Event::Slide: {
         const QPoint &delta(event._position);
 
         // calculate begin position depending on widget type
         QPoint begin;
         if (const QSlider *slider = qobject_cast<QSlider *>(receiver)) {
             // this is copied from QSlider::initStyleOption
             QStyleOptionSlider option;
             option.initFrom(slider);
             option.orientation = slider->orientation();
             option.sliderPosition = slider->sliderPosition();
             option.minimum = slider->minimum();
             option.maximum = slider->maximum();
             option.upsideDown = (slider->orientation() == Qt::Horizontal) ? (slider->invertedAppearance() != (option.direction == Qt::RightToLeft))
                                                                           : (!slider->invertedAppearance());
 
             QRect handleRect(slider->style()->subControlRect(QStyle::CC_Slider, &option, QStyle::SC_SliderHandle, slider));
 
             if (!handleRect.isValid())
                 break;
             begin = handleRect.center();
 
         } else if (const QScrollBar *scrollbar = qobject_cast<QScrollBar *>(receiver)) {
             // this is copied from QSlider::initStyleOption
             QStyleOptionSlider option;
             option.initFrom(scrollbar);
             option.orientation = scrollbar->orientation();
             option.sliderPosition = scrollbar->sliderPosition();
             option.minimum = scrollbar->minimum();
             option.maximum = scrollbar->maximum();
             option.upsideDown = scrollbar->invertedAppearance();
             if (scrollbar->orientation() == Qt::Horizontal) {
                 option.state |= QStyle::State_Horizontal;
             }
 
             QRect handleRect(scrollbar->style()->subControlRect(QStyle::CC_ScrollBar, &option, QStyle::SC_ScrollBarSlider, scrollbar));
 
             if (!handleRect.isValid())
                 break;
             begin = handleRect.center();
 
         } else if (const QMdiSubWindow *window = qobject_cast<QMdiSubWindow *>(receiver)) {
             QStyleOptionTitleBar option;
             option.initFrom(window);
             int titleBarHeight(window->style()->pixelMetric(QStyle::PM_TitleBarHeight, &option, window));
             QRect titleBarRect(QPoint(0, 0), QSize(window->width(), titleBarHeight));
             if (!titleBarRect.isValid())
                 break;
             begin = titleBarRect.center();
 
         } else {
             begin = receiver->rect().center();
         }
 
         // enter widget or move cursor to relevant position
         if (!enter(receiver, begin, event._delay)) {
             moveCursor(receiver->mapToGlobal(begin));
             postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, begin);
         }
 
         const QPoint end(begin + delta);
         postMouseEvent(receiver, QEvent::MouseButtonPress, Qt::LeftButton, begin, Qt::LeftButton);
         setFocus(receiver);
         postDelay(50);
         const int steps = 10;
         for (int i = 0; i < steps; ++i) {
             QPoint current(begin.x() + qreal((i + 1) * (end.x() - begin.x())) / steps, begin.y() + qreal((i + 1) * (end.y() - begin.y())) / steps);
             moveCursor(receiver->mapToGlobal(current), 1);
             postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, current, Qt::LeftButton, Qt::NoModifier);
             postDelay(20);
         }
 
         postMouseEvent(receiver, QEvent::MouseButtonRelease, Qt::LeftButton, end);
         break;
     }
 
     case Event::SelectItem: {
         const QAbstractItemView *view = qobject_cast<QAbstractItemView *>(receiver);
         if (!(view && view->model()))
             break;
 
         const int column(event._position.x());
         const int row(event._position.y());
 
         // find index
         const QModelIndex modelIndex(view->model()->index(row, column));
         if (!modelIndex.isValid())
             break;
 
         // get rect
         QRect r(view->visualRect(modelIndex));
         if (!r.isValid())
             break;
 
         // enter widget or move cursor to relevant position
         const QPoint position(r.center());
         if (!enter(view->viewport(), position, event._delay)) {
             moveCursor(view->viewport()->mapToGlobal(position));
             postMouseEvent(view->viewport(), QEvent::MouseMove, Qt::NoButton, position);
             postDelay(event._delay);
         }
 
         postMouseClickEvent(view->viewport(), Qt::LeftButton, position);
         break;
     }
 
     case Event::SelectComboBoxItem: {
         QComboBox *combobox = qobject_cast<QComboBox *>(receiver);
         if (!combobox)
             break;
 
         // get arrow rect
         QStyleOptionComboBox option;
         option.initFrom(combobox);
         QRect arrowRect(combobox->style()->subControlRect(QStyle::CC_ComboBox, &option, QStyle::SC_ComboBoxArrow, combobox));
 
         // enter widget or move cursor to relevant position
         QPoint position(arrowRect.center());
         if (!enter(combobox, position, event._delay)) {
             moveCursor(combobox->mapToGlobal(position));
             postMouseEvent(combobox, QEvent::MouseMove, Qt::NoButton, position);
             postDelay(event._delay);
         }
 
         postMouseClickEvent(combobox, Qt::LeftButton, position);
 
         // select item in view
         QAbstractItemView *view = combobox->view();
         const int row(event._position.x());
         const int column(0);
 
         // find index
         const QModelIndex modelIndex(view->model()->index(row, column));
         if (!modelIndex.isValid())
             break;
 
         // get rect
         QRect r(view->visualRect(modelIndex));
         if (!r.isValid())
             break;
 
         // send event
         position = QPoint(r.center());
         moveCursor(view->viewport()->mapToGlobal(position));
         postMouseEvent(view->viewport(), QEvent::MouseMove, Qt::NoButton, position, Qt::NoButton, Qt::NoModifier);
         postDelay(100);
         postMouseClickEvent(view->viewport(), Qt::LeftButton, position);
         break;
     }
 
     case Event::SelectMenuItem: {
         // retrieve menu
         QMenu *menu(nullptr);
         if (const QToolButton *button = qobject_cast<QToolButton *>(receiver))
             menu = button->menu();
         else if (const QPushButton *button = qobject_cast<QPushButton *>(receiver))
             menu = button->menu();
 
         // abort if not found
         if (!menu)
             break;
 
         // get action and geometry
         const int row(event._position.x());
         QList<QAction *> actions(menu->actions());
         if (row >= actions.size())
             break;
 
         menu->sizeHint();
         QRect r(menu->actionGeometry(actions[row]));
         if (!r.isValid())
             break;
 
         /*!
         HACK: As soon as leftMouseButton is pressed on a button with menu,
         the menu is shown and code is interrupted until an action is selected in the menu.
         As a consequence, one must first generate the events, execute them with a delay, and then
         click on the button (before delay is expired). This way, the menu events will be executed
         even if the menu is visible (and blocking further code execution).
         */
         QPoint position(r.center());
         _pendingWidget = menu;
         _pendingEvents.append(new QMouseEvent(QEvent::MouseMove, position, Qt::NoButton, Qt::NoButton, Qt::NoModifier));
 
         _pendingEvents.append(new QMouseEvent(QEvent::MouseButtonPress, position, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
 
         _pendingEvents.append(new QMouseEvent(QEvent::MouseButtonRelease, position, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
 
         _pendingEventsTimer.start(10, this);
 
         // enter widget or move cursor to relevant position
         position = receiver->rect().center();
         if (!enter(receiver, position, event._delay)) {
             moveCursor(receiver->mapToGlobal(position));
             postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, position);
             postDelay(event._delay);
         }
 
         // click
         postMouseEvent(receiver, QEvent::MouseButtonPress, Qt::LeftButton, position, Qt::NoButton, Qt::NoModifier);
         break;
     }
 
     case Event::SelectTab: {
         const QTabBar *tabbar = qobject_cast<QTabBar *>(receiver);
         if (!tabbar)
             break;
 
         const int index(event._position.x());
 
         const QRect r(tabbar->tabRect(index));
         if (!r.isValid())
             break;
 
         // enter widget or move cursor to relevant position
         const QPoint position(r.center());
         if (!enter(receiver, position, event._delay)) {
             moveCursor(receiver->mapToGlobal(position));
             postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, position);
             postDelay(event._delay);
         }
 
         postMouseClickEvent(receiver, Qt::LeftButton, position);
         break;
     }
 
     case Event::WriteText: {
         enter(receiver, receiver->rect().center(), event._delay);
         setFocus(receiver);
         const QString &text(event._text);
         for (int i = 0; i < text.length(); ++i) {
             const Qt::Key key(toKey(text.at(i)));
             const QString local(text.at(i));
             postKeyEvent(receiver, QEvent::KeyPress, key, local, Qt::NoModifier);
             postKeyEvent(receiver, QEvent::KeyRelease, key, local, Qt::NoModifier);
             postDelay(20);
         }
         break;
     }
 
     case Event::ClearText: {
         enter(receiver, receiver->rect().center(), event._delay);
         setFocus(receiver);
         postKeyEvent(receiver, QEvent::KeyPress, Qt::Key_A, QStringLiteral("a"), Qt::ControlModifier);
         postKeyEvent(receiver, QEvent::KeyRelease, Qt::Key_A, QStringLiteral("a"), Qt::ControlModifier);
         postDelay(20);
         postKeyClickEvent(receiver, Qt::Key_Backspace, QString());
     }
 
     default:
         break;
     }
 
     // delay
     postDelay(event._delay);
 
     return;
 }
 
 //_______________________________________________________________________
 void Simulator::postEvent(QWidget *receiver, QEvent::Type type) const
 {
     postQEvent(receiver, new QEvent(type));
 }
 
 //_______________________________________________________________________
 void Simulator::postHoverEvent(QWidget *receiver, QEvent::Type type, const QPoint &newPosition, const QPoint &oldPosition) const
 {
     postQEvent(receiver, new QHoverEvent(type, newPosition, oldPosition));
 }
 
 //_______________________________________________________________________
 bool Simulator::enter(QWidget *receiver, const QPoint &position, int delay)
 {
     if (receiver == _previousWidget.data())
         return false;
 
     // store position
     moveCursor(receiver->mapToGlobal(position));
 
     // leave previous widget
     if (_previousWidget) {
         postEvent(_previousWidget.data(), QEvent::Leave);
         if (_previousWidget.data()->testAttribute(Qt::WA_Hover)) {
             const QPoint oldPosition(_previousWidget.data()->mapFromGlobal(_previousPosition));
             const QPoint newPosition(_previousWidget.data()->mapFromGlobal(receiver->mapToGlobal(position)));
             postHoverEvent(_previousWidget.data(), QEvent::HoverLeave, newPosition, oldPosition);
         }
     }
 
     // enter or move in current widget
     if (!receiver->rect().contains(receiver->mapFromGlobal(_previousPosition))) {
         // enter current widget if needed
         postEvent(receiver, QEvent::Enter);
         if (receiver->testAttribute(Qt::WA_Hover)) {
             const QPoint oldPosition(receiver->mapFromGlobal(_previousPosition));
             const QPoint newPosition(position);
             postHoverEvent(receiver, QEvent::HoverEnter, newPosition, oldPosition);
         }
 
     } else if (receiver->mapFromGlobal(_previousPosition) != position) {
         // move mouse if needed
         postMouseEvent(receiver, QEvent::MouseMove, Qt::NoButton, position);
         if (receiver->testAttribute(Qt::WA_Hover)) {
             const QPoint oldPosition(receiver->mapFromGlobal(_previousPosition));
             const QPoint newPosition(position);
             postHoverEvent(receiver, QEvent::HoverMove, newPosition, oldPosition);
         }
     }
 
     // update previous widget and position
     _previousWidget = receiver;
     _previousPosition = receiver->mapToGlobal(position);
     postDelay(delay);
 
     return true;
 }
 
 //_______________________________________________________________________
 void Simulator::postMouseClickEvent(QWidget *receiver, Qt::MouseButton button, const QPoint &position)
 {
     // button press and button release
     postMouseEvent(receiver, QEvent::MouseButtonPress, button, position, button);
     setFocus(receiver);
     postDelay(50);
     postMouseEvent(receiver, QEvent::MouseButtonRelease, button, position, button);
 }
 
 //_______________________________________________________________________
 void Simulator::postMouseEvent(QWidget *receiver,
                                QEvent::Type type,
                                Qt::MouseButton button,
                                const QPoint &position,
                                Qt::MouseButtons buttons,
                                Qt::KeyboardModifiers modifiers) const
 {
     postQEvent(receiver, new QMouseEvent(type, position, receiver->mapToGlobal(position), button, buttons, modifiers));
 }
 
 //_______________________________________________________________________
 void Simulator::postKeyClickEvent(QWidget *receiver, Qt::Key key, QString text, Qt::KeyboardModifiers modifiers) const
 {
     postKeyModifiersEvent(receiver, QEvent::KeyPress, modifiers);
     postKeyEvent(receiver, QEvent::KeyPress, key, text, modifiers);
     postKeyEvent(receiver, QEvent::KeyRelease, key, text, modifiers);
     postKeyModifiersEvent(receiver, QEvent::KeyRelease, modifiers);
 }
 
 //_______________________________________________________________________
 void Simulator::postKeyModifiersEvent(QWidget *receiver, QEvent::Type type, Qt::KeyboardModifiers modifiers) const
 {
     if (modifiers == Qt::NoModifier)
         return;
 
     switch (type) {
     case QEvent::KeyPress: {
         if (modifiers & Qt::ShiftModifier) {
             postKeyEvent(receiver, QEvent::KeyPress, Qt::Key_Shift, QString());
         }
 
         if (modifiers & Qt::ControlModifier) {
             postKeyEvent(receiver, QEvent::KeyPress, Qt::Key_Control, QString(), modifiers & Qt::ShiftModifier);
         }
 
         if (modifiers & Qt::AltModifier) {
             postKeyEvent(receiver, QEvent::KeyPress, Qt::Key_Alt, QString(), modifiers & (Qt::ShiftModifier | Qt::ControlModifier));
         }
 
         if (modifiers & Qt::MetaModifier) {
             postKeyEvent(receiver, QEvent::KeyPress, Qt::Key_Meta, QString(), modifiers & (Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier));
         }
 
         break;
     }
 
     case QEvent::KeyRelease: {
         if (modifiers & Qt::MetaModifier) {
             postKeyEvent(receiver, QEvent::KeyRelease, Qt::Key_Meta, QString());
         }
 
         if (modifiers & Qt::AltModifier) {
             postKeyEvent(receiver, QEvent::KeyRelease, Qt::Key_Alt, QString(), modifiers & Qt::MetaModifier);
         }
 
         if (modifiers & Qt::ControlModifier) {
             postKeyEvent(receiver, QEvent::KeyRelease, Qt::Key_Control, QString(), modifiers & (Qt::MetaModifier | Qt::AltModifier));
         }
 
         if (modifiers & Qt::ShiftModifier) {
             postKeyEvent(receiver, QEvent::KeyRelease, Qt::Key_Shift, QString(), modifiers & (Qt::MetaModifier | Qt::AltModifier | Qt::ControlModifier));
         }
     }
 
     default:
         break;
     }
 }
 
 //_______________________________________________________________________
 void Simulator::postKeyEvent(QWidget *receiver, QEvent::Type type, Qt::Key key, QString text, Qt::KeyboardModifiers modifiers) const
 {
     postQEvent(receiver, new QKeyEvent(type, key, modifiers, text));
 }
 
 //_______________________________________________________________________
 void Simulator::postDelay(int delay)
 {
     // check value
     if (delay == -1)
         delay = _defaultDelay;
     if (delay <= 0)
         return;
 
     // this is largely inspired from qtestlib's qsleep implementation
     _timer.start(delay, this);
     while (_timer.isActive()) {
         // flush events in loop
         QCoreApplication::processEvents(QEventLoop::AllEvents, delay);
         int ms(10);
 
 // sleep
 #ifdef Q_OS_WIN
         Sleep(uint(ms));
 #else
         struct timespec ts = {ms / 1000, (ms % 1000) * 1000 * 1000};
         nanosleep(&ts, nullptr);
 #endif
     }
 }
 
 //_______________________________________________________________________
 void Simulator::moveCursor(const QPoint &position, int steps)
 {
     // do nothing if mouse grab is disabled
     if (!_grabMouse)
         return;
     if (_aborted)
         return;
     const QPoint begin(QCursor::pos());
     const QPoint end(position);
     if (begin == end)
         return;
 
     if (steps > 1) {
         for (int i = 0; i < steps; ++i) {
             const QPoint current(begin.x() + qreal((i + 1) * (end.x() - begin.x())) / steps, begin.y() + qreal((i + 1) * (end.y() - begin.y())) / steps);
             QCursor::setPos(current);
             postDelay(10);
         }
 
     } else {
         QCursor::setPos(end);
     }
 }
 
 //_______________________________________________________________________
 void Simulator::setFocus(QWidget *receiver)
 {
     if (receiver->focusPolicy() != Qt::NoFocus) {
         receiver->setFocus();
     }
 }
 
 //_______________________________________________________________________
 Qt::Key Simulator::toKey(QChar a) const
 {
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
     return (Qt::Key)QKeySequence(a)[0];
 #else
     return QKeySequence(a)[0].key();
 #endif
 }
 
 //_______________________________________________________________________
 void Simulator::postQEvent(QWidget *receiver, QEvent *event) const
 {
     if (_aborted)
         delete event;
     else
         qApp->postEvent(receiver, event);
 }
 }