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

#include "../../../../labplot-2.12.1/src/backend/worksheet/plots/cartesian/CartesianPlot.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'CartesianPlot.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN13CartesianPlotE_t {};
} // unnamed namespace

template <> constexpr inline auto CartesianPlot::qt_create_metaobjectdata<qt_meta_tag_ZN13CartesianPlotE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CartesianPlot",
        "rangeTypeChanged",
        "",
        "CartesianPlot::RangeType",
        "niceExtendChanged",
        "rangeFormatChanged",
        "Dimension",
        "rangeIndex",
        "RangeT::Format",
        "rangeLastValuesChanged",
        "rangeFirstValuesChanged",
        "rectChanged",
        "QRectF&",
        "autoScaleChanged",
        "xRangeIndex",
        "rangeChanged",
        "Range<double>",
        "minChanged",
        "maxChanged",
        "scaleChanged",
        "RangeT::Scale",
        "defaultCoordinateSystemIndexChanged",
        "xRangeBreakingEnabledChanged",
        "xRangeBreaksChanged",
        "CartesianPlot::RangeBreaks",
        "yRangeBreakingEnabledChanged",
        "yRangeBreaksChanged",
        "themeChanged",
        "axisShiftSignal",
        "delta",
        "dim",
        "index",
        "mousePressZoomSelectionModeSignal",
        "QPointF",
        "logicPos",
        "mousePressCursorModeSignal",
        "cursorNumber",
        "mouseMoveSelectionModeSignal",
        "logicalStart",
        "logicalEnd",
        "mouseMoveZoomSelectionModeSignal",
        "mouseMoveCursorModeSignal",
        "mouseReleaseCursorModeSignal",
        "mouseReleaseZoomSelectionModeSignal",
        "mouseHoverZoomSelectionModeSignal",
        "logicalPoint",
        "mouseHoverOutsideDataRectSignal",
        "wheelEventSignal",
        "sceneRelPos",
        "xIndex",
        "yIndex",
        "considerDimension",
        "curveNameChanged",
        "const AbstractAspect*",
        "curve",
        "cursorPosChanged",
        "xPos",
        "curveAdded",
        "const XYCurve*",
        "curveRemoved",
        "plotColorChanged",
        "QColor",
        "curveName",
        "cursorPenChanged",
        "QPen",
        "curveDataChanged",
        "curveVisibilityChangedSignal",
        "mouseModeChanged",
        "CartesianPlot::MouseMode",
        "cursor0EnableChanged",
        "enable",
        "cursor1EnableChanged",
        "scaleRetransformed",
        "const CartesianPlot*",
        "setTheme",
        "retransform",
        "addHistogramFit",
        "Histogram*",
        "nsl_sf_stats_distribution",
        "addLegend",
        "scaleAuto",
        "fullRange",
        "suppressRetransformScale",
        "zoomIn",
        "zoomOut",
        "zoomInX",
        "zoomOutX",
        "zoomInY",
        "zoomOutY",
        "zoomInOut",
        "relScenePosRange",
        "shiftLeftX",
        "shiftRightX",
        "shiftUpY",
        "shiftDownY",
        "shift",
        "leftOrDown",
        "cursor",
        "dataChanged",
        "WorksheetElement*",
        "sender",
        "addPlot",
        "QAction*",
        "addDataReductionCurve",
        "addDifferentiationCurve",
        "addIntegrationCurve",
        "addInterpolationCurve",
        "addSmoothCurve",
        "addFitCurve",
        "addFourierFilterCurve",
        "addFunctionCurve",
        "addHorizontalAxis",
        "addVerticalAxis",
        "addTextLabel",
        "addImage",
        "addCustomPoint",
        "addReferenceLine",
        "addReferenceRange",
        "addInfoElement",
        "updateLegend",
        "childAdded",
        "childRemoved",
        "parent",
        "before",
        "child",
        "childHovered",
        "Plot*",
        "curveVisibilityChanged",
        "boxPlotOrientationChanged",
        "WorksheetElement::Orientation",
        "loadTheme",
        "RangeType",
        "Free",
        "Last",
        "First"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'rangeTypeChanged'
        QtMocHelpers::SignalData<void(CartesianPlot::RangeType)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'niceExtendChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'rangeFormatChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, RangeT::Format)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 7 }, { 0x80000000 | 8, 2 },
        }}),
        // Signal 'rangeLastValuesChanged'
        QtMocHelpers::SignalData<void(int)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'rangeFirstValuesChanged'
        QtMocHelpers::SignalData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'rectChanged'
        QtMocHelpers::SignalData<void(QRectF &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 2 },
        }}),
        // Signal 'autoScaleChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 14 }, { QMetaType::Bool, 2 },
        }}),
        // Signal 'rangeChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, Range<double>)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 2 }, { 0x80000000 | 16, 2 },
        }}),
        // Signal 'minChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, double)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 7 }, { QMetaType::Double, 2 },
        }}),
        // Signal 'maxChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, double)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 7 }, { QMetaType::Double, 2 },
        }}),
        // Signal 'scaleChanged'
        QtMocHelpers::SignalData<void(const Dimension, int, RangeT::Scale)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 7 }, { 0x80000000 | 20, 2 },
        }}),
        // Signal 'defaultCoordinateSystemIndexChanged'
        QtMocHelpers::SignalData<void(int)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'xRangeBreakingEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'xRangeBreaksChanged'
        QtMocHelpers::SignalData<void(const CartesianPlot::RangeBreaks &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 2 },
        }}),
        // Signal 'yRangeBreakingEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'yRangeBreaksChanged'
        QtMocHelpers::SignalData<void(const CartesianPlot::RangeBreaks &)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 2 },
        }}),
        // Signal 'themeChanged'
        QtMocHelpers::SignalData<void(const QString &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'axisShiftSignal'
        QtMocHelpers::SignalData<void(int, Dimension, int)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 29 }, { 0x80000000 | 6, 30 }, { QMetaType::Int, 31 },
        }}),
        // Signal 'mousePressZoomSelectionModeSignal'
        QtMocHelpers::SignalData<void(QPointF)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Signal 'mousePressCursorModeSignal'
        QtMocHelpers::SignalData<void(int, QPointF)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { 0x80000000 | 33, 34 },
        }}),
        // Signal 'mouseMoveSelectionModeSignal'
        QtMocHelpers::SignalData<void(QPointF, QPointF)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 38 }, { 0x80000000 | 33, 39 },
        }}),
        // Signal 'mouseMoveZoomSelectionModeSignal'
        QtMocHelpers::SignalData<void(QPointF)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Signal 'mouseMoveCursorModeSignal'
        QtMocHelpers::SignalData<void(int, QPointF)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { 0x80000000 | 33, 34 },
        }}),
        // Signal 'mouseReleaseCursorModeSignal'
        QtMocHelpers::SignalData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mouseReleaseZoomSelectionModeSignal'
        QtMocHelpers::SignalData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mouseHoverZoomSelectionModeSignal'
        QtMocHelpers::SignalData<void(QPointF)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 45 },
        }}),
        // Signal 'mouseHoverOutsideDataRectSignal'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'wheelEventSignal'
        QtMocHelpers::SignalData<void(const QPointF &, int, int, int, bool, Dimension)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 48 }, { QMetaType::Int, 29 }, { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
            { QMetaType::Bool, 51 }, { 0x80000000 | 6, 30 },
        }}),
        // Signal 'curveNameChanged'
        QtMocHelpers::SignalData<void(const AbstractAspect *)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 53, 54 },
        }}),
        // Signal 'cursorPosChanged'
        QtMocHelpers::SignalData<void(int, double)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { QMetaType::Double, 56 },
        }}),
        // Signal 'curveAdded'
        QtMocHelpers::SignalData<void(const XYCurve *)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 2 },
        }}),
        // Signal 'curveRemoved'
        QtMocHelpers::SignalData<void(const XYCurve *)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 2 },
        }}),
        // Signal 'plotColorChanged'
        QtMocHelpers::SignalData<void(const QColor &, const QString &)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 61, 2 }, { QMetaType::QString, 62 },
        }}),
        // Signal 'cursorPenChanged'
        QtMocHelpers::SignalData<void(QPen)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 64, 2 },
        }}),
        // Signal 'curveDataChanged'
        QtMocHelpers::SignalData<void(const XYCurve *)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 2 },
        }}),
        // Signal 'curveVisibilityChangedSignal'
        QtMocHelpers::SignalData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mouseModeChanged'
        QtMocHelpers::SignalData<void(CartesianPlot::MouseMode)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 2 },
        }}),
        // Signal 'cursor0EnableChanged'
        QtMocHelpers::SignalData<void(bool)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 70 },
        }}),
        // Signal 'cursor1EnableChanged'
        QtMocHelpers::SignalData<void(bool)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 70 },
        }}),
        // Signal 'scaleRetransformed'
        QtMocHelpers::SignalData<void(const CartesianPlot *, const Dimension, int)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 2 }, { 0x80000000 | 6, 2 }, { QMetaType::Int, 31 },
        }}),
        // Slot 'setTheme'
        QtMocHelpers::SlotData<void(const QString &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'retransform'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addHistogramFit'
        QtMocHelpers::SlotData<void(Histogram *, nsl_sf_stats_distribution)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 77, 2 }, { 0x80000000 | 78, 2 },
        }}),
        // Slot 'addLegend'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(int, int, bool, bool)>(80, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { QMetaType::Bool, 81 }, { QMetaType::Bool, 82 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(int, int, bool)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { QMetaType::Bool, 81 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(int, int)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(int)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 49 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool()>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(const Dimension, int, bool, bool)>(80, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 31 }, { QMetaType::Bool, 81 }, { QMetaType::Bool, 82 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(const Dimension, int, bool)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 31 }, { QMetaType::Bool, 81 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(const Dimension, int)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 6, 2 }, { QMetaType::Int, 31 },
        }}),
        // Slot 'scaleAuto'
        QtMocHelpers::SlotData<bool(const Dimension)>(80, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { 0x80000000 | 6, 2 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void(int, int, const QPointF &)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { 0x80000000 | 33, 48 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void(int, int)>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void(int)>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void(int, int, const QPointF &)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { 0x80000000 | 33, 48 },
        }}),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void(int, int)>(84, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
        }}),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void(int)>(84, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomInX'
        QtMocHelpers::SlotData<void(int)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'zoomInX'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomOutX'
        QtMocHelpers::SlotData<void(int)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'zoomOutX'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomInY'
        QtMocHelpers::SlotData<void(int)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'zoomInY'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomOutY'
        QtMocHelpers::SlotData<void(int)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'zoomOutY'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomInOut'
        QtMocHelpers::SlotData<void(const int, const Dimension, const bool, const double)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 }, { 0x80000000 | 6, 30 }, { QMetaType::Bool, 83 }, { QMetaType::Double, 90 },
        }}),
        // Slot 'zoomInOut'
        QtMocHelpers::SlotData<void(const int, const Dimension, const bool)>(89, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 31 }, { 0x80000000 | 6, 30 }, { QMetaType::Bool, 83 },
        }}),
        // Slot 'shiftLeftX'
        QtMocHelpers::SlotData<void(int)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'shiftLeftX'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'shiftRightX'
        QtMocHelpers::SlotData<void(int)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'shiftRightX'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'shiftUpY'
        QtMocHelpers::SlotData<void(int)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'shiftUpY'
        QtMocHelpers::SlotData<void()>(93, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'shiftDownY'
        QtMocHelpers::SlotData<void(int)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'shiftDownY'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'shift'
        QtMocHelpers::SlotData<void(int, const Dimension, bool)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 }, { 0x80000000 | 6, 2 }, { QMetaType::Bool, 96 },
        }}),
        // Slot 'cursor'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void(int, int, WorksheetElement *)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { 0x80000000 | 99, 100 },
        }}),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void(int, int)>(98, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
        }}),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void(int)>(98, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addPlot'
        QtMocHelpers::SlotData<void(QAction *)>(101, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 102, 2 },
        }}),
        // Slot 'addDataReductionCurve'
        QtMocHelpers::SlotData<void()>(103, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addDifferentiationCurve'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addIntegrationCurve'
        QtMocHelpers::SlotData<void()>(105, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addInterpolationCurve'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addSmoothCurve'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addFitCurve'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addFourierFilterCurve'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addFunctionCurve'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addHorizontalAxis'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addVerticalAxis'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addTextLabel'
        QtMocHelpers::SlotData<void()>(113, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addImage'
        QtMocHelpers::SlotData<void()>(114, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addCustomPoint'
        QtMocHelpers::SlotData<void()>(115, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addReferenceLine'
        QtMocHelpers::SlotData<void()>(116, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addReferenceRange'
        QtMocHelpers::SlotData<void()>(117, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addInfoElement'
        QtMocHelpers::SlotData<void()>(118, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateLegend'
        QtMocHelpers::SlotData<void()>(119, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'childAdded'
        QtMocHelpers::SlotData<void(const AbstractAspect *)>(120, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 53, 2 },
        }}),
        // Slot 'childRemoved'
        QtMocHelpers::SlotData<void(const AbstractAspect *, const AbstractAspect *, const AbstractAspect *)>(121, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 53, 122 }, { 0x80000000 | 53, 123 }, { 0x80000000 | 53, 124 },
        }}),
        // Slot 'childHovered'
        QtMocHelpers::SlotData<void()>(125, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void(WorksheetElement *)>(98, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 99, 2 },
        }}),
        // Slot 'dataChanged'
        QtMocHelpers::SlotData<void(Plot *, const Dimension)>(98, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 126, 2 }, { 0x80000000 | 6, 2 },
        }}),
        // Slot 'plotColorChanged'
        QtMocHelpers::SlotData<void()>(60, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'curveVisibilityChanged'
        QtMocHelpers::SlotData<void()>(127, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'boxPlotOrientationChanged'
        QtMocHelpers::SlotData<void(WorksheetElement::Orientation)>(128, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 129, 2 },
        }}),
        // Slot 'loadTheme'
        QtMocHelpers::SlotData<void(const QString &)>(130, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'RangeType'
        QtMocHelpers::EnumData<enum RangeType>(131, 131, QMC::EnumIsScoped).add({
            {  132, RangeType::Free },
            {  133, RangeType::Last },
            {  134, RangeType::First },
        }),
    };
    return QtMocHelpers::metaObjectData<CartesianPlot, qt_meta_tag_ZN13CartesianPlotE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CartesianPlot::staticMetaObject = { {
    QMetaObject::SuperData::link<AbstractPlot::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CartesianPlotE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CartesianPlotE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13CartesianPlotE_t>.metaTypes,
    nullptr
} };

void CartesianPlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CartesianPlot *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->rangeTypeChanged((*reinterpret_cast<std::add_pointer_t<CartesianPlot::RangeType>>(_a[1]))); break;
        case 1: _t->niceExtendChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->rangeFormatChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<RangeT::Format>>(_a[3]))); break;
        case 3: _t->rangeLastValuesChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->rangeFirstValuesChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 5: _t->rectChanged((*reinterpret_cast<std::add_pointer_t<QRectF&>>(_a[1]))); break;
        case 6: _t->autoScaleChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 7: _t->rangeChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Range<double>>>(_a[3]))); break;
        case 8: _t->minChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 9: _t->maxChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 10: _t->scaleChanged((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<RangeT::Scale>>(_a[3]))); break;
        case 11: _t->defaultCoordinateSystemIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->xRangeBreakingEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->xRangeBreaksChanged((*reinterpret_cast<std::add_pointer_t<CartesianPlot::RangeBreaks>>(_a[1]))); break;
        case 14: _t->yRangeBreakingEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->yRangeBreaksChanged((*reinterpret_cast<std::add_pointer_t<CartesianPlot::RangeBreaks>>(_a[1]))); break;
        case 16: _t->themeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->axisShiftSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 18: _t->mousePressZoomSelectionModeSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 19: _t->mousePressCursorModeSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 20: _t->mouseMoveSelectionModeSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 21: _t->mouseMoveZoomSelectionModeSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 22: _t->mouseMoveCursorModeSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2]))); break;
        case 23: _t->mouseReleaseCursorModeSignal(); break;
        case 24: _t->mouseReleaseZoomSelectionModeSignal(); break;
        case 25: _t->mouseHoverZoomSelectionModeSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 26: _t->mouseHoverOutsideDataRectSignal(); break;
        case 27: _t->wheelEventSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[6]))); break;
        case 28: _t->curveNameChanged((*reinterpret_cast<std::add_pointer_t<const AbstractAspect*>>(_a[1]))); break;
        case 29: _t->cursorPosChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 30: _t->curveAdded((*reinterpret_cast<std::add_pointer_t<const XYCurve*>>(_a[1]))); break;
        case 31: _t->curveRemoved((*reinterpret_cast<std::add_pointer_t<const XYCurve*>>(_a[1]))); break;
        case 32: _t->plotColorChanged((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 33: _t->cursorPenChanged((*reinterpret_cast<std::add_pointer_t<QPen>>(_a[1]))); break;
        case 34: _t->curveDataChanged((*reinterpret_cast<std::add_pointer_t<const XYCurve*>>(_a[1]))); break;
        case 35: _t->curveVisibilityChangedSignal(); break;
        case 36: _t->mouseModeChanged((*reinterpret_cast<std::add_pointer_t<CartesianPlot::MouseMode>>(_a[1]))); break;
        case 37: _t->cursor0EnableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->cursor1EnableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->scaleRetransformed((*reinterpret_cast<std::add_pointer_t<const CartesianPlot*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 40: _t->setTheme((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 41: _t->retransform(); break;
        case 42: _t->addHistogramFit((*reinterpret_cast<std::add_pointer_t<Histogram*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<nsl_sf_stats_distribution>>(_a[2]))); break;
        case 43: _t->addLegend(); break;
        case 44: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 47: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 48: { bool _r = _t->scaleAuto();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 50: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 51: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 52: { bool _r = _t->scaleAuto((*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 53: _t->zoomIn((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[3]))); break;
        case 54: _t->zoomIn((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 55: _t->zoomIn((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 56: _t->zoomIn(); break;
        case 57: _t->zoomOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[3]))); break;
        case 58: _t->zoomOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 59: _t->zoomOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 60: _t->zoomOut(); break;
        case 61: _t->zoomInX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 62: _t->zoomInX(); break;
        case 63: _t->zoomOutX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 64: _t->zoomOutX(); break;
        case 65: _t->zoomInY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 66: _t->zoomInY(); break;
        case 67: _t->zoomOutY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 68: _t->zoomOutY(); break;
        case 69: _t->zoomInOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[4]))); break;
        case 70: _t->zoomInOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 71: _t->shiftLeftX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 72: _t->shiftLeftX(); break;
        case 73: _t->shiftRightX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 74: _t->shiftRightX(); break;
        case 75: _t->shiftUpY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 76: _t->shiftUpY(); break;
        case 77: _t->shiftDownY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 78: _t->shiftDownY(); break;
        case 79: _t->shift((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 80: _t->cursor(); break;
        case 81: _t->dataChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<WorksheetElement*>>(_a[3]))); break;
        case 82: _t->dataChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 83: _t->dataChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 84: _t->dataChanged(); break;
        case 85: _t->addPlot((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 86: _t->addDataReductionCurve(); break;
        case 87: _t->addDifferentiationCurve(); break;
        case 88: _t->addIntegrationCurve(); break;
        case 89: _t->addInterpolationCurve(); break;
        case 90: _t->addSmoothCurve(); break;
        case 91: _t->addFitCurve(); break;
        case 92: _t->addFourierFilterCurve(); break;
        case 93: _t->addFunctionCurve(); break;
        case 94: _t->addHorizontalAxis(); break;
        case 95: _t->addVerticalAxis(); break;
        case 96: _t->addTextLabel(); break;
        case 97: _t->addImage(); break;
        case 98: _t->addCustomPoint(); break;
        case 99: _t->addReferenceLine(); break;
        case 100: _t->addReferenceRange(); break;
        case 101: _t->addInfoElement(); break;
        case 102: _t->updateLegend(); break;
        case 103: _t->childAdded((*reinterpret_cast<std::add_pointer_t<const AbstractAspect*>>(_a[1]))); break;
        case 104: _t->childRemoved((*reinterpret_cast<std::add_pointer_t<const AbstractAspect*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<const AbstractAspect*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<const AbstractAspect*>>(_a[3]))); break;
        case 105: _t->childHovered(); break;
        case 106: _t->dataChanged((*reinterpret_cast<std::add_pointer_t<WorksheetElement*>>(_a[1]))); break;
        case 107: _t->dataChanged((*reinterpret_cast<std::add_pointer_t<Plot*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Dimension>>(_a[2]))); break;
        case 108: _t->plotColorChanged(); break;
        case 109: _t->curveVisibilityChanged(); break;
        case 110: _t->boxPlotOrientationChanged((*reinterpret_cast<std::add_pointer_t<WorksheetElement::Orientation>>(_a[1]))); break;
        case 111: _t->loadTheme((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 81:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< WorksheetElement* >(); break;
            }
            break;
        case 106:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< WorksheetElement* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(CartesianPlot::RangeType )>(_a, &CartesianPlot::rangeTypeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(bool )>(_a, &CartesianPlot::niceExtendChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , RangeT::Format )>(_a, &CartesianPlot::rangeFormatChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int )>(_a, &CartesianPlot::rangeLastValuesChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int )>(_a, &CartesianPlot::rangeFirstValuesChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QRectF & )>(_a, &CartesianPlot::rectChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , bool )>(_a, &CartesianPlot::autoScaleChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , Range<double> )>(_a, &CartesianPlot::rangeChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , double )>(_a, &CartesianPlot::minChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , double )>(_a, &CartesianPlot::maxChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const Dimension , int , RangeT::Scale )>(_a, &CartesianPlot::scaleChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int )>(_a, &CartesianPlot::defaultCoordinateSystemIndexChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(bool )>(_a, &CartesianPlot::xRangeBreakingEnabledChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const CartesianPlot::RangeBreaks & )>(_a, &CartesianPlot::xRangeBreaksChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(bool )>(_a, &CartesianPlot::yRangeBreakingEnabledChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const CartesianPlot::RangeBreaks & )>(_a, &CartesianPlot::yRangeBreaksChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const QString & )>(_a, &CartesianPlot::themeChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int , Dimension , int )>(_a, &CartesianPlot::axisShiftSignal, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QPointF )>(_a, &CartesianPlot::mousePressZoomSelectionModeSignal, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int , QPointF )>(_a, &CartesianPlot::mousePressCursorModeSignal, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QPointF , QPointF )>(_a, &CartesianPlot::mouseMoveSelectionModeSignal, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QPointF )>(_a, &CartesianPlot::mouseMoveZoomSelectionModeSignal, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int , QPointF )>(_a, &CartesianPlot::mouseMoveCursorModeSignal, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)()>(_a, &CartesianPlot::mouseReleaseCursorModeSignal, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)()>(_a, &CartesianPlot::mouseReleaseZoomSelectionModeSignal, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QPointF )>(_a, &CartesianPlot::mouseHoverZoomSelectionModeSignal, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)()>(_a, &CartesianPlot::mouseHoverOutsideDataRectSignal, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const QPointF & , int , int , int , bool , Dimension )>(_a, &CartesianPlot::wheelEventSignal, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const AbstractAspect * )>(_a, &CartesianPlot::curveNameChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(int , double )>(_a, &CartesianPlot::cursorPosChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const XYCurve * )>(_a, &CartesianPlot::curveAdded, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const XYCurve * )>(_a, &CartesianPlot::curveRemoved, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const QColor & , const QString & )>(_a, &CartesianPlot::plotColorChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(QPen )>(_a, &CartesianPlot::cursorPenChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const XYCurve * )>(_a, &CartesianPlot::curveDataChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)()>(_a, &CartesianPlot::curveVisibilityChangedSignal, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(CartesianPlot::MouseMode )>(_a, &CartesianPlot::mouseModeChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(bool )>(_a, &CartesianPlot::cursor0EnableChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(bool )>(_a, &CartesianPlot::cursor1EnableChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (CartesianPlot::*)(const CartesianPlot * , const Dimension , int )>(_a, &CartesianPlot::scaleRetransformed, 39))
            return;
    }
}

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

void *CartesianPlot::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CartesianPlotE_t>.strings))
        return static_cast<void*>(this);
    return AbstractPlot::qt_metacast(_clname);
}

int CartesianPlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractPlot::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 112)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 112;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 112)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 112;
    }
    return _id;
}

// SIGNAL 0
void CartesianPlot::rangeTypeChanged(CartesianPlot::RangeType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void CartesianPlot::niceExtendChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void CartesianPlot::rangeFormatChanged(const Dimension _t1, int _t2, RangeT::Format _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2, _t3);
}

// SIGNAL 3
void CartesianPlot::rangeLastValuesChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void CartesianPlot::rangeFirstValuesChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void CartesianPlot::rectChanged(QRectF & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void CartesianPlot::autoScaleChanged(const Dimension _t1, int _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2, _t3);
}

// SIGNAL 7
void CartesianPlot::rangeChanged(const Dimension _t1, int _t2, Range<double> _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2, _t3);
}

// SIGNAL 8
void CartesianPlot::minChanged(const Dimension _t1, int _t2, double _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2, _t3);
}

// SIGNAL 9
void CartesianPlot::maxChanged(const Dimension _t1, int _t2, double _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2, _t3);
}

// SIGNAL 10
void CartesianPlot::scaleChanged(const Dimension _t1, int _t2, RangeT::Scale _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3);
}

// SIGNAL 11
void CartesianPlot::defaultCoordinateSystemIndexChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void CartesianPlot::xRangeBreakingEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void CartesianPlot::xRangeBreaksChanged(const CartesianPlot::RangeBreaks & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void CartesianPlot::yRangeBreakingEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void CartesianPlot::yRangeBreaksChanged(const CartesianPlot::RangeBreaks & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void CartesianPlot::themeChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void CartesianPlot::axisShiftSignal(int _t1, Dimension _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2, _t3);
}

// SIGNAL 18
void CartesianPlot::mousePressZoomSelectionModeSignal(QPointF _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void CartesianPlot::mousePressCursorModeSignal(int _t1, QPointF _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void CartesianPlot::mouseMoveSelectionModeSignal(QPointF _t1, QPointF _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2);
}

// SIGNAL 21
void CartesianPlot::mouseMoveZoomSelectionModeSignal(QPointF _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void CartesianPlot::mouseMoveCursorModeSignal(int _t1, QPointF _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1, _t2);
}

// SIGNAL 23
void CartesianPlot::mouseReleaseCursorModeSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void CartesianPlot::mouseReleaseZoomSelectionModeSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void CartesianPlot::mouseHoverZoomSelectionModeSignal(QPointF _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void CartesianPlot::mouseHoverOutsideDataRectSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void CartesianPlot::wheelEventSignal(const QPointF & _t1, int _t2, int _t3, int _t4, bool _t5, Dimension _t6)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2, _t3, _t4, _t5, _t6);
}

// SIGNAL 28
void CartesianPlot::curveNameChanged(const AbstractAspect * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void CartesianPlot::cursorPosChanged(int _t1, double _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1, _t2);
}

// SIGNAL 30
void CartesianPlot::curveAdded(const XYCurve * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void CartesianPlot::curveRemoved(const XYCurve * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void CartesianPlot::plotColorChanged(const QColor & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1, _t2);
}

// SIGNAL 33
void CartesianPlot::cursorPenChanged(QPen _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void CartesianPlot::curveDataChanged(const XYCurve * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void CartesianPlot::curveVisibilityChangedSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void CartesianPlot::mouseModeChanged(CartesianPlot::MouseMode _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void CartesianPlot::cursor0EnableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void CartesianPlot::cursor1EnableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void CartesianPlot::scaleRetransformed(const CartesianPlot * _t1, const Dimension _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1, _t2, _t3);
}
QT_WARNING_POP
