/****************************************************************************
** Meta object code from reading C++ file 'PDFDocumentView.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.10.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../../texworks-release-0.6.11/modules/QtPDF/src/PDFDocumentView.h"
#include <QtGui/qtextcursor.h>
#include <QtGui/qscreen.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QSharedPointer>
#include <QtCore/QWeakPointer>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'PDFDocumentView.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.10.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t {};
} // unnamed namespace

template <> constexpr inline auto QtPDF::PDFDocumentView::qt_create_metaobjectdata<qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QtPDF::PDFDocumentView",
        "changedPage",
        "",
        "QtPDF::PDFDocumentView::size_type",
        "pageNum",
        "changedZoom",
        "zoomLevel",
        "changedPageMode",
        "QtPDF::PDFDocumentView::PageMode",
        "newMode",
        "changedDocument",
        "QWeakPointer<QtPDF::Backend::Document>",
        "newDoc",
        "updated",
        "searchProgressChanged",
        "percent",
        "occurrences",
        "searchResultHighlighted",
        "QList<QPolygonF>",
        "region",
        "textSelectionChanged",
        "isTextSelected",
        "requestOpenUrl",
        "QUrl",
        "url",
        "requestExecuteCommand",
        "command",
        "requestOpenPdf",
        "filename",
        "QtPDF::PDFDestination",
        "destination",
        "newWindow",
        "contextClick",
        "page",
        "QPointF",
        "pos",
        "goPrev",
        "goNext",
        "goFirst",
        "goLast",
        "goPrevViewRect",
        "goToPage",
        "size_type",
        "alignment",
        "anchor",
        "goToPDFDestination",
        "PDFDestination",
        "dest",
        "saveOldViewRect",
        "setPageMode",
        "PageMode",
        "pageMode",
        "forceRelayout",
        "setSinglePageMode",
        "setOneColContPageMode",
        "setTwoColContPageMode",
        "setPresentationMode",
        "setMouseMode",
        "MouseMode",
        "setMouseModeMagnifyingGlass",
        "setMouseModeMove",
        "setMouseModeMarqueeZoom",
        "setMouseModeMeasure",
        "setMouseModeSelect",
        "setMagnifierShape",
        "DocumentTool::MagnifyingGlass::MagnifierShape",
        "shape",
        "setMagnifierSize",
        "size",
        "setUseGrayScale",
        "grayScale",
        "zoomBy",
        "zoomFactor",
        "QGraphicsView::ViewportAnchor",
        "zoomIn",
        "zoomOut",
        "zoomToRect",
        "QRectF",
        "a_rect",
        "zoomFitWindow",
        "zoomFitWidth",
        "zoomFitContentWidth",
        "zoom100",
        "setZoomLevel",
        "search",
        "searchText",
        "Backend::SearchFlags",
        "flags",
        "nextSearchResult",
        "previousSearchResult",
        "clearSearchResults",
        "armTool",
        "DocumentTool::AbstractTool::Type",
        "toolType",
        "disarmTool",
        "showRuler",
        "show",
        "maybeUpdateSceneRect",
        "maybeArmTool",
        "modifiers",
        "pdfActionTriggered",
        "const QtPDF::PDFAction*",
        "action",
        "const QtPDF::PDFPageGraphicsItem*",
        "view",
        "mayZoom",
        "searchResultReady",
        "PDFSearcher::size_type",
        "pageIndex",
        "searchProgressValueChanged",
        "progressValue",
        "reinitializeFromScene",
        "notifyTextSelectionChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'changedPage'
        QtMocHelpers::SignalData<void(QtPDF::PDFDocumentView::size_type)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'changedZoom'
        QtMocHelpers::SignalData<void(qreal)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 6 },
        }}),
        // Signal 'changedPageMode'
        QtMocHelpers::SignalData<void(QtPDF::PDFDocumentView::PageMode)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'changedDocument'
        QtMocHelpers::SignalData<void(const QWeakPointer<QtPDF::Backend::Document>)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Signal 'updated'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'searchProgressChanged'
        QtMocHelpers::SignalData<void(int, QtPDF::PDFDocumentView::size_type)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 15 }, { 0x80000000 | 3, 16 },
        }}),
        // Signal 'searchResultHighlighted'
        QtMocHelpers::SignalData<void(const QtPDF::PDFDocumentView::size_type, const QList<QPolygonF>)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 18, 19 },
        }}),
        // Signal 'textSelectionChanged'
        QtMocHelpers::SignalData<void(const bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 21 },
        }}),
        // Signal 'requestOpenUrl'
        QtMocHelpers::SignalData<void(const QUrl)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 },
        }}),
        // Signal 'requestExecuteCommand'
        QtMocHelpers::SignalData<void(QString)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 26 },
        }}),
        // Signal 'requestOpenPdf'
        QtMocHelpers::SignalData<void(QString, QtPDF::PDFDestination, bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 28 }, { 0x80000000 | 29, 30 }, { QMetaType::Bool, 31 },
        }}),
        // Signal 'contextClick'
        QtMocHelpers::SignalData<void(const QtPDF::PDFDocumentView::size_type, const QPointF)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 33 }, { 0x80000000 | 34, 35 },
        }}),
        // Slot 'goPrev'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goNext'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goFirst'
        QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goLast'
        QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goPrevViewRect'
        QtMocHelpers::SlotData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const size_type, const int)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 4 }, { QMetaType::Int, 43 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const size_type)>(41, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 42, 4 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const size_type, const QPointF, const int)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 4 }, { 0x80000000 | 34, 44 }, { QMetaType::Int, 43 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const size_type, const QPointF)>(41, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 42, 4 }, { 0x80000000 | 34, 44 },
        }}),
        // Slot 'goToPDFDestination'
        QtMocHelpers::SlotData<void(const PDFDestination &, bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 }, { QMetaType::Bool, 48 },
        }}),
        // Slot 'goToPDFDestination'
        QtMocHelpers::SlotData<void(const PDFDestination &)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Slot 'setPageMode'
        QtMocHelpers::SlotData<void(const PageMode, const bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 50, 51 }, { QMetaType::Bool, 52 },
        }}),
        // Slot 'setPageMode'
        QtMocHelpers::SlotData<void(const PageMode)>(49, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 50, 51 },
        }}),
        // Slot 'setSinglePageMode'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setOneColContPageMode'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setTwoColContPageMode'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setPresentationMode'
        QtMocHelpers::SlotData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMouseMode'
        QtMocHelpers::SlotData<void(const MouseMode)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 9 },
        }}),
        // Slot 'setMouseModeMagnifyingGlass'
        QtMocHelpers::SlotData<void()>(59, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMouseModeMove'
        QtMocHelpers::SlotData<void()>(60, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMouseModeMarqueeZoom'
        QtMocHelpers::SlotData<void()>(61, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMouseModeMeasure'
        QtMocHelpers::SlotData<void()>(62, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMouseModeSelect'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setMagnifierShape'
        QtMocHelpers::SlotData<void(const DocumentTool::MagnifyingGlass::MagnifierShape)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 66 },
        }}),
        // Slot 'setMagnifierSize'
        QtMocHelpers::SlotData<void(const int)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 68 },
        }}),
        // Slot 'setUseGrayScale'
        QtMocHelpers::SlotData<void(const bool)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 70 },
        }}),
        // Slot 'setUseGrayScale'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomBy'
        QtMocHelpers::SlotData<void(const qreal, const QGraphicsView::ViewportAnchor)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 72 }, { 0x80000000 | 73, 44 },
        }}),
        // Slot 'zoomBy'
        QtMocHelpers::SlotData<void(const qreal)>(71, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QReal, 72 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void(const QGraphicsView::ViewportAnchor)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 44 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void(const QGraphicsView::ViewportAnchor)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 44 },
        }}),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomToRect'
        QtMocHelpers::SlotData<void(QRectF)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 77, 78 },
        }}),
        // Slot 'zoomFitWindow'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoomFitWidth'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoomFitContentWidth'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoom100'
        QtMocHelpers::SlotData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setZoomLevel'
        QtMocHelpers::SlotData<void(const qreal, const QGraphicsView::ViewportAnchor)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 6 }, { 0x80000000 | 73, 44 },
        }}),
        // Slot 'setZoomLevel'
        QtMocHelpers::SlotData<void(const qreal)>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QReal, 6 },
        }}),
        // Slot 'search'
        QtMocHelpers::SlotData<void(QString, Backend::SearchFlags)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 85 }, { 0x80000000 | 86, 87 },
        }}),
        // Slot 'search'
        QtMocHelpers::SlotData<void(QString)>(84, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 85 },
        }}),
        // Slot 'nextSearchResult'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'previousSearchResult'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearSearchResults'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'armTool'
        QtMocHelpers::SlotData<void(const DocumentTool::AbstractTool::Type)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 93 },
        }}),
        // Slot 'disarmTool'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showRuler'
        QtMocHelpers::SlotData<void(const bool)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 96 },
        }}),
        // Slot 'showRuler'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'maybeUpdateSceneRect'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'maybeArmTool'
        QtMocHelpers::SlotData<void(uint)>(98, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::UInt, 99 },
        }}),
        // Slot 'pdfActionTriggered'
        QtMocHelpers::SlotData<void(const QtPDF::PDFAction *)>(100, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 101, 102 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *, const QRectF, const bool)>(41, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 103, 33 }, { 0x80000000 | 77, 104 }, { QMetaType::Bool, 105 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *, const QRectF)>(41, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 103, 33 }, { 0x80000000 | 77, 104 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *, const int)>(41, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 103, 33 }, { QMetaType::Int, 43 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *)>(41, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 103, 33 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *, const QPointF, const int)>(41, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 103, 33 }, { 0x80000000 | 34, 44 }, { QMetaType::Int, 43 },
        }}),
        // Slot 'goToPage'
        QtMocHelpers::SlotData<void(const QtPDF::PDFPageGraphicsItem *, const QPointF)>(41, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 103, 33 }, { 0x80000000 | 34, 44 },
        }}),
        // Slot 'searchResultReady'
        QtMocHelpers::SlotData<void(PDFSearcher::size_type)>(106, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 107, 108 },
        }}),
        // Slot 'searchProgressValueChanged'
        QtMocHelpers::SlotData<void(PDFSearcher::size_type)>(109, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 107, 110 },
        }}),
        // Slot 'reinitializeFromScene'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'notifyTextSelectionChanged'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PDFDocumentView, qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QtPDF::PDFDocumentView::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsView::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>.metaTypes,
    nullptr
} };

void QtPDF::PDFDocumentView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PDFDocumentView *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->changedPage((*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDocumentView::size_type>>(_a[1]))); break;
        case 1: _t->changedZoom((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 2: _t->changedPageMode((*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDocumentView::PageMode>>(_a[1]))); break;
        case 3: _t->changedDocument((*reinterpret_cast<std::add_pointer_t<QWeakPointer<QtPDF::Backend::Document>>>(_a[1]))); break;
        case 4: _t->updated(); break;
        case 5: _t->searchProgressChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDocumentView::size_type>>(_a[2]))); break;
        case 6: _t->searchResultHighlighted((*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDocumentView::size_type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QPolygonF>>>(_a[2]))); break;
        case 7: _t->textSelectionChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->requestOpenUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 9: _t->requestExecuteCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->requestOpenPdf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDestination>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 11: _t->contextClick((*reinterpret_cast<std::add_pointer_t<QtPDF::PDFDocumentView::size_type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 12: _t->goPrev(); break;
        case 13: _t->goNext(); break;
        case 14: _t->goFirst(); break;
        case 15: _t->goLast(); break;
        case 16: _t->goPrevViewRect(); break;
        case 17: _t->goToPage((*reinterpret_cast<std::add_pointer_t<size_type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 18: _t->goToPage((*reinterpret_cast<std::add_pointer_t<size_type>>(_a[1]))); break;
        case 19: _t->goToPage((*reinterpret_cast<std::add_pointer_t<size_type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 20: _t->goToPage((*reinterpret_cast<std::add_pointer_t<size_type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 21: _t->goToPDFDestination((*reinterpret_cast<std::add_pointer_t<PDFDestination>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 22: _t->goToPDFDestination((*reinterpret_cast<std::add_pointer_t<PDFDestination>>(_a[1]))); break;
        case 23: _t->setPageMode((*reinterpret_cast<std::add_pointer_t<enum PageMode>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 24: _t->setPageMode((*reinterpret_cast<std::add_pointer_t<enum PageMode>>(_a[1]))); break;
        case 25: _t->setSinglePageMode(); break;
        case 26: _t->setOneColContPageMode(); break;
        case 27: _t->setTwoColContPageMode(); break;
        case 28: _t->setPresentationMode(); break;
        case 29: _t->setMouseMode((*reinterpret_cast<std::add_pointer_t<enum MouseMode>>(_a[1]))); break;
        case 30: _t->setMouseModeMagnifyingGlass(); break;
        case 31: _t->setMouseModeMove(); break;
        case 32: _t->setMouseModeMarqueeZoom(); break;
        case 33: _t->setMouseModeMeasure(); break;
        case 34: _t->setMouseModeSelect(); break;
        case 35: _t->setMagnifierShape((*reinterpret_cast<std::add_pointer_t<DocumentTool::MagnifyingGlass::MagnifierShape>>(_a[1]))); break;
        case 36: _t->setMagnifierSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 37: _t->setUseGrayScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->setUseGrayScale(); break;
        case 39: _t->zoomBy((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QGraphicsView::ViewportAnchor>>(_a[2]))); break;
        case 40: _t->zoomBy((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 41: _t->zoomIn((*reinterpret_cast<std::add_pointer_t<QGraphicsView::ViewportAnchor>>(_a[1]))); break;
        case 42: _t->zoomIn(); break;
        case 43: _t->zoomOut((*reinterpret_cast<std::add_pointer_t<QGraphicsView::ViewportAnchor>>(_a[1]))); break;
        case 44: _t->zoomOut(); break;
        case 45: _t->zoomToRect((*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[1]))); break;
        case 46: _t->zoomFitWindow(); break;
        case 47: _t->zoomFitWidth(); break;
        case 48: _t->zoomFitContentWidth(); break;
        case 49: _t->zoom100(); break;
        case 50: _t->setZoomLevel((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QGraphicsView::ViewportAnchor>>(_a[2]))); break;
        case 51: _t->setZoomLevel((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 52: _t->search((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Backend::SearchFlags>>(_a[2]))); break;
        case 53: _t->search((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 54: _t->nextSearchResult(); break;
        case 55: _t->previousSearchResult(); break;
        case 56: _t->clearSearchResults(); break;
        case 57: _t->armTool((*reinterpret_cast<std::add_pointer_t<DocumentTool::AbstractTool::Type>>(_a[1]))); break;
        case 58: _t->disarmTool(); break;
        case 59: _t->showRuler((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 60: _t->showRuler(); break;
        case 61: _t->maybeUpdateSceneRect(); break;
        case 62: _t->maybeArmTool((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 63: _t->pdfActionTriggered((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFAction*>>(_a[1]))); break;
        case 64: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 65: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 66: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 67: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1]))); break;
        case 68: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 69: _t->goToPage((*reinterpret_cast<std::add_pointer_t<const QtPDF::PDFPageGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 70: _t->searchResultReady((*reinterpret_cast<std::add_pointer_t<PDFSearcher::size_type>>(_a[1]))); break;
        case 71: _t->searchProgressValueChanged((*reinterpret_cast<std::add_pointer_t<PDFSearcher::size_type>>(_a[1]))); break;
        case 72: _t->reinitializeFromScene(); break;
        case 73: _t->notifyTextSelectionChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(QtPDF::PDFDocumentView::size_type )>(_a, &PDFDocumentView::changedPage, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(qreal )>(_a, &PDFDocumentView::changedZoom, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(QtPDF::PDFDocumentView::PageMode )>(_a, &PDFDocumentView::changedPageMode, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(const QWeakPointer<QtPDF::Backend::Document> )>(_a, &PDFDocumentView::changedDocument, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)()>(_a, &PDFDocumentView::updated, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(int , QtPDF::PDFDocumentView::size_type )>(_a, &PDFDocumentView::searchProgressChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(const QtPDF::PDFDocumentView::size_type , const QList<QPolygonF> )>(_a, &PDFDocumentView::searchResultHighlighted, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(const bool )>(_a, &PDFDocumentView::textSelectionChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(const QUrl )>(_a, &PDFDocumentView::requestOpenUrl, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(QString )>(_a, &PDFDocumentView::requestExecuteCommand, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(QString , QtPDF::PDFDestination , bool )>(_a, &PDFDocumentView::requestOpenPdf, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (PDFDocumentView::*)(const QtPDF::PDFDocumentView::size_type , const QPointF )>(_a, &PDFDocumentView::contextClick, 11))
            return;
    }
}

const QMetaObject *QtPDF::PDFDocumentView::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QtPDF::PDFDocumentView::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF15PDFDocumentViewE_t>.strings))
        return static_cast<void*>(this);
    return QGraphicsView::qt_metacast(_clname);
}

int QtPDF::PDFDocumentView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QGraphicsView::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 74)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 74;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 74)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 74;
    }
    return _id;
}

// SIGNAL 0
void QtPDF::PDFDocumentView::changedPage(QtPDF::PDFDocumentView::size_type _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void QtPDF::PDFDocumentView::changedZoom(qreal _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void QtPDF::PDFDocumentView::changedPageMode(QtPDF::PDFDocumentView::PageMode _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void QtPDF::PDFDocumentView::changedDocument(const QWeakPointer<QtPDF::Backend::Document> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void QtPDF::PDFDocumentView::updated()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void QtPDF::PDFDocumentView::searchProgressChanged(int _t1, QtPDF::PDFDocumentView::size_type _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void QtPDF::PDFDocumentView::searchResultHighlighted(const QtPDF::PDFDocumentView::size_type _t1, const QList<QPolygonF> _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void QtPDF::PDFDocumentView::textSelectionChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void QtPDF::PDFDocumentView::requestOpenUrl(const QUrl _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void QtPDF::PDFDocumentView::requestExecuteCommand(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void QtPDF::PDFDocumentView::requestOpenPdf(QString _t1, QtPDF::PDFDestination _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3);
}

// SIGNAL 11
void QtPDF::PDFDocumentView::contextClick(const QtPDF::PDFDocumentView::size_type _t1, const QPointF _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t {};
} // unnamed namespace

template <> constexpr inline auto QtPDF::PDFDocumentMagnifierView::qt_create_metaobjectdata<qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QtPDF::PDFDocumentMagnifierView"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PDFDocumentMagnifierView, qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QtPDF::PDFDocumentMagnifierView::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsView::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>.metaTypes,
    nullptr
} };

void QtPDF::PDFDocumentMagnifierView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PDFDocumentMagnifierView *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *QtPDF::PDFDocumentMagnifierView::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QtPDF::PDFDocumentMagnifierView::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF24PDFDocumentMagnifierViewE_t>.strings))
        return static_cast<void*>(this);
    return QGraphicsView::qt_metacast(_clname);
}

int QtPDF::PDFDocumentMagnifierView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QGraphicsView::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t {};
} // unnamed namespace

template <> constexpr inline auto QtPDF::PDFPageGraphicsItem::qt_create_metaobjectdata<qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QtPDF::PDFPageGraphicsItem",
        "addLinks",
        "",
        "QList<QSharedPointer<Annotation::Link>>",
        "links",
        "addAnnotations",
        "QList<QSharedPointer<Annotation::AbstractAnnotation>>",
        "annotations"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'addLinks'
        QtMocHelpers::SlotData<void(QList<QSharedPointer<Annotation::Link> >)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'addAnnotations'
        QtMocHelpers::SlotData<void(QList<QSharedPointer<Annotation::AbstractAnnotation> >)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PDFPageGraphicsItem, qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QtPDF::PDFPageGraphicsItem::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>.metaTypes,
    nullptr
} };

void QtPDF::PDFPageGraphicsItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PDFPageGraphicsItem *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addLinks((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<Annotation::Link>>>>(_a[1]))); break;
        case 1: _t->addAnnotations((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<Annotation::AbstractAnnotation>>>>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject *QtPDF::PDFPageGraphicsItem::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QtPDF::PDFPageGraphicsItem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN5QtPDF19PDFPageGraphicsItemE_t>.strings))
        return static_cast<void*>(this);
    return QGraphicsObject::qt_metacast(_clname);
}

int QtPDF::PDFPageGraphicsItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QGraphicsObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}
QT_WARNING_POP
