//*****************************************************************************
// Copyright (c) 2024 Autodesk, Inc.
// All rights reserved.
//
// SPDX-License-Identifier: Apache-2.0
//
//*****************************************************************************

// IMPORTANT: This file (not the template) is auto-generated by qt2mu.py script.
//            The prefered way to do a fix is to handrolled it or modify the
//            qt2mu.py script. If it is not possible, manual editing is ok but
//            it could be lost in future generations.

#ifndef __MuQt6__QQuickItemType__h__
#define __MuQt6__QQuickItemType__h__
#include <iostream>
#include <Mu/Class.h>
#include <Mu/MuProcess.h>
#include <QtCore/QtCore>
#include <QtGui/QtGui>
#include <QtWidgets/QtWidgets>
#include <QtNetwork/QtNetwork>
#include <QtWebEngineWidgets/QtWebEngineWidgets>
#include <QtQml/QtQml>
#include <QtQuick/QtQuick>
#include <QtQuickWidgets/QtQuickWidgets>
#include <QtSvg/QtSvg>
#include <QSvgWidget>
#include <MuQt6/Bridge.h>

namespace Mu
{
    class MuQt_QQuickItem;

    class QQuickItemType : public Class
    {
    public:
        typedef MuQt_QQuickItem MuQtType;
        typedef QQuickItem QtType;

        //
        //  Constructors
        //

        QQuickItemType(Context* context, const char* name,
                       Class* superClass = 0, Class* superClass2 = 0);

        virtual ~QQuickItemType();

        static bool isInheritable() { return true; }

        static inline ClassInstance* cachedInstance(const MuQtType*);

        //
        //  Class API
        //

        virtual void load();

        MemberFunction* _func[33];
    };

    // Inheritable object

    class MuQt_QQuickItem : public QQuickItem
    {
    public:
        virtual ~MuQt_QQuickItem();
        MuQt_QQuickItem(Pointer muobj, const CallEnvironment*,
                        QQuickItem* parent);
        virtual QRectF boundingRect() const;
        virtual QRectF clipRect() const;
        virtual bool contains(const QPointF& point) const;
        virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
        virtual bool isTextureProvider() const;

    protected:
        virtual bool childMouseEventFilter(QQuickItem* item, QEvent* event);
        virtual void dragEnterEvent(QDragEnterEvent* event);
        virtual void dragLeaveEvent(QDragLeaveEvent* event);
        virtual void dragMoveEvent(QDragMoveEvent* event);
        virtual void dropEvent(QDropEvent* event);
        virtual void focusInEvent(QFocusEvent* _p14);
        virtual void focusOutEvent(QFocusEvent* _p14);
        virtual void geometryChange(const QRectF& newGeometry,
                                    const QRectF& oldGeometry);
        virtual void hoverEnterEvent(QHoverEvent* event);
        virtual void hoverLeaveEvent(QHoverEvent* event);
        virtual void hoverMoveEvent(QHoverEvent* event);
        virtual void keyPressEvent(QKeyEvent* event);
        virtual void keyReleaseEvent(QKeyEvent* event);
        virtual void mouseDoubleClickEvent(QMouseEvent* event);
        virtual void mouseMoveEvent(QMouseEvent* event);
        virtual void mousePressEvent(QMouseEvent* event);
        virtual void mouseReleaseEvent(QMouseEvent* event);
        virtual void mouseUngrabEvent();
        virtual void releaseResources();
        virtual void touchUngrabEvent();
        virtual void updatePolish();
        virtual void wheelEvent(QWheelEvent* event);
        virtual void classBegin();
        virtual void componentComplete();
        virtual bool event(QEvent* ev);

    public:
        virtual bool eventFilter(QObject* watched, QEvent* event);

    protected:
        virtual void customEvent(QEvent* event);
        virtual void timerEvent(QTimerEvent* event);

    public:
        bool childMouseEventFilter_pub(QQuickItem* item, QEvent* event)
        {
            return childMouseEventFilter(item, event);
        }

        bool childMouseEventFilter_pub_parent(QQuickItem* item, QEvent* event)
        {
            return QQuickItem::childMouseEventFilter(item, event);
        }

        void dragEnterEvent_pub(QDragEnterEvent* event)
        {
            dragEnterEvent(event);
        }

        void dragEnterEvent_pub_parent(QDragEnterEvent* event)
        {
            QQuickItem::dragEnterEvent(event);
        }

        void dragLeaveEvent_pub(QDragLeaveEvent* event)
        {
            dragLeaveEvent(event);
        }

        void dragLeaveEvent_pub_parent(QDragLeaveEvent* event)
        {
            QQuickItem::dragLeaveEvent(event);
        }

        void dragMoveEvent_pub(QDragMoveEvent* event) { dragMoveEvent(event); }

        void dragMoveEvent_pub_parent(QDragMoveEvent* event)
        {
            QQuickItem::dragMoveEvent(event);
        }

        void dropEvent_pub(QDropEvent* event) { dropEvent(event); }

        void dropEvent_pub_parent(QDropEvent* event)
        {
            QQuickItem::dropEvent(event);
        }

        void focusInEvent_pub(QFocusEvent* _p14) { focusInEvent(_p14); }

        void focusInEvent_pub_parent(QFocusEvent* _p14)
        {
            QQuickItem::focusInEvent(_p14);
        }

        void focusOutEvent_pub(QFocusEvent* _p14) { focusOutEvent(_p14); }

        void focusOutEvent_pub_parent(QFocusEvent* _p14)
        {
            QQuickItem::focusOutEvent(_p14);
        }

        void geometryChange_pub(const QRectF& newGeometry,
                                const QRectF& oldGeometry)
        {
            geometryChange(newGeometry, oldGeometry);
        }

        void geometryChange_pub_parent(const QRectF& newGeometry,
                                       const QRectF& oldGeometry)
        {
            QQuickItem::geometryChange(newGeometry, oldGeometry);
        }

        bool heightValid_pub() const { return heightValid(); }

        bool heightValid_pub_parent() const
        {
            return QQuickItem::heightValid();
        }

        void hoverEnterEvent_pub(QHoverEvent* event) { hoverEnterEvent(event); }

        void hoverEnterEvent_pub_parent(QHoverEvent* event)
        {
            QQuickItem::hoverEnterEvent(event);
        }

        void hoverLeaveEvent_pub(QHoverEvent* event) { hoverLeaveEvent(event); }

        void hoverLeaveEvent_pub_parent(QHoverEvent* event)
        {
            QQuickItem::hoverLeaveEvent(event);
        }

        void hoverMoveEvent_pub(QHoverEvent* event) { hoverMoveEvent(event); }

        void hoverMoveEvent_pub_parent(QHoverEvent* event)
        {
            QQuickItem::hoverMoveEvent(event);
        }

        bool isComponentComplete_pub() const { return isComponentComplete(); }

        bool isComponentComplete_pub_parent() const
        {
            return QQuickItem::isComponentComplete();
        }

        void keyPressEvent_pub(QKeyEvent* event) { keyPressEvent(event); }

        void keyPressEvent_pub_parent(QKeyEvent* event)
        {
            QQuickItem::keyPressEvent(event);
        }

        void keyReleaseEvent_pub(QKeyEvent* event) { keyReleaseEvent(event); }

        void keyReleaseEvent_pub_parent(QKeyEvent* event)
        {
            QQuickItem::keyReleaseEvent(event);
        }

        void mouseDoubleClickEvent_pub(QMouseEvent* event)
        {
            mouseDoubleClickEvent(event);
        }

        void mouseDoubleClickEvent_pub_parent(QMouseEvent* event)
        {
            QQuickItem::mouseDoubleClickEvent(event);
        }

        void mouseMoveEvent_pub(QMouseEvent* event) { mouseMoveEvent(event); }

        void mouseMoveEvent_pub_parent(QMouseEvent* event)
        {
            QQuickItem::mouseMoveEvent(event);
        }

        void mousePressEvent_pub(QMouseEvent* event) { mousePressEvent(event); }

        void mousePressEvent_pub_parent(QMouseEvent* event)
        {
            QQuickItem::mousePressEvent(event);
        }

        void mouseReleaseEvent_pub(QMouseEvent* event)
        {
            mouseReleaseEvent(event);
        }

        void mouseReleaseEvent_pub_parent(QMouseEvent* event)
        {
            QQuickItem::mouseReleaseEvent(event);
        }

        void mouseUngrabEvent_pub() { mouseUngrabEvent(); }

        void mouseUngrabEvent_pub_parent() { QQuickItem::mouseUngrabEvent(); }

        void releaseResources_pub() { releaseResources(); }

        void releaseResources_pub_parent() { QQuickItem::releaseResources(); }

        void touchUngrabEvent_pub() { touchUngrabEvent(); }

        void touchUngrabEvent_pub_parent() { QQuickItem::touchUngrabEvent(); }

        void updateInputMethod_pub(Qt::InputMethodQueries queries)
        {
            updateInputMethod(queries);
        }

        void updateInputMethod_pub_parent(Qt::InputMethodQueries queries)
        {
            QQuickItem::updateInputMethod(queries);
        }

        void updatePolish_pub() { updatePolish(); }

        void updatePolish_pub_parent() { QQuickItem::updatePolish(); }

        void wheelEvent_pub(QWheelEvent* event) { wheelEvent(event); }

        void wheelEvent_pub_parent(QWheelEvent* event)
        {
            QQuickItem::wheelEvent(event);
        }

        bool widthValid_pub() const { return widthValid(); }

        bool widthValid_pub_parent() const { return QQuickItem::widthValid(); }

        void classBegin_pub() { classBegin(); }

        void classBegin_pub_parent() { QQuickItem::classBegin(); }

        void componentComplete_pub() { componentComplete(); }

        void componentComplete_pub_parent() { QQuickItem::componentComplete(); }

        bool event_pub(QEvent* ev) { return event(ev); }

        bool event_pub_parent(QEvent* ev) { return QQuickItem::event(ev); }

        void customEvent_pub(QEvent* event) { customEvent(event); }

        void customEvent_pub_parent(QEvent* event)
        {
            QQuickItem::customEvent(event);
        }

        void timerEvent_pub(QTimerEvent* event) { timerEvent(event); }

        void timerEvent_pub_parent(QTimerEvent* event)
        {
            QQuickItem::timerEvent(event);
        }

    public:
        const QQuickItemType* _baseType;
        ClassInstance* _obj;
        const CallEnvironment* _env;
    };

    inline ClassInstance*
    QQuickItemType::cachedInstance(const QQuickItemType::MuQtType* obj)
    {
        return obj->_obj;
    }

} // namespace Mu

#endif // __MuQt__QQuickItemType__h__
