initial commit

Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>

libs/wxWidgets-3.3.1/include/wx/qt/private/compat.h

@@ -0,0 +1,37 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/private/compat.h
+// Purpose:     Helpers for dealing with various Qt versions
+// Author:      Vadim Zeitlin
+// Created:     2022-10-21
+// Copyright:   (c) 2022 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_PRIVATE_COMPAT_H_
+#define _WX_QT_PRIVATE_COMPAT_H_
+
+#include <QtGui/QFontMetrics>
+
+// Hide the difference in name of QFontMetrics::width() in various Qt versions.
+inline int
+wxQtGetWidthFromMetrics(const QFontMetrics& metrics, const QString& string)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
+    return metrics.horizontalAdvance( string );
+#else
+    return metrics.width( string );
+#endif
+}
+
+// Hide the difference in getting Qt event position in various Qt versions.
+template<typename T>
+inline QPoint wxQtGetEventPosition(T* event)
+{
+#if QT_VERSION_MAJOR >= 6
+    return event->position().toPoint();
+#else
+    return event->pos();
+#endif
+}
+
+#endif // _WX_QT_PRIVATE_COMPAT_H_

libs/wxWidgets-3.3.1/include/wx/qt/private/converter.h

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/converter.h
+// Purpose:     Converter utility classes and functions
+// Author:      Peter Most, Kolya Kosenko
+// Created:     02/28/10
+// Copyright:   (c) Peter Most
+//              (c) 2010 Kolya Kosenko
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_CONVERTER_H_
+#define _WX_QT_CONVERTER_H_
+
+#include "wx/defs.h"
+
+#include "wx/kbdstate.h"
+#include "wx/gdicmn.h"
+#include "wx/colour.h"
+#include "wx/geometry.h"
+
+#include <QtCore/QRect>
+#include <QtCore/QSize>
+#include <QtCore/QString>
+#include <QtGui/QColor>
+
+// Rely on overloading and let the compiler pick the correct version, which makes
+// them easier to use then to write wxQtConvertQtRectToWxRect() or wxQtConvertWxRectToQtRect()
+
+inline wxPoint wxQtConvertPoint( const QPoint &point )
+{
+    return wxPoint( point.x(), point.y() );
+}
+
+inline QPoint wxQtConvertPoint( const wxPoint &point )
+{
+    return QPoint( point.x, point.y );
+}
+
+inline wxPoint2DDouble wxQtConvertPointF(const QPointF& point)
+{
+    return wxPoint2DDouble(point.x(), point.y());
+}
+
+inline QPointF wxQtConvertPointF(const wxPoint2DDouble& point)
+{
+    return QPointF(point.m_x, point.m_y);
+}
+
+inline wxRect wxQtConvertRect( const QRect &rect )
+{
+    return wxRect( rect.x(), rect.y(), rect.width(), rect.height() );
+}
+
+inline QRect wxQtConvertRect( const wxRect &rect )
+{
+    return QRect( rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight() );
+}
+
+// TODO: Check whether QString::toStdString/QString::toStdWString might be faster
+
+inline wxString wxQtConvertString( const QString &str )
+{
+    return wxString( str.toUtf8().data(), wxConvUTF8 );
+}
+
+inline QString wxQtConvertString( const wxString &str )
+{
+    return QString( str.utf8_str() );
+}
+
+inline wxColour wxQtConvertColour(const QColor &colour)
+{
+    return wxColour(colour.red(), colour.green(), colour.blue(), colour.alpha());
+}
+
+inline QColor wxQtConvertColour(const wxColour &colour)
+{
+    return QColor(colour.Red(), colour.Green(), colour.Blue(), colour.Alpha());
+}
+
+#if wxUSE_DATETIME
+
+class WXDLLIMPEXP_FWD_BASE wxDateTime;
+class QDate;
+class QTime;
+
+wxDateTime wxQtConvertDate(const QDate& date);
+QDate wxQtConvertDate(const wxDateTime& date);
+
+wxDateTime wxQtConvertTime(const QTime& Time);
+QTime wxQtConvertTime(const wxDateTime& time);
+
+#endif // wxUSE_DATETIME
+
+inline wxSize wxQtConvertSize( const QSize  &size )
+{
+    return wxSize(size.width(), size.height());
+}
+inline QSize wxQtConvertSize( const wxSize &size )
+{
+    return QSize(size.GetWidth(), size.GetHeight());
+}
+
+Qt::Orientation wxQtConvertOrientation( long style, wxOrientation defaultOrientation );
+wxOrientation wxQtConvertOrientation( Qt::Orientation );
+
+wxKeyCode wxQtConvertKeyCode( int key, Qt::KeyboardModifiers modifiers );
+void wxQtFillKeyboardModifiers( Qt::KeyboardModifiers modifiers, wxKeyboardState *state );
+int wxQtConvertKeyCode( int keyCode, int modifiers, Qt::KeyboardModifiers &qtmodifiers );
+
+#endif // _WX_QT_CONVERTER_H_
+

libs/wxWidgets-3.3.1/include/wx/qt/private/pointer.h

@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/private/pointer.h
+// Author:      Peter Most
+// Copyright:   (c) Peter Most
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_POINTER_H_
+#define _WX_QT_POINTER_H_
+
+#include <QtCore/QPointer>
+
+// Extend QPointer with the ability to delete the object in its destructor. The
+// normal behaviour of the QPointer makes sure that this is safe, because if somebody
+// has deleted the object, then data() returns nullptr and delete does nothing.
+
+template < typename T >
+class wxQtPointer : public QPointer< T >
+{
+public:
+    inline wxQtPointer()
+        : QPointer< T >()
+    {
+    }
+
+    inline wxQtPointer( T *p )
+        : QPointer< T >( p )
+    {
+    }
+
+    inline wxQtPointer< T > &operator = ( T *p )
+    {
+        QPointer< T >::operator = ( p );
+        return *this;
+    }
+
+    inline ~wxQtPointer()
+    {
+        delete QPointer< T >::data();
+    }
+};
+
+#endif // _WX_QT_POINTER_H_

libs/wxWidgets-3.3.1/include/wx/qt/private/timer.h

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/timer.h
+// Author:      Javier Torres
+// Copyright:   (c) Javier Torres
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_TIMER_H_
+#define _WX_QT_TIMER_H_
+
+#if wxUSE_TIMER
+
+#include <QtCore/QObject>
+#include "wx/private/timer.h"
+
+//-----------------------------------------------------------------------------
+// wxTimer
+//-----------------------------------------------------------------------------
+
+class QTimerEvent;
+class WXDLLIMPEXP_CORE wxQtTimerImpl : public wxTimerImpl, QObject
+{
+public:
+    wxQtTimerImpl( wxTimer* timer );
+
+    virtual bool Start( int millisecs = -1, bool oneShot = false ) override;
+    virtual void Stop() override;
+    virtual bool IsRunning() const override;
+
+protected:
+    virtual void timerEvent( QTimerEvent * event ) override;
+
+private:
+    int m_timerId;
+};
+
+#endif // wxUSE_TIMER
+
+#endif // _WX_QT_TIMER_H_

libs/wxWidgets-3.3.1/include/wx/qt/private/treeitemdelegate.h

@@ -0,0 +1,99 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/private/treeitemdelegate.h
+// Purpose:     Delegate to create text edit controls for the tree items
+// Author:      Matthew Griffin
+// Created:     2019-05-29
+// Copyright:   Matthew Griffin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_PRIVATE_TREEITEM_DELEGATE_H
+#define _WX_QT_PRIVATE_TREEITEM_DELEGATE_H
+
+#include <QtWidgets/QStyledItemDelegate>
+#include <QtWidgets/QToolTip>
+
+#include "wx/app.h"
+#include "wx/textctrl.h"
+
+#include "treeitemfactory.h"
+
+class wxQTTreeItemDelegate : public QStyledItemDelegate
+{
+public:
+    explicit wxQTTreeItemDelegate(wxWindow* parent)
+        : m_parent(parent),
+        m_textCtrl(nullptr)
+    {
+    }
+
+    QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &WXUNUSED(option), const QModelIndex &index) const override
+    {
+        if ( m_textCtrl != nullptr )
+            destroyEditor(m_textCtrl->GetHandle(), m_currentModelIndex);
+
+        m_currentModelIndex = index;
+        m_textCtrl = new wxQtListTextCtrl(m_parent, parent);
+        m_textCtrl->SetFocus();
+        return m_textCtrl->GetHandle();
+    }
+
+    void destroyEditor(QWidget *WXUNUSED(editor), const QModelIndex &WXUNUSED(index)) const override
+    {
+        if ( m_textCtrl != nullptr )
+        {
+            m_currentModelIndex = QModelIndex(); // invalidate the index
+            wxTheApp->ScheduleForDestruction(m_textCtrl);
+            m_textCtrl = nullptr;
+        }
+    }
+
+    void setModelData(QWidget *WXUNUSED(editor), QAbstractItemModel *WXUNUSED(model), const QModelIndex &WXUNUSED(index)) const override
+    {
+        // Don't set model data until wx has had a chance to send out events
+    }
+
+    wxTextCtrl* GetEditControl() const
+    {
+        return m_textCtrl;
+    }
+
+    QModelIndex GetCurrentModelIndex() const
+    {
+        return m_currentModelIndex;
+    }
+
+    void AcceptModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
+    {
+        QStyledItemDelegate::setModelData(editor, model, index);
+    }
+
+    virtual bool helpEvent(QHelpEvent* event, QAbstractItemView* view, const QStyleOptionViewItem& option, const QModelIndex& index) override
+    {
+        if ( event->type() == QEvent::ToolTip )
+        {
+            const QRect &itemRect = view->visualRect(index);
+            const QSize &bestSize = sizeHint(option, index);
+            if ( itemRect.width() < bestSize.width() )
+            {
+                const QString &value = index.data(Qt::DisplayRole).toString();
+                QToolTip::showText(event->globalPos(), value, view);
+            }
+            else
+            {
+                QToolTip::hideText();
+            }
+
+            return true;
+        }
+
+        return QStyledItemDelegate::helpEvent(event, view, option, index);
+    }
+
+private:
+    wxWindow* m_parent;
+    mutable wxTextCtrl* m_textCtrl;
+    mutable QModelIndex m_currentModelIndex;
+};
+
+#endif // _WX_QT_PRIVATE_TREEITEM_DELEGATE_H

libs/wxWidgets-3.3.1/include/wx/qt/private/treeitemfactory.h

@@ -0,0 +1,122 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/private/treeitemfactory.h
+// Purpose:     Factory to create text edit controls for the tree items
+// Author:      Graham Dawes
+// Created:     2019-02-07
+// Copyright:   Graham Dawes
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_PRIVATE_TREEITEM_FACTORY_H_
+#define _WX_QT_PRIVATE_TREEITEM_FACTORY_H_
+
+#include <QtWidgets/QItemEditorFactory>
+#include <QtWidgets/QTreeWidget>
+#include <QtWidgets/QItemDelegate>
+
+#include "wx/recguard.h"
+#include "wx/textctrl.h"
+
+// wxQT Doesn't have a mechanism for "adopting" external widgets so we have to
+// create an instance of wxTextCtrl rather than adopting the control QT would
+// create.
+//
+// Unfortunately the factory is given an internal widget as the parent for
+// editor.
+//
+// To work around these issues we create a wxTextCtl parented by the wxListCtrl
+// then recalculate its position relative to the internal widget.
+
+class wxQtListTextCtrl : public wxTextCtrl
+{
+public:
+    wxQtListTextCtrl(wxWindow* parent, QWidget* actualParent)
+        : wxTextCtrl(parent, wxID_ANY, wxEmptyString,
+            wxDefaultPosition, wxDefaultSize,
+            wxNO_BORDER),
+        m_actualParent(actualParent),
+        m_moving(0)
+    {
+        Bind(wxEVT_MOVE, &wxQtListTextCtrl::OnMove, this);
+    }
+
+    void OnMove(wxMoveEvent &event)
+    {
+        // QWidget::move generates a QMoveEvent so we need to guard against
+        // reentrant calls.
+        wxRecursionGuard guard(m_moving);
+
+        if ( guard.IsInside() )
+        {
+            event.Skip();
+            return;
+        }
+
+        const QPoint eventPos = wxQtConvertPoint(event.GetPosition());
+        const QPoint globalPos = m_actualParent->mapToGlobal(eventPos);
+
+        // For some reason this always gives us the offset from the header info
+        // the internal control. So we need to treat this as an offset rather
+        // than a position.
+        QWidget* widget = GetHandle();
+        const QPoint offset = widget->mapFromGlobal(globalPos);
+
+        widget->move(eventPos + offset);
+    }
+
+private:
+    QWidget* m_actualParent;
+    wxRecursionGuardFlag m_moving;
+
+    wxDECLARE_NO_COPY_CLASS(wxQtListTextCtrl);
+};
+
+// QT doesn't give us direct access to the editor within the QTreeWidget.
+// Instead, we'll supply a factory to create the widget for QT and keep track
+// of it ourselves.
+
+class wxQtTreeItemEditorFactory : public QItemEditorFactory
+{
+public:
+    explicit wxQtTreeItemEditorFactory(wxWindow* parent)
+        : m_parent(parent),
+          m_textCtrl(nullptr)
+    {
+    }
+
+    void AttachTo(QTreeWidget *tree)
+    {
+        QAbstractItemDelegate* delegate = tree->itemDelegate();
+        QItemDelegate *qItemDelegate = static_cast<QItemDelegate*>(delegate);
+        qItemDelegate->setItemEditorFactory(this);
+    }
+
+    QWidget* createEditor(int WXUNUSED(userType), QWidget* parent) const override
+    {
+        if (m_textCtrl != nullptr)
+            ClearEditor();
+
+        m_textCtrl = new wxQtListTextCtrl(m_parent, parent);
+        m_textCtrl->SetFocus();
+        return m_textCtrl->GetHandle();
+    }
+
+    wxTextCtrl* GetEditControl() const
+    {
+        return m_textCtrl;
+    }
+
+    void ClearEditor() const
+    {
+        delete m_textCtrl;
+        m_textCtrl = nullptr;
+    }
+
+private:
+    wxWindow* m_parent;
+    mutable wxTextCtrl* m_textCtrl;
+
+    wxDECLARE_NO_COPY_CLASS(wxQtTreeItemEditorFactory);
+};
+
+#endif //_WX_QT_PRIVATE_TREEITEM_FACTORY_H_

libs/wxWidgets-3.3.1/include/wx/qt/private/utils.h

@@ -0,0 +1,27 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/qt/utils.h
+// Purpose:     utility classes and/or functions
+// Author:      Peter Most, Javier Torres
+// Created:     15/05/10
+// Copyright:   (c) Peter Most, Javier Torres
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_UTILS_H_
+#define _WX_QT_UTILS_H_
+
+#include "wx/mousestate.h"
+#include <QtCore/Qt>
+
+void wxQtFillMouseButtons( Qt::MouseButtons buttons, wxMouseState *state );
+
+void wxMissingImplementation( const char fileName[], unsigned lineNumber,
+    const char feature[] );
+
+#define wxMISSING_IMPLEMENTATION( feature )\
+    wxMissingImplementation( __FILE__, __LINE__, feature )
+
+#define wxMISSING_FUNCTION() \
+    wxMISSING_IMPLEMENTATION( __func__ )
+
+#endif // _WX_QT_UTILS_H_

libs/wxWidgets-3.3.1/include/wx/qt/private/winevent.h

@@ -0,0 +1,583 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        include/wx/qt/private/winevent.h
+// Purpose:     QWidget to wxWindow event handler
+// Author:      Javier Torres, Peter Most
+// Created:     21.06.10
+// Copyright:   (c) Javier Torres
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_QT_EVENTSIGNALFORWARDER_H_
+#define _WX_QT_EVENTSIGNALFORWARDER_H_
+
+#include <QtCore/QEvent>
+#include <QtGui/QCloseEvent>
+
+#include "wx/log.h"
+#include "wx/window.h"
+#include "wx/qt/private/converter.h"
+#include "wx/qt/private/utils.h"
+
+#include <QtWidgets/QGestureEvent>
+#include <QtGui/QCursor>
+
+// redeclare wxEVT_TEXT_ENTER here instead of including "wx/textctrl.h"
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_TEXT_ENTER, wxCommandEvent);
+
+// The parameter of QWidget::enterEvent() is changed to QEnterEvent in Qt6
+#if QT_VERSION_MAJOR >= 6
+using wxQtEnterEvent = QEnterEvent;
+#else
+using wxQtEnterEvent = QEvent;
+#endif
+
+class QPaintEvent;
+
+
+class wxQtSignalHandler
+{
+protected:
+    explicit wxQtSignalHandler( wxWindow *handler ) : m_handler(handler)
+    {
+    }
+
+    bool EmitEvent( wxEvent &event ) const
+    {
+        event.SetEventObject( m_handler );
+        return m_handler->HandleWindowEvent( event );
+    }
+
+    virtual wxWindow *GetHandler() const
+    {
+        return m_handler;
+    }
+
+    // A hack for wxQtEventSignalHandler<>::keyPressEvent() handler for the
+    // convenience of wxTextCtrl-like controls to emit the wxEVT_TEXT_ENTER
+    // event if the control has wxTE_PROCESS_ENTER flag.
+    bool HandleKeyPressEvent(QWidget* widget, QKeyEvent* e)
+    {
+        if ( m_handler->HasFlag(wxTE_PROCESS_ENTER) )
+        {
+            if ( e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )
+            {
+                wxCommandEvent event( wxEVT_TEXT_ENTER, m_handler->GetId() );
+                event.SetString( GetValueForProcessEnter() );
+                event.SetEventObject( m_handler );
+                return m_handler->HandleWindowEvent( event );
+            }
+        }
+
+        return m_handler->QtHandleKeyEvent(widget, e);
+    }
+
+    // Controls supporting wxTE_PROCESS_ENTER flag (e.g. wxTextCtrl, wxComboBox and wxSpinCtrl)
+    // should override this to return the control value as string when enter is pressed.
+    virtual wxString GetValueForProcessEnter() { return wxString(); }
+
+private:
+    wxWindow* const m_handler;
+};
+
+template < typename Widget, typename Handler >
+class wxQtEventSignalHandler : public Widget, public wxQtSignalHandler
+{
+public:
+    wxQtEventSignalHandler( wxWindow *parent, Handler *handler )
+        : Widget( parent != nullptr ? parent->GetHandle() : nullptr )
+        , wxQtSignalHandler( handler )
+    {
+        // Set immediately as it is used to check if wxWindow is alive
+        wxWindow::QtStoreWindowPointer( this, handler );
+
+        Widget::setMouseTracking(true);
+    }
+
+    virtual Handler *GetHandler() const override
+    {
+        // Only process the signal / event if the wxWindow is not destroyed
+        if ( !wxWindow::QtRetrieveWindowPointer( this ) )
+        {
+            return nullptr;
+        }
+        else
+            return static_cast<Handler*>(wxQtSignalHandler::GetHandler());
+    }
+
+protected:
+    /* Not implemented here: wxHelpEvent, wxIdleEvent wxJoystickEvent,
+     * wxMouseCaptureLostEvent, wxMouseCaptureChangedEvent,
+     * wxPowerEvent, wxScrollWinEvent, wxSysColourChangedEvent */
+
+    //wxActivateEvent
+    virtual void changeEvent ( QEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleChangeEvent(this, event) )
+            Widget::changeEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxCloseEvent
+    virtual void closeEvent ( QCloseEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleCloseEvent(this, event) )
+            Widget::closeEvent(event);
+        else
+            event->ignore();
+    }
+
+    //wxContextMenuEvent
+    virtual void contextMenuEvent ( QContextMenuEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        this->GetHandler()->QtHandleContextMenuEvent(this, event);
+
+        // Notice that we are simply accepting the event and deliberately not
+        // calling Widget::contextMenuEvent(event); here because the context menu
+        // is supposed to be shown from a wxEVT_CONTEXT_MENU handler and not from
+        // QWidget::contextMenuEvent() overrides (and we are already in one of
+        // these overrides to perform QContextMenuEvent --> wxContextMenuEvent
+        // translation).
+        // More importantly, the default implementation of contextMenuEvent() simply
+        // ignores the context event, which means that the event will be propagated
+        // to the parent widget again which is undesirable here because the event may
+        // have already been propagated at the wxWidgets level.
+
+        event->accept();
+    }
+
+    //wxDropFilesEvent
+    //virtual void dropEvent ( QDropEvent * event ) { }
+
+    //wxFocusEvent.
+    virtual void focusInEvent ( QFocusEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleFocusEvent(this, event) )
+            Widget::focusInEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxFocusEvent.
+    virtual void focusOutEvent ( QFocusEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleFocusEvent(this, event) )
+            Widget::focusOutEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxShowEvent
+    virtual void hideEvent ( QHideEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleShowEvent(this, event) )
+            Widget::hideEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxKeyEvent
+    virtual void keyPressEvent ( QKeyEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->HandleKeyPressEvent(this, event) )
+            Widget::keyPressEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxKeyEvent
+    virtual void keyReleaseEvent ( QKeyEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleKeyEvent(this, event) )
+            Widget::keyReleaseEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void enterEvent ( wxQtEnterEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleEnterEvent(this, event) )
+            Widget::enterEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void leaveEvent ( QEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleEnterEvent(this, event) )
+            Widget::leaveEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void mouseDoubleClickEvent ( QMouseEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
+            Widget::mouseDoubleClickEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void mouseMoveEvent ( QMouseEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
+            Widget::mouseMoveEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void mousePressEvent ( QMouseEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
+            Widget::mousePressEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void mouseReleaseEvent ( QMouseEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
+            Widget::mouseReleaseEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMoveEvent
+    virtual void moveEvent ( QMoveEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleMoveEvent(this, event) )
+            Widget::moveEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxEraseEvent then wxPaintEvent
+    virtual void paintEvent ( QPaintEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandlePaintEvent(this, event) )
+            Widget::paintEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxSizeEvent
+    virtual void resizeEvent ( QResizeEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleResizeEvent(this, event) )
+            Widget::resizeEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxShowEvent
+    virtual void showEvent ( QShowEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleShowEvent(this, event) )
+            Widget::showEvent(event);
+        else
+            event->accept();
+    }
+
+    //wxMouseEvent
+    virtual void wheelEvent ( QWheelEvent * event ) override
+    {
+        if ( !this->GetHandler() )
+            return;
+
+        if ( !this->GetHandler()->QtHandleWheelEvent(this, event) )
+            Widget::wheelEvent(event);
+        else
+            event->accept();
+    }
+
+    /* Unused Qt events
+    virtual void actionEvent ( QActionEvent * event ) { }
+    virtual void dragEnterEvent ( QDragEnterEvent * event ) { }
+    virtual void dragLeaveEvent ( QDragLeaveEvent * event ) { }
+    virtual void dragMoveEvent ( QDragMoveEvent * event ) { }
+    virtual void inputMethodEvent ( QInputMethodEvent * event ) { }
+    virtual bool macEvent ( EventHandlerCallRef caller, EventRef event ) { }
+    virtual bool qwsEvent ( QWSEvent * event ) { }
+    virtual void tabletEvent ( QTabletEvent * event ) { }
+    virtual bool winEvent ( MSG * message, long * result ) { }
+    virtual bool x11Event ( XEvent * event ) { } */
+
+    virtual bool event(QEvent *event) override
+    {
+        switch (event->type())
+        {
+            case QEvent::Gesture:
+                return gestureEvent(static_cast<QGestureEvent*>(event), event);
+
+            case QEvent::TouchBegin:
+            case QEvent::TouchUpdate:
+            case QEvent::TouchCancel:
+            case QEvent::TouchEnd:
+                return touchEvent(static_cast<QTouchEvent*>(event));
+            default:;
+        }
+
+        return Widget::event(event);
+    }
+
+    bool touchEvent(QTouchEvent *touch)
+    {
+        bool handled = false;
+
+        if ( wxWindow *win = wxWindow::QtRetrieveWindowPointer(this) )
+        {
+#if QT_VERSION_MAJOR >= 6
+            for (const auto& tp : touch->points())
+#else
+            for (const auto& tp : touch->touchPoints())
+#endif
+            {
+                wxEventType evtype = wxEVT_NULL;
+
+                switch (tp.state())
+                {
+                    case Qt::TouchPointPressed:
+                        evtype = wxEVT_TOUCH_BEGIN;
+                        break;
+
+                    case Qt::TouchPointMoved:
+                        evtype = wxEVT_TOUCH_MOVE;
+                        break;
+                    case Qt::TouchPointReleased:
+                        evtype = wxEVT_TOUCH_END;
+                        break;
+
+                    default:
+                        continue;
+                }
+
+                wxMultiTouchEvent evt(win->GetId(), evtype);
+
+                // Use screen position as the event might originate from a different
+                // Qt window than this one.
+#if QT_VERSION_MAJOR >= 6
+                const auto screenPos = tp.globalPosition();
+#else
+                const auto screenPos = tp.screenPos();
+#endif
+                wxPoint2DDouble pt = wxQtConvertPointF(screenPos.toPoint());
+                wxPoint ref = pt.GetFloor();
+
+                evt.SetPosition(win->ScreenToClient(ref) + (pt - ref));
+                evt.SetSequenceId(wxTouchSequenceId(wxUIntToPtr((unsigned)tp.id())));
+                // Qt doesn't provide the primary point flag
+
+                handled |= win->ProcessWindowEvent(evt);
+            }
+        }
+
+        return handled;
+    }
+
+    bool gestureEvent(QGestureEvent *gesture, QEvent *event)
+    {
+        if (QGesture *tah = gesture->gesture(Qt::TapAndHoldGesture))
+        {
+            //  Set the policy so that accepted gestures are taken by the first window that gets them
+            tah->setGestureCancelPolicy ( QGesture::CancelAllInContext );
+            tapandholdTriggered(static_cast<QTapAndHoldGesture *>(tah), event);
+        }
+
+        if (QGesture *pan = gesture->gesture(Qt::PanGesture))
+        {
+            panTriggered(static_cast<QPanGesture *>(pan), event);
+        }
+
+        if (QGesture *pinch = gesture->gesture(Qt::PinchGesture))
+        {
+            pinchTriggered(static_cast<QPinchGesture *>(pinch), event);
+        }
+
+        return true;
+    }
+
+    void tapandholdTriggered(QTapAndHoldGesture *gesture, QEvent *event)
+    {
+        if ( wxWindow *win = wxWindow::QtRetrieveWindowPointer( this ) )
+        {
+            if (gesture->state() == Qt::GestureFinished)
+            {
+                wxLongPressEvent ev(win->GetId());
+                ev.SetPosition( wxQtConvertPoint( gesture->position().toPoint() ) );
+
+                ev.SetGestureEnd();
+                win->ProcessWindowEvent( ev );
+            }
+            event->accept();
+        }
+    }
+
+    void panTriggered(QPanGesture *gesture, QEvent *event)
+    {
+        wxWindow *win = wxWindow::QtRetrieveWindowPointer( this );
+
+        if (win)
+        {
+            wxPanGestureEvent evp(win->GetId());
+            QPoint pos = QCursor::pos();
+            evp.SetPosition( wxQtConvertPoint( pos ) );
+            evp.SetDelta( wxQtConvertPoint( gesture->delta().toPoint() ) );
+
+            switch(gesture->state())
+            {
+                case Qt::GestureStarted:
+                    evp.SetGestureStart();
+                    break;
+                case Qt::GestureFinished:
+                case Qt::GestureCanceled:
+                    evp.SetGestureEnd();
+                    break;
+                default:
+                    break;
+            }
+
+            win->ProcessWindowEvent( evp );
+
+            event->accept();
+        }
+    }
+
+    void pinchTriggered(QPinchGesture *gesture, QEvent *event)
+    {
+        wxWindow *win = wxWindow::QtRetrieveWindowPointer( this );
+        if (win)
+        {
+            if (gesture->changeFlags() & QPinchGesture::ScaleFactorChanged)
+            {
+                wxZoomGestureEvent evp(win->GetId());
+                evp.SetPosition(wxQtConvertPoint(gesture->centerPoint().toPoint()));
+                evp.SetZoomFactor(gesture->totalScaleFactor());
+
+                switch (gesture->state())
+                {
+                case Qt::GestureStarted:
+                    evp.SetGestureStart();
+                    break;
+                case Qt::GestureFinished:
+                case Qt::GestureCanceled:
+                    evp.SetGestureEnd();
+                    break;
+                default:
+                    break;
+                }
+
+                win->ProcessWindowEvent(evp);
+            }
+
+            if (gesture->changeFlags() & QPinchGesture::RotationAngleChanged)
+            {
+                wxRotateGestureEvent evp(win->GetId());
+                evp.SetPosition(wxQtConvertPoint(gesture->centerPoint().toPoint()));
+                evp.SetRotationAngle(wxDegToRad(gesture->totalRotationAngle()));
+
+                switch (gesture->state())
+                {
+                case Qt::GestureStarted:
+                    evp.SetGestureStart();
+                    break;
+                case Qt::GestureFinished:
+                case Qt::GestureCanceled:
+                    evp.SetGestureEnd();
+                    break;
+                default:
+                    break;
+                }
+
+                win->ProcessWindowEvent(evp);
+            }
+
+            event->accept();
+        }
+    }
+};
+
+// RAII wrapper for blockSignals(). It blocks signals in its constructor and in
+// the destructor it restores the state to what it was before the constructor ran.
+class wxQtEnsureSignalsBlocked
+{
+public:
+    // Use QObject instead of QWidget to avoid including <QWidget> from here.
+    wxQtEnsureSignalsBlocked(QObject *widget) :
+        m_widget(widget)
+    {
+        m_restore = m_widget->blockSignals(true);
+    }
+
+    ~wxQtEnsureSignalsBlocked()
+    {
+        m_widget->blockSignals(m_restore);
+    }
+
+private:
+    QObject* const m_widget;
+    bool m_restore;
+
+    wxDECLARE_NO_COPY_CLASS(wxQtEnsureSignalsBlocked);
+};
+
+#endif