//*****************************************************************************
// 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__QAbstractItemViewType__h__
#define __MuQt6__QAbstractItemViewType__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_QAbstractItemView;

    class QAbstractItemViewType : public Class
    {
    public:
        typedef MuQt_QAbstractItemView MuQtType;
        typedef QAbstractItemView QtType;

        //
        //  Constructors
        //

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

        virtual ~QAbstractItemViewType();

        static bool isInheritable() { return true; }

        static inline ClassInstance* cachedInstance(const MuQtType*);

        //
        //  Class API
        //

        virtual void load();

        MemberFunction* _func[44];
    };

    // Inheritable object

    class MuQt_QAbstractItemView : public QAbstractItemView
    {
    public:
        virtual ~MuQt_QAbstractItemView();
        MuQt_QAbstractItemView(Pointer muobj, const CallEnvironment*,
                               QWidget* parent);
        virtual QModelIndex indexAt(const QPoint& point) const;
        virtual void keyboardSearch(const QString& search);
        virtual void scrollTo(const QModelIndex& index,
                              QAbstractItemView::ScrollHint hint);
        virtual void setModel(QAbstractItemModel* model);
        virtual void setSelectionModel(QItemSelectionModel* selectionModel);
        virtual int sizeHintForColumn(int column) const;
        virtual int sizeHintForRow(int row) const;
        virtual QRect visualRect(const QModelIndex& index) const;
        virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;

    protected:
        virtual bool edit(const QModelIndex& index,
                          QAbstractItemView::EditTrigger trigger,
                          QEvent* event);
        virtual int horizontalOffset() const;
        virtual bool isIndexHidden(const QModelIndex& index) const;
        virtual QModelIndex
        moveCursor(QAbstractItemView::CursorAction cursorAction,
                   Qt::KeyboardModifiers modifiers);
        virtual QModelIndexList selectedIndexes() const;
        virtual QItemSelectionModel::SelectionFlags
        selectionCommand(const QModelIndex& index, const QEvent* event) const;
        virtual void setSelection(const QRect& rect,
                                  QItemSelectionModel::SelectionFlags flags);
        virtual void startDrag(Qt::DropActions supportedActions);
        virtual int verticalOffset() const;
        virtual QRegion
        visualRegionForSelection(const QItemSelection& selection) const;
        virtual void dragEnterEvent(QDragEnterEvent* event);
        virtual void dragLeaveEvent(QDragLeaveEvent* event);
        virtual void dragMoveEvent(QDragMoveEvent* event);
        virtual void dropEvent(QDropEvent* event);
        virtual bool event(QEvent* event_);
        virtual bool eventFilter(QObject* object, QEvent* event);
        virtual void focusInEvent(QFocusEvent* event);
        virtual bool focusNextPrevChild(bool next);
        virtual void focusOutEvent(QFocusEvent* event);
        virtual void keyPressEvent(QKeyEvent* event);
        virtual void mouseDoubleClickEvent(QMouseEvent* event);
        virtual void mouseMoveEvent(QMouseEvent* event);
        virtual void mousePressEvent(QMouseEvent* event);
        virtual void mouseReleaseEvent(QMouseEvent* event);
        virtual void resizeEvent(QResizeEvent* event);
        virtual void timerEvent(QTimerEvent* event);
        virtual bool viewportEvent(QEvent* event);
        virtual QSize viewportSizeHint() const;

    public:
        virtual void setupViewport(QWidget* viewport);
        virtual QSize minimumSizeHint() const;
        virtual QSize sizeHint() const;

    protected:
        virtual void scrollContentsBy(int dx, int dy);
        virtual void contextMenuEvent(QContextMenuEvent* e);
        virtual void paintEvent(QPaintEvent* event);
        virtual void wheelEvent(QWheelEvent* e);

    public:
        QPoint dirtyRegionOffset_pub() const { return dirtyRegionOffset(); }

        QPoint dirtyRegionOffset_pub_parent() const
        {
            return QAbstractItemView::dirtyRegionOffset();
        }

        QAbstractItemView::DropIndicatorPosition
        dropIndicatorPosition_pub() const
        {
            return dropIndicatorPosition();
        }

        QAbstractItemView::DropIndicatorPosition
        dropIndicatorPosition_pub_parent() const
        {
            return QAbstractItemView::dropIndicatorPosition();
        }

        bool edit_pub(const QModelIndex& index,
                      QAbstractItemView::EditTrigger trigger, QEvent* event)
        {
            return edit(index, trigger, event);
        }

        bool edit_pub_parent(const QModelIndex& index,
                             QAbstractItemView::EditTrigger trigger,
                             QEvent* event)
        {
            return QAbstractItemView::edit(index, trigger, event);
        }

        void executeDelayedItemsLayout_pub() { executeDelayedItemsLayout(); }

        void executeDelayedItemsLayout_pub_parent()
        {
            QAbstractItemView::executeDelayedItemsLayout();
        }

        int horizontalOffset_pub() const { return horizontalOffset(); }

        int horizontalOffset_pub_parent() const
        {
            return QAbstractItemView::horizontalOffset();
        }

        bool isIndexHidden_pub(const QModelIndex& index) const
        {
            return isIndexHidden(index);
        }

        bool isIndexHidden_pub_parent(const QModelIndex& index) const
        {
            return QAbstractItemView::isIndexHidden(index);
        }

        QModelIndex moveCursor_pub(MuQtPublicEnum cursorAction,
                                   Qt::KeyboardModifiers modifiers)
        {
            return moveCursor((QAbstractItemView::CursorAction)cursorAction,
                              modifiers);
        }

        QModelIndex moveCursor_pub_parent(MuQtPublicEnum cursorAction,
                                          Qt::KeyboardModifiers modifiers)
        {
            return QAbstractItemView::moveCursor(
                (QAbstractItemView::CursorAction)cursorAction, modifiers);
        }

        void scheduleDelayedItemsLayout_pub() { scheduleDelayedItemsLayout(); }

        void scheduleDelayedItemsLayout_pub_parent()
        {
            QAbstractItemView::scheduleDelayedItemsLayout();
        }

        void scrollDirtyRegion_pub(int dx, int dy)
        {
            scrollDirtyRegion(dx, dy);
        }

        void scrollDirtyRegion_pub_parent(int dx, int dy)
        {
            QAbstractItemView::scrollDirtyRegion(dx, dy);
        }

        QModelIndexList selectedIndexes_pub() const
        {
            return selectedIndexes();
        }

        QModelIndexList selectedIndexes_pub_parent() const
        {
            return QAbstractItemView::selectedIndexes();
        }

        QItemSelectionModel::SelectionFlags
        selectionCommand_pub(const QModelIndex& index,
                             const QEvent* event) const
        {
            return selectionCommand(index, event);
        }

        QItemSelectionModel::SelectionFlags
        selectionCommand_pub_parent(const QModelIndex& index,
                                    const QEvent* event) const
        {
            return QAbstractItemView::selectionCommand(index, event);
        }

        void setDirtyRegion_pub(const QRegion& region)
        {
            setDirtyRegion(region);
        }

        void setDirtyRegion_pub_parent(const QRegion& region)
        {
            QAbstractItemView::setDirtyRegion(region);
        }

        void setSelection_pub(const QRect& rect,
                              QItemSelectionModel::SelectionFlags flags)
        {
            setSelection(rect, flags);
        }

        void setSelection_pub_parent(const QRect& rect,
                                     QItemSelectionModel::SelectionFlags flags)
        {
            QAbstractItemView::setSelection(rect, flags);
        }

        void setState_pub(MuQtPublicEnum state)
        {
            setState((QAbstractItemView::State)state);
        }

        void setState_pub_parent(MuQtPublicEnum state)
        {
            QAbstractItemView::setState((QAbstractItemView::State)state);
        }

        void startDrag_pub(Qt::DropActions supportedActions)
        {
            startDrag(supportedActions);
        }

        void startDrag_pub_parent(Qt::DropActions supportedActions)
        {
            QAbstractItemView::startDrag(supportedActions);
        }

        QAbstractItemView::State state_pub() const { return state(); }

        QAbstractItemView::State state_pub_parent() const
        {
            return QAbstractItemView::state();
        }

        int verticalOffset_pub() const { return verticalOffset(); }

        int verticalOffset_pub_parent() const
        {
            return QAbstractItemView::verticalOffset();
        }

        QRegion
        visualRegionForSelection_pub(const QItemSelection& selection) const
        {
            return visualRegionForSelection(selection);
        }

        QRegion visualRegionForSelection_pub_parent(
            const QItemSelection& selection) const
        {
            return QAbstractItemView::visualRegionForSelection(selection);
        }

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

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

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

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

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

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

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

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

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

        bool event_pub_parent(QEvent* event_)
        {
            return QAbstractItemView::event(event_);
        }

        bool eventFilter_pub(QObject* object, QEvent* event)
        {
            return eventFilter(object, event);
        }

        bool eventFilter_pub_parent(QObject* object, QEvent* event)
        {
            return QAbstractItemView::eventFilter(object, event);
        }

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

        void focusInEvent_pub_parent(QFocusEvent* event)
        {
            QAbstractItemView::focusInEvent(event);
        }

        bool focusNextPrevChild_pub(bool next)
        {
            return focusNextPrevChild(next);
        }

        bool focusNextPrevChild_pub_parent(bool next)
        {
            return QAbstractItemView::focusNextPrevChild(next);
        }

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

        void focusOutEvent_pub_parent(QFocusEvent* event)
        {
            QAbstractItemView::focusOutEvent(event);
        }

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

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

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

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

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

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

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

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

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

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

        void resizeEvent_pub(QResizeEvent* event) { resizeEvent(event); }

        void resizeEvent_pub_parent(QResizeEvent* event)
        {
            QAbstractItemView::resizeEvent(event);
        }

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

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

        bool viewportEvent_pub(QEvent* event) { return viewportEvent(event); }

        bool viewportEvent_pub_parent(QEvent* event)
        {
            return QAbstractItemView::viewportEvent(event);
        }

        QSize viewportSizeHint_pub() const { return viewportSizeHint(); }

        QSize viewportSizeHint_pub_parent() const
        {
            return QAbstractItemView::viewportSizeHint();
        }

        void scrollContentsBy_pub(int dx, int dy) { scrollContentsBy(dx, dy); }

        void scrollContentsBy_pub_parent(int dx, int dy)
        {
            QAbstractItemView::scrollContentsBy(dx, dy);
        }

        void contextMenuEvent_pub(QContextMenuEvent* e) { contextMenuEvent(e); }

        void contextMenuEvent_pub_parent(QContextMenuEvent* e)
        {
            QAbstractItemView::contextMenuEvent(e);
        }

        void paintEvent_pub(QPaintEvent* event) { paintEvent(event); }

        void paintEvent_pub_parent(QPaintEvent* event)
        {
            QAbstractItemView::paintEvent(event);
        }

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

        void wheelEvent_pub_parent(QWheelEvent* e)
        {
            QAbstractItemView::wheelEvent(e);
        }

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

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

} // namespace Mu

#endif // __MuQt__QAbstractItemViewType__h__
