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

#include "../../../../../contour/src/contour/window/WindowController.hpp"
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#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 'WindowController.hpp' 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_ZN7contour6window16WindowControllerE_t {};
} // unnamed namespace

template <> constexpr inline auto contour::window::WindowController::qt_create_metaobjectdata<qt_meta_tag_ZN7contour6window16WindowControllerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "contour::window::WindowController",
        "QML.Element",
        "auto",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Created by the session manager",
        "countChanged",
        "",
        "activeTabIndexChanged",
        "tabTitleEditRequested",
        "index",
        "tabColorPickRequested",
        "commandPaletteRequested",
        "saveLayoutRequested",
        "contextMenuModelChanged",
        "contextMenuRequested",
        "titleBarContextMenuModelChanged",
        "titleBarContextMenuRequested",
        "multimediaReadyChanged",
        "activeTabRootPaneChanged",
        "titleBarVisibleChanged",
        "nativeControlsInsetChanged",
        "tabBarPositionChanged",
        "tabBarVisibilityChanged",
        "tabBarShouldShowChanged",
        "activeSessionChanged",
        "chromeHeightChanged",
        "settingsActiveChanged",
        "createNewTab",
        "profileName",
        "activateTab",
        "tabWorkingDirectory",
        "dispatchTabStripWheel",
        "pixelDeltaX",
        "pixelDeltaY",
        "angleDeltaX",
        "angleDeltaY",
        "phase",
        "inverted",
        "moveTab",
        "fromIndex",
        "toIndex",
        "windowIdValue",
        "moveTabIntoThisWindow",
        "sourceWindowId",
        "tearOffTab",
        "setTabTitle",
        "title",
        "resetTabTitle",
        "beginActiveTabTitleEdit",
        "beginActiveTabColorPick",
        "beginSaveLayoutPrompt",
        "saveLayoutAs",
        "name",
        "setTabColor",
        "QColor",
        "color",
        "resetTabColor",
        "closeTabAtIndex",
        "closeOtherTabs",
        "closeTabsToRight",
        "tabColorPalette",
        "QVariantList",
        "tabBackgroundColor",
        "tabColor",
        "rowBackground",
        "active",
        "hovered",
        "windowActive",
        "tabTextColor",
        "tabBackground",
        "closeWindow",
        "canCloseWindow",
        "runCommand",
        "id",
        "openSettings",
        "closeSettings",
        "toggleSettings",
        "openTitleBarContextMenu",
        "triggerTitleBarContextMenuAction",
        "actionId",
        "triggerContextMenuAction",
        "bindWindow",
        "QQuickWindow*",
        "osWindow",
        "toggleMaximized",
        "minimizeWindow",
        "showInitial",
        "count",
        "commandPalette",
        "contour::window::CommandPaletteModel*",
        "contextMenuModel",
        "titleBarContextMenuModel",
        "activeTabIndex",
        "multimediaReady",
        "activeTabRootPane",
        "contour::session::PaneProxy*",
        "activeSession",
        "contour::session::TerminalSession*",
        "titleBarVisible",
        "needsFramelessHint",
        "needsClientFrameAffordances",
        "nativeControlsInset",
        "tabBarPosition",
        "tabBarVisibility",
        "tabBarShouldShow",
        "chromeHeight",
        "settingsActive",
        "settingsController",
        "contour::window::SettingsController*"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'countChanged'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeTabIndexChanged'
        QtMocHelpers::SignalData<void()>(9, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tabTitleEditRequested'
        QtMocHelpers::SignalData<void(int)>(10, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'tabColorPickRequested'
        QtMocHelpers::SignalData<void(int)>(12, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'commandPaletteRequested'
        QtMocHelpers::SignalData<void()>(13, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'saveLayoutRequested'
        QtMocHelpers::SignalData<void()>(14, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'contextMenuModelChanged'
        QtMocHelpers::SignalData<void()>(15, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'contextMenuRequested'
        QtMocHelpers::SignalData<void()>(16, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'titleBarContextMenuModelChanged'
        QtMocHelpers::SignalData<void()>(17, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'titleBarContextMenuRequested'
        QtMocHelpers::SignalData<void()>(18, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'multimediaReadyChanged'
        QtMocHelpers::SignalData<void()>(19, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeTabRootPaneChanged'
        QtMocHelpers::SignalData<void()>(20, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'titleBarVisibleChanged'
        QtMocHelpers::SignalData<void()>(21, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'nativeControlsInsetChanged'
        QtMocHelpers::SignalData<void()>(22, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tabBarPositionChanged'
        QtMocHelpers::SignalData<void()>(23, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tabBarVisibilityChanged'
        QtMocHelpers::SignalData<void()>(24, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tabBarShouldShowChanged'
        QtMocHelpers::SignalData<void()>(25, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeSessionChanged'
        QtMocHelpers::SignalData<void()>(26, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chromeHeightChanged'
        QtMocHelpers::SignalData<void()>(27, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'settingsActiveChanged'
        QtMocHelpers::SignalData<void()>(28, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'createNewTab'
        QtMocHelpers::MethodData<void(QString const &)>(29, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'createNewTab'
        QtMocHelpers::MethodData<void()>(29, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'activateTab'
        QtMocHelpers::MethodData<void(int)>(31, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'tabWorkingDirectory'
        QtMocHelpers::MethodData<QString(int) const>(32, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'dispatchTabStripWheel'
        QtMocHelpers::MethodData<void(int, int, int, int, int, bool)>(33, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 34 }, { QMetaType::Int, 35 }, { QMetaType::Int, 36 }, { QMetaType::Int, 37 },
            { QMetaType::Int, 38 }, { QMetaType::Bool, 39 },
        }}),
        // Method 'moveTab'
        QtMocHelpers::MethodData<void(int, int)>(40, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 41 }, { QMetaType::Int, 42 },
        }}),
        // Method 'windowIdValue'
        QtMocHelpers::MethodData<quint64() const>(43, 8, QMC::AccessPublic, QMetaType::ULongLong),
        // Method 'moveTabIntoThisWindow'
        QtMocHelpers::MethodData<void(quint64, int, int)>(44, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 45 }, { QMetaType::Int, 41 }, { QMetaType::Int, 42 },
        }}),
        // Method 'tearOffTab'
        QtMocHelpers::MethodData<void(int)>(46, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'setTabTitle'
        QtMocHelpers::MethodData<void(int, QString const &)>(47, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 }, { QMetaType::QString, 48 },
        }}),
        // Method 'resetTabTitle'
        QtMocHelpers::MethodData<void(int)>(49, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'beginActiveTabTitleEdit'
        QtMocHelpers::MethodData<void()>(50, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'beginActiveTabColorPick'
        QtMocHelpers::MethodData<void()>(51, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'beginSaveLayoutPrompt'
        QtMocHelpers::MethodData<void()>(52, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'saveLayoutAs'
        QtMocHelpers::MethodData<void(QString const &)>(53, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Method 'setTabColor'
        QtMocHelpers::MethodData<void(int, QColor const &)>(55, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 }, { 0x80000000 | 56, 57 },
        }}),
        // Method 'resetTabColor'
        QtMocHelpers::MethodData<void(int)>(58, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'closeTabAtIndex'
        QtMocHelpers::MethodData<void(int)>(59, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'closeOtherTabs'
        QtMocHelpers::MethodData<void(int)>(60, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'closeTabsToRight'
        QtMocHelpers::MethodData<void(int)>(61, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Method 'tabColorPalette'
        QtMocHelpers::MethodData<QVariantList() const>(62, 8, QMC::AccessPublic, 0x80000000 | 63),
        // Method 'tabBackgroundColor'
        QtMocHelpers::MethodData<QColor(QColor const &, QColor const &, bool, bool, bool) const>(64, 8, QMC::AccessPublic, 0x80000000 | 56, {{
            { 0x80000000 | 56, 65 }, { 0x80000000 | 56, 66 }, { QMetaType::Bool, 67 }, { QMetaType::Bool, 68 },
            { QMetaType::Bool, 69 },
        }}),
        // Method 'tabTextColor'
        QtMocHelpers::MethodData<QColor(QColor const &) const>(70, 8, QMC::AccessPublic, 0x80000000 | 56, {{
            { 0x80000000 | 56, 71 },
        }}),
        // Method 'closeWindow'
        QtMocHelpers::MethodData<void()>(72, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'canCloseWindow'
        QtMocHelpers::MethodData<bool() const>(73, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'runCommand'
        QtMocHelpers::MethodData<void(QString const &)>(74, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 75 },
        }}),
        // Method 'openSettings'
        QtMocHelpers::MethodData<void()>(76, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'closeSettings'
        QtMocHelpers::MethodData<void()>(77, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'toggleSettings'
        QtMocHelpers::MethodData<void()>(78, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'openTitleBarContextMenu'
        QtMocHelpers::MethodData<void()>(79, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'triggerTitleBarContextMenuAction'
        QtMocHelpers::MethodData<void(int)>(80, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 81 },
        }}),
        // Method 'triggerContextMenuAction'
        QtMocHelpers::MethodData<void(int)>(82, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 81 },
        }}),
        // Method 'bindWindow'
        QtMocHelpers::MethodData<void(QQuickWindow *)>(83, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 84, 85 },
        }}),
        // Method 'toggleMaximized'
        QtMocHelpers::MethodData<void()>(86, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'minimizeWindow'
        QtMocHelpers::MethodData<void()>(87, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'showInitial'
        QtMocHelpers::MethodData<void()>(88, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'count'
        QtMocHelpers::PropertyData<int>(89, QMetaType::Int, QMC::DefaultPropertyFlags, 0),
        // property 'commandPalette'
        QtMocHelpers::PropertyData<contour::window::CommandPaletteModel*>(90, 0x80000000 | 91, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'contextMenuModel'
        QtMocHelpers::PropertyData<QVariantList>(92, 0x80000000 | 63, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 6),
        // property 'titleBarContextMenuModel'
        QtMocHelpers::PropertyData<QVariantList>(93, 0x80000000 | 63, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 8),
        // property 'activeTabIndex'
        QtMocHelpers::PropertyData<int>(94, QMetaType::Int, QMC::DefaultPropertyFlags, 1),
        // property 'multimediaReady'
        QtMocHelpers::PropertyData<bool>(95, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'activeTabRootPane'
        QtMocHelpers::PropertyData<contour::session::PaneProxy*>(96, 0x80000000 | 97, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 11),
        // property 'activeSession'
        QtMocHelpers::PropertyData<contour::session::TerminalSession*>(98, 0x80000000 | 99, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'titleBarVisible'
        QtMocHelpers::PropertyData<bool>(100, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'needsFramelessHint'
        QtMocHelpers::PropertyData<bool>(101, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'needsClientFrameAffordances'
        QtMocHelpers::PropertyData<bool>(102, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'nativeControlsInset'
        QtMocHelpers::PropertyData<qreal>(103, QMetaType::QReal, QMC::DefaultPropertyFlags, 13),
        // property 'tabBarPosition'
        QtMocHelpers::PropertyData<int>(104, QMetaType::Int, QMC::DefaultPropertyFlags, 14),
        // property 'tabBarVisibility'
        QtMocHelpers::PropertyData<int>(105, QMetaType::Int, QMC::DefaultPropertyFlags, 15),
        // property 'tabBarShouldShow'
        QtMocHelpers::PropertyData<bool>(106, QMetaType::Bool, QMC::DefaultPropertyFlags, 16),
        // property 'chromeHeight'
        QtMocHelpers::PropertyData<int>(107, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'settingsActive'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags, 19),
        // property 'settingsController'
        QtMocHelpers::PropertyData<contour::window::SettingsController*>(109, 0x80000000 | 110, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<WindowController, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject contour::window::WindowController::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7contour6window16WindowControllerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7contour6window16WindowControllerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7contour6window16WindowControllerE_t>.metaTypes,
    nullptr
} };

void contour::window::WindowController::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<WindowController *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->countChanged(); break;
        case 1: _t->activeTabIndexChanged(); break;
        case 2: _t->tabTitleEditRequested((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->tabColorPickRequested((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->commandPaletteRequested(); break;
        case 5: _t->saveLayoutRequested(); break;
        case 6: _t->contextMenuModelChanged(); break;
        case 7: _t->contextMenuRequested(); break;
        case 8: _t->titleBarContextMenuModelChanged(); break;
        case 9: _t->titleBarContextMenuRequested(); break;
        case 10: _t->multimediaReadyChanged(); break;
        case 11: _t->activeTabRootPaneChanged(); break;
        case 12: _t->titleBarVisibleChanged(); break;
        case 13: _t->nativeControlsInsetChanged(); break;
        case 14: _t->tabBarPositionChanged(); break;
        case 15: _t->tabBarVisibilityChanged(); break;
        case 16: _t->tabBarShouldShowChanged(); break;
        case 17: _t->activeSessionChanged(); break;
        case 18: _t->chromeHeightChanged(); break;
        case 19: _t->settingsActiveChanged(); break;
        case 20: _t->createNewTab((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 21: _t->createNewTab(); break;
        case 22: _t->activateTab((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 23: { QString _r = _t->tabWorkingDirectory((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 24: _t->dispatchTabStripWheel((*reinterpret_cast<std::add_pointer_t<int>>(_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<int>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6]))); break;
        case 25: _t->moveTab((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 26: { quint64 _r = _t->windowIdValue();
            if (_a[0]) *reinterpret_cast<quint64*>(_a[0]) = std::move(_r); }  break;
        case 27: _t->moveTabIntoThisWindow((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 28: _t->tearOffTab((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 29: _t->setTabTitle((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 30: _t->resetTabTitle((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 31: _t->beginActiveTabTitleEdit(); break;
        case 32: _t->beginActiveTabColorPick(); break;
        case 33: _t->beginSaveLayoutPrompt(); break;
        case 34: _t->saveLayoutAs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 35: _t->setTabColor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 36: _t->resetTabColor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 37: _t->closeTabAtIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 38: _t->closeOtherTabs((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 39: _t->closeTabsToRight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 40: { QVariantList _r = _t->tabColorPalette();
            if (_a[0]) *reinterpret_cast<QVariantList*>(_a[0]) = std::move(_r); }  break;
        case 41: { QColor _r = _t->tabBackgroundColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 42: { QColor _r = _t->tabTextColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->closeWindow(); break;
        case 44: { bool _r = _t->canCloseWindow();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: _t->runCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 46: _t->openSettings(); break;
        case 47: _t->closeSettings(); break;
        case 48: _t->toggleSettings(); break;
        case 49: _t->openTitleBarContextMenu(); break;
        case 50: _t->triggerTitleBarContextMenuAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 51: _t->triggerContextMenuAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 52: _t->bindWindow((*reinterpret_cast<std::add_pointer_t<QQuickWindow*>>(_a[1]))); break;
        case 53: _t->toggleMaximized(); break;
        case 54: _t->minimizeWindow(); break;
        case 55: _t->showInitial(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 52:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuickWindow* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::countChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::activeTabIndexChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)(int )>(_a, &WindowController::tabTitleEditRequested, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)(int )>(_a, &WindowController::tabColorPickRequested, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::commandPaletteRequested, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::saveLayoutRequested, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::contextMenuModelChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::contextMenuRequested, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::titleBarContextMenuModelChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::titleBarContextMenuRequested, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::multimediaReadyChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::activeTabRootPaneChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::titleBarVisibleChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::nativeControlsInsetChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::tabBarPositionChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::tabBarVisibilityChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::tabBarShouldShowChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::activeSessionChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::chromeHeightChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowController::*)()>(_a, &WindowController::settingsActiveChanged, 19))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 6:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< contour::session::PaneProxy* >(); break;
        case 7:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< contour::session::TerminalSession* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< contour::window::CommandPaletteModel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->count(); break;
        case 1: *reinterpret_cast<contour::window::CommandPaletteModel**>(_v) = _t->commandPalette(); break;
        case 2: *reinterpret_cast<QVariantList*>(_v) = _t->contextMenuModel(); break;
        case 3: *reinterpret_cast<QVariantList*>(_v) = _t->titleBarContextMenuModel(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->activeTabIndex(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isMultimediaReady(); break;
        case 6: *reinterpret_cast<contour::session::PaneProxy**>(_v) = _t->activeTabRootPane(); break;
        case 7: *reinterpret_cast<contour::session::TerminalSession**>(_v) = _t->activeSession(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->titleBarVisible(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->needsFramelessHint(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->needsClientFrameAffordances(); break;
        case 11: *reinterpret_cast<qreal*>(_v) = _t->nativeControlsInset(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->tabBarPosition(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->tabBarVisibility(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->tabBarShouldShow(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->chromeHeight(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->settingsActive(); break;
        case 17: *reinterpret_cast<contour::window::SettingsController**>(_v) = _t->settingsController(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 15: _t->setChromeHeight(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

void *contour::window::WindowController::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7contour6window16WindowControllerE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "command::TabTitleProvider"))
        return static_cast< command::TabTitleProvider*>(this);
    if (!strcmp(_clname, "display::WindowHost"))
        return static_cast< display::WindowHost*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int contour::window::WindowController::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 56)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 56;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 56)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 56;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 18;
    }
    return _id;
}

// SIGNAL 0
void contour::window::WindowController::countChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void contour::window::WindowController::activeTabIndexChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void contour::window::WindowController::tabTitleEditRequested(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void contour::window::WindowController::tabColorPickRequested(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void contour::window::WindowController::commandPaletteRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void contour::window::WindowController::saveLayoutRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void contour::window::WindowController::contextMenuModelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void contour::window::WindowController::contextMenuRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void contour::window::WindowController::titleBarContextMenuModelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void contour::window::WindowController::titleBarContextMenuRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void contour::window::WindowController::multimediaReadyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void contour::window::WindowController::activeTabRootPaneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void contour::window::WindowController::titleBarVisibleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void contour::window::WindowController::nativeControlsInsetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void contour::window::WindowController::tabBarPositionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void contour::window::WindowController::tabBarVisibilityChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void contour::window::WindowController::tabBarShouldShowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void contour::window::WindowController::activeSessionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void contour::window::WindowController::chromeHeightChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void contour::window::WindowController::settingsActiveChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}
QT_WARNING_POP
