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

#include "../../window.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto KWin::Window::qt_create_metaobjectdata<qt_meta_tag_ZN4KWin6WindowE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KWin::Window",
        "stackingOrderChanged",
        "",
        "shadeChanged",
        "opacityChanged",
        "KWin::Window*",
        "window",
        "oldOpacity",
        "damaged",
        "inputTransformationChanged",
        "geometryChanged",
        "geometryShapeChanged",
        "QRectF",
        "old",
        "windowClosed",
        "KWin::Deleted*",
        "deleted",
        "windowShown",
        "windowHidden",
        "shapedChanged",
        "screenChanged",
        "skipCloseAnimationChanged",
        "windowRoleChanged",
        "windowClassChanged",
        "hasAlphaChanged",
        "surfaceChanged",
        "shadowChanged",
        "bufferGeometryChanged",
        "oldGeometry",
        "frameGeometryChanged",
        "clientGeometryChanged",
        "frameGeometryAboutToChange",
        "visibleGeometryChanged",
        "tileChanged",
        "KWin::Tile*",
        "tile",
        "waylandWindowRadiusChanged",
        "QPointF",
        "waylandShadowColorChanged",
        "waylandBorderWidthChanged",
        "waylandBorderColorChanged",
        "waylandWindowEffectChanged",
        "uint32_t",
        "waylandWindowStartUpEffectChanged",
        "fullScreenChanged",
        "skipTaskbarChanged",
        "skipPagerChanged",
        "skipSwitcherChanged",
        "iconChanged",
        "activeChanged",
        "keepAboveChanged",
        "keepBelowChanged",
        "demandsAttentionChanged",
        "desktopPresenceChanged",
        "desktopChanged",
        "activitiesChanged",
        "x11DesktopIdsChanged",
        "minimizedChanged",
        "clientMinimized",
        "animate",
        "clientUnminimized",
        "paletteChanged",
        "QPalette",
        "p",
        "colorSchemeChanged",
        "captionChanged",
        "clientMaximizedStateAboutToChange",
        "MaximizeMode",
        "clientMaximizedStateChanged",
        "animated",
        "c",
        "h",
        "v",
        "transientChanged",
        "modalChanged",
        "quickTileModeChanged",
        "moveResizedChanged",
        "moveResizeCursorChanged",
        "CursorShape",
        "clientStartUserMovedResized",
        "clientStepUserMovedResized",
        "clientFinishUserMovedResized",
        "closeableChanged",
        "minimizeableChanged",
        "shadeableChanged",
        "maximizeableChanged",
        "desktopFileNameChanged",
        "applicationMenuChanged",
        "hasApplicationMenuChanged",
        "applicationMenuActiveChanged",
        "unresponsiveChanged",
        "decorationChanged",
        "hiddenChanged",
        "lockScreenOverlayChanged",
        "triggerSplitPreview",
        "w",
        "swapSplitWindow",
        "index",
        "waylandShadowChanged",
        "scissorForceChange",
        "closeWindow",
        "onWindowRadiusChanged",
        "float&",
        "onThemeChange",
        "bool&",
        "setReadyForPainting",
        "clearRules",
        "shadeHover",
        "shadeUnhover",
        "setMaximize",
        "vertically",
        "horizontally",
        "bufferGeometry",
        "pos",
        "size",
        "QSizeF",
        "x",
        "y",
        "width",
        "height",
        "opacity",
        "screen",
        "output",
        "KWin::Output*",
        "rect",
        "resourceName",
        "resourceClass",
        "windowRole",
        "desktopWindow",
        "dock",
        "toolbar",
        "menu",
        "normalWindow",
        "dialog",
        "splash",
        "utility",
        "dropdownMenu",
        "popupMenu",
        "tooltip",
        "notification",
        "criticalNotification",
        "appletPopup",
        "onScreenDisplay",
        "comboBox",
        "dndIcon",
        "windowType",
        "managed",
        "shaped",
        "skipsCloseAnimation",
        "popupWindow",
        "outline",
        "splitbar",
        "watermark",
        "windowmenu",
        "splitmenu",
        "switcherwin",
        "internalId",
        "QUuid",
        "pid",
        "stackingOrder",
        "fullScreen",
        "fullScreenable",
        "active",
        "desktop",
        "desktops",
        "QList<KWin::VirtualDesktop*>",
        "onAllDesktops",
        "activities",
        "x11DesktopIds",
        "QList<uint>",
        "skipTaskbar",
        "skipPager",
        "skipSwitcher",
        "closeable",
        "icon",
        "QIcon",
        "keepAbove",
        "keepBelow",
        "shadeable",
        "shade",
        "minimizable",
        "minimized",
        "iconGeometry",
        "specialWindow",
        "demandsAttention",
        "caption",
        "minSize",
        "maxSize",
        "wantsInput",
        "transient",
        "transientFor",
        "modal",
        "geometry",
        "frameGeometry",
        "move",
        "resize",
        "decorationHasAlpha",
        "noBorder",
        "providesContextHelp",
        "maximizable",
        "moveable",
        "moveableAcrossScreens",
        "resizeable",
        "desktopFileName",
        "hasApplicationMenu",
        "applicationMenuActive",
        "unresponsive",
        "colorScheme",
        "layer",
        "KWin::Layer",
        "hidden"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'stackingOrderChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shadeChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'opacityChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, qreal)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { QMetaType::QReal, 7 },
        }}),
        // Signal 'damaged'
        QtMocHelpers::SignalData<void(KWin::Window *)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'inputTransformationChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geometryChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geometryShapeChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, const QRectF &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 12, 13 },
        }}),
        // Signal 'windowClosed'
        QtMocHelpers::SignalData<void(KWin::Window *, KWin::Deleted *)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 15, 16 },
        }}),
        // Signal 'windowShown'
        QtMocHelpers::SignalData<void(KWin::Window *)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'windowHidden'
        QtMocHelpers::SignalData<void(KWin::Window *)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'shapedChanged'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'screenChanged'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'skipCloseAnimationChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'windowRoleChanged'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'windowClassChanged'
        QtMocHelpers::SignalData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasAlphaChanged'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'surfaceChanged'
        QtMocHelpers::SignalData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shadowChanged'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'bufferGeometryChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, const QRectF &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 12, 28 },
        }}),
        // Signal 'frameGeometryChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, const QRectF &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 12, 28 },
        }}),
        // Signal 'clientGeometryChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, const QRectF &)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 12, 28 },
        }}),
        // Signal 'frameGeometryAboutToChange'
        QtMocHelpers::SignalData<void(KWin::Window *)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'visibleGeometryChanged'
        QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tileChanged'
        QtMocHelpers::SignalData<void(KWin::Tile *)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 34, 35 },
        }}),
        // Signal 'waylandWindowRadiusChanged'
        QtMocHelpers::SignalData<void(QPointF)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 37, 2 },
        }}),
        // Signal 'waylandShadowColorChanged'
        QtMocHelpers::SignalData<void(QString)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'waylandBorderWidthChanged'
        QtMocHelpers::SignalData<void(qint32)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'waylandBorderColorChanged'
        QtMocHelpers::SignalData<void(QString)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'waylandWindowEffectChanged'
        QtMocHelpers::SignalData<void(uint32_t)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 2 },
        }}),
        // Signal 'waylandWindowStartUpEffectChanged'
        QtMocHelpers::SignalData<void(uint32_t)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 2 },
        }}),
        // Signal 'fullScreenChanged'
        QtMocHelpers::SignalData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'skipTaskbarChanged'
        QtMocHelpers::SignalData<void()>(45, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'skipPagerChanged'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'skipSwitcherChanged'
        QtMocHelpers::SignalData<void()>(47, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'iconChanged'
        QtMocHelpers::SignalData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeChanged'
        QtMocHelpers::SignalData<void()>(49, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'keepAboveChanged'
        QtMocHelpers::SignalData<void(bool)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'keepBelowChanged'
        QtMocHelpers::SignalData<void(bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'demandsAttentionChanged'
        QtMocHelpers::SignalData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'desktopPresenceChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, int)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 }, { QMetaType::Int, 2 },
        }}),
        // Signal 'desktopChanged'
        QtMocHelpers::SignalData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activitiesChanged'
        QtMocHelpers::SignalData<void(KWin::Window *)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'x11DesktopIdsChanged'
        QtMocHelpers::SignalData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'minimizedChanged'
        QtMocHelpers::SignalData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'clientMinimized'
        QtMocHelpers::SignalData<void(KWin::Window *, bool)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { QMetaType::Bool, 59 },
        }}),
        // Signal 'clientUnminimized'
        QtMocHelpers::SignalData<void(KWin::Window *, bool)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { QMetaType::Bool, 59 },
        }}),
        // Signal 'paletteChanged'
        QtMocHelpers::SignalData<void(const QPalette &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 },
        }}),
        // Signal 'colorSchemeChanged'
        QtMocHelpers::SignalData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'captionChanged'
        QtMocHelpers::SignalData<void()>(65, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'clientMaximizedStateAboutToChange'
        QtMocHelpers::SignalData<void(KWin::Window *, MaximizeMode)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 }, { 0x80000000 | 67, 2 },
        }}),
        // Signal 'clientMaximizedStateChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, MaximizeMode, bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 }, { 0x80000000 | 67, 2 }, { QMetaType::Bool, 69 },
        }}),
        // Signal 'clientMaximizedStateChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, MaximizeMode)>(68, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 5, 2 }, { 0x80000000 | 67, 2 },
        }}),
        // Signal 'clientMaximizedStateChanged'
        QtMocHelpers::SignalData<void(KWin::Window *, bool, bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 70 }, { QMetaType::Bool, 71 }, { QMetaType::Bool, 72 },
        }}),
        // Signal 'transientChanged'
        QtMocHelpers::SignalData<void()>(73, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modalChanged'
        QtMocHelpers::SignalData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'quickTileModeChanged'
        QtMocHelpers::SignalData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'moveResizedChanged'
        QtMocHelpers::SignalData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'moveResizeCursorChanged'
        QtMocHelpers::SignalData<void(CursorShape)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 78, 2 },
        }}),
        // Signal 'clientStartUserMovedResized'
        QtMocHelpers::SignalData<void(KWin::Window *)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 },
        }}),
        // Signal 'clientStepUserMovedResized'
        QtMocHelpers::SignalData<void(KWin::Window *, const QRectF &)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 }, { 0x80000000 | 12, 2 },
        }}),
        // Signal 'clientFinishUserMovedResized'
        QtMocHelpers::SignalData<void(KWin::Window *)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 2 },
        }}),
        // Signal 'closeableChanged'
        QtMocHelpers::SignalData<void(bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'minimizeableChanged'
        QtMocHelpers::SignalData<void(bool)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'shadeableChanged'
        QtMocHelpers::SignalData<void(bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'maximizeableChanged'
        QtMocHelpers::SignalData<void(bool)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'desktopFileNameChanged'
        QtMocHelpers::SignalData<void()>(86, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'applicationMenuChanged'
        QtMocHelpers::SignalData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasApplicationMenuChanged'
        QtMocHelpers::SignalData<void(bool)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'applicationMenuActiveChanged'
        QtMocHelpers::SignalData<void(bool)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'unresponsiveChanged'
        QtMocHelpers::SignalData<void(bool)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'decorationChanged'
        QtMocHelpers::SignalData<void()>(91, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hiddenChanged'
        QtMocHelpers::SignalData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lockScreenOverlayChanged'
        QtMocHelpers::SignalData<void()>(93, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'triggerSplitPreview'
        QtMocHelpers::SignalData<void(KWin::Window *)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 95 },
        }}),
        // Signal 'swapSplitWindow'
        QtMocHelpers::SignalData<void(KWin::Window *, int)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 95 }, { QMetaType::Int, 97 },
        }}),
        // Signal 'waylandShadowChanged'
        QtMocHelpers::SignalData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'scissorForceChange'
        QtMocHelpers::SignalData<void()>(99, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'closeWindow'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onWindowRadiusChanged'
        QtMocHelpers::SlotData<void(float &)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 102, 2 },
        }}),
        // Slot 'onThemeChange'
        QtMocHelpers::SlotData<void(bool &)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 104, 2 },
        }}),
        // Slot 'setReadyForPainting'
        QtMocHelpers::SlotData<void()>(105, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'clearRules'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'shadeHover'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'shadeUnhover'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPrivate, QMetaType::Void),
        // Method 'setMaximize'
        QtMocHelpers::MethodData<void(bool, bool, bool)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 110 }, { QMetaType::Bool, 111 }, { QMetaType::Bool, 69 },
        }}),
        // Method 'setMaximize'
        QtMocHelpers::MethodData<void(bool, bool)>(109, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 110 }, { QMetaType::Bool, 111 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'bufferGeometry'
        QtMocHelpers::PropertyData<QRectF>(112, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'pos'
        QtMocHelpers::PropertyData<QPointF>(113, 0x80000000 | 37, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'size'
        QtMocHelpers::PropertyData<QSizeF>(114, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'x'
        QtMocHelpers::PropertyData<qreal>(116, QMetaType::QReal, QMC::DefaultPropertyFlags, 19),
        // property 'y'
        QtMocHelpers::PropertyData<qreal>(117, QMetaType::QReal, QMC::DefaultPropertyFlags, 19),
        // property 'width'
        QtMocHelpers::PropertyData<qreal>(118, QMetaType::QReal, QMC::DefaultPropertyFlags, 19),
        // property 'height'
        QtMocHelpers::PropertyData<qreal>(119, QMetaType::QReal, QMC::DefaultPropertyFlags, 19),
        // property 'opacity'
        QtMocHelpers::PropertyData<qreal>(120, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'screen'
        QtMocHelpers::PropertyData<int>(121, QMetaType::Int, QMC::DefaultPropertyFlags, 11),
        // property 'output'
        QtMocHelpers::PropertyData<KWin::Output*>(122, 0x80000000 | 123, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 11),
        // property 'rect'
        QtMocHelpers::PropertyData<QRectF>(124, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'resourceName'
        QtMocHelpers::PropertyData<QString>(125, QMetaType::QString, QMC::DefaultPropertyFlags, 14),
        // property 'resourceClass'
        QtMocHelpers::PropertyData<QString>(126, QMetaType::QString, QMC::DefaultPropertyFlags, 14),
        // property 'windowRole'
        QtMocHelpers::PropertyData<QString>(127, QMetaType::QString, QMC::DefaultPropertyFlags, 13),
        // property 'desktopWindow'
        QtMocHelpers::PropertyData<bool>(128, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dock'
        QtMocHelpers::PropertyData<bool>(129, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'toolbar'
        QtMocHelpers::PropertyData<bool>(130, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'menu'
        QtMocHelpers::PropertyData<bool>(131, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'normalWindow'
        QtMocHelpers::PropertyData<bool>(132, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dialog'
        QtMocHelpers::PropertyData<bool>(133, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'splash'
        QtMocHelpers::PropertyData<bool>(134, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'utility'
        QtMocHelpers::PropertyData<bool>(135, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dropdownMenu'
        QtMocHelpers::PropertyData<bool>(136, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'popupMenu'
        QtMocHelpers::PropertyData<bool>(137, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'tooltip'
        QtMocHelpers::PropertyData<bool>(138, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'notification'
        QtMocHelpers::PropertyData<bool>(139, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'criticalNotification'
        QtMocHelpers::PropertyData<bool>(140, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'appletPopup'
        QtMocHelpers::PropertyData<bool>(141, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'onScreenDisplay'
        QtMocHelpers::PropertyData<bool>(142, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'comboBox'
        QtMocHelpers::PropertyData<bool>(143, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'dndIcon'
        QtMocHelpers::PropertyData<bool>(144, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'windowType'
        QtMocHelpers::PropertyData<int>(145, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'managed'
        QtMocHelpers::PropertyData<bool>(146, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'deleted'
        QtMocHelpers::PropertyData<bool>(16, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'shaped'
        QtMocHelpers::PropertyData<bool>(147, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'skipsCloseAnimation'
        QtMocHelpers::PropertyData<bool>(148, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'popupWindow'
        QtMocHelpers::PropertyData<bool>(149, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'outline'
        QtMocHelpers::PropertyData<bool>(150, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'splitbar'
        QtMocHelpers::PropertyData<bool>(151, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'watermark'
        QtMocHelpers::PropertyData<bool>(152, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'windowmenu'
        QtMocHelpers::PropertyData<bool>(153, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'splitmenu'
        QtMocHelpers::PropertyData<bool>(154, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'switcherwin'
        QtMocHelpers::PropertyData<bool>(155, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'internalId'
        QtMocHelpers::PropertyData<QUuid>(156, 0x80000000 | 157, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'pid'
        QtMocHelpers::PropertyData<int>(158, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'stackingOrder'
        QtMocHelpers::PropertyData<int>(159, QMetaType::Int, QMC::DefaultPropertyFlags, 0),
        // property 'fullScreen'
        QtMocHelpers::PropertyData<bool>(160, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
        // property 'fullScreenable'
        QtMocHelpers::PropertyData<bool>(161, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'active'
        QtMocHelpers::PropertyData<bool>(162, QMetaType::Bool, QMC::DefaultPropertyFlags, 35),
        // property 'desktop'
        QtMocHelpers::PropertyData<int>(163, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 40),
        // property 'desktops'
        QtMocHelpers::PropertyData<QList<KWin::VirtualDesktop*>>(164, 0x80000000 | 165, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 40),
        // property 'onAllDesktops'
        QtMocHelpers::PropertyData<bool>(166, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 40),
        // property 'activities'
        QtMocHelpers::PropertyData<QStringList>(167, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable, 41),
        // property 'x11DesktopIds'
        QtMocHelpers::PropertyData<QList<uint>>(168, 0x80000000 | 169, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 42),
        // property 'skipTaskbar'
        QtMocHelpers::PropertyData<bool>(170, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'skipPager'
        QtMocHelpers::PropertyData<bool>(171, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'skipSwitcher'
        QtMocHelpers::PropertyData<bool>(172, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'closeable'
        QtMocHelpers::PropertyData<bool>(173, QMetaType::Bool, QMC::DefaultPropertyFlags, 61),
        // property 'icon'
        QtMocHelpers::PropertyData<QIcon>(174, 0x80000000 | 175, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 34),
        // property 'keepAbove'
        QtMocHelpers::PropertyData<bool>(176, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 36),
        // property 'keepBelow'
        QtMocHelpers::PropertyData<bool>(177, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 37),
        // property 'shadeable'
        QtMocHelpers::PropertyData<bool>(178, QMetaType::Bool, QMC::DefaultPropertyFlags, 63),
        // property 'shade'
        QtMocHelpers::PropertyData<bool>(179, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'minimizable'
        QtMocHelpers::PropertyData<bool>(180, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'minimized'
        QtMocHelpers::PropertyData<bool>(181, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 43),
        // property 'iconGeometry'
        QtMocHelpers::PropertyData<QRectF>(182, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'specialWindow'
        QtMocHelpers::PropertyData<bool>(183, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'demandsAttention'
        QtMocHelpers::PropertyData<bool>(184, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 38),
        // property 'caption'
        QtMocHelpers::PropertyData<QString>(185, QMetaType::QString, QMC::DefaultPropertyFlags, 48),
        // property 'minSize'
        QtMocHelpers::PropertyData<QSizeF>(186, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'maxSize'
        QtMocHelpers::PropertyData<QSizeF>(187, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'wantsInput'
        QtMocHelpers::PropertyData<bool>(188, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'transient'
        QtMocHelpers::PropertyData<bool>(189, QMetaType::Bool, QMC::DefaultPropertyFlags, 53),
        // property 'transientFor'
        QtMocHelpers::PropertyData<KWin::Window*>(190, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 53),
        // property 'modal'
        QtMocHelpers::PropertyData<bool>(191, QMetaType::Bool, QMC::DefaultPropertyFlags, 54),
        // property 'geometry'
        QtMocHelpers::PropertyData<QRectF>(192, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 19),
        // property 'frameGeometry'
        QtMocHelpers::PropertyData<QRectF>(193, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 19),
        // property 'move'
        QtMocHelpers::PropertyData<bool>(194, QMetaType::Bool, QMC::DefaultPropertyFlags, 56),
        // property 'resize'
        QtMocHelpers::PropertyData<bool>(195, QMetaType::Bool, QMC::DefaultPropertyFlags, 56),
        // property 'decorationHasAlpha'
        QtMocHelpers::PropertyData<bool>(196, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'noBorder'
        QtMocHelpers::PropertyData<bool>(197, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'providesContextHelp'
        QtMocHelpers::PropertyData<bool>(198, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'maximizable'
        QtMocHelpers::PropertyData<bool>(199, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'moveable'
        QtMocHelpers::PropertyData<bool>(200, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'moveableAcrossScreens'
        QtMocHelpers::PropertyData<bool>(201, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'resizeable'
        QtMocHelpers::PropertyData<bool>(202, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'desktopFileName'
        QtMocHelpers::PropertyData<QString>(203, QMetaType::QString, QMC::DefaultPropertyFlags, 65),
        // property 'hasApplicationMenu'
        QtMocHelpers::PropertyData<bool>(204, QMetaType::Bool, QMC::DefaultPropertyFlags, 67),
        // property 'applicationMenuActive'
        QtMocHelpers::PropertyData<bool>(205, QMetaType::Bool, QMC::DefaultPropertyFlags, 68),
        // property 'unresponsive'
        QtMocHelpers::PropertyData<bool>(206, QMetaType::Bool, QMC::DefaultPropertyFlags, 69),
        // property 'colorScheme'
        QtMocHelpers::PropertyData<QString>(207, QMetaType::QString, QMC::DefaultPropertyFlags, 47),
        // property 'layer'
        QtMocHelpers::PropertyData<KWin::Layer>(208, 0x80000000 | 209, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'hidden'
        QtMocHelpers::PropertyData<bool>(210, QMetaType::Bool, QMC::DefaultPropertyFlags, 71),
        // property 'tile'
        QtMocHelpers::PropertyData<KWin::Tile*>(35, 0x80000000 | 34, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 23),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Window, qt_meta_tag_ZN4KWin6WindowE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN4KWin6WindowE[] = {
    QMetaObject::SuperData::link<KWin::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject KWin::Window::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin6WindowE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin6WindowE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN4KWin6WindowE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4KWin6WindowE_t>.metaTypes,
    nullptr
} };

void KWin::Window::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Window *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->stackingOrderChanged(); break;
        case 1: _t->shadeChanged(); break;
        case 2: _t->opacityChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2]))); break;
        case 3: _t->damaged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 4: _t->inputTransformationChanged(); break;
        case 5: _t->geometryChanged(); break;
        case 6: _t->geometryShapeChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 7: _t->windowClosed((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<KWin::Deleted*>>(_a[2]))); break;
        case 8: _t->windowShown((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 9: _t->windowHidden((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 10: _t->shapedChanged(); break;
        case 11: _t->screenChanged(); break;
        case 12: _t->skipCloseAnimationChanged(); break;
        case 13: _t->windowRoleChanged(); break;
        case 14: _t->windowClassChanged(); break;
        case 15: _t->hasAlphaChanged(); break;
        case 16: _t->surfaceChanged(); break;
        case 17: _t->shadowChanged(); break;
        case 18: _t->bufferGeometryChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 19: _t->frameGeometryChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 20: _t->clientGeometryChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 21: _t->frameGeometryAboutToChange((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 22: _t->visibleGeometryChanged(); break;
        case 23: _t->tileChanged((*reinterpret_cast<std::add_pointer_t<KWin::Tile*>>(_a[1]))); break;
        case 24: _t->waylandWindowRadiusChanged((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 25: _t->waylandShadowColorChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->waylandBorderWidthChanged((*reinterpret_cast<std::add_pointer_t<qint32>>(_a[1]))); break;
        case 27: _t->waylandBorderColorChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 28: _t->waylandWindowEffectChanged((*reinterpret_cast<std::add_pointer_t<uint32_t>>(_a[1]))); break;
        case 29: _t->waylandWindowStartUpEffectChanged((*reinterpret_cast<std::add_pointer_t<uint32_t>>(_a[1]))); break;
        case 30: _t->fullScreenChanged(); break;
        case 31: _t->skipTaskbarChanged(); break;
        case 32: _t->skipPagerChanged(); break;
        case 33: _t->skipSwitcherChanged(); break;
        case 34: _t->iconChanged(); break;
        case 35: _t->activeChanged(); break;
        case 36: _t->keepAboveChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->keepBelowChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->demandsAttentionChanged(); break;
        case 39: _t->desktopPresenceChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 40: _t->desktopChanged(); break;
        case 41: _t->activitiesChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 42: _t->x11DesktopIdsChanged(); break;
        case 43: _t->minimizedChanged(); break;
        case 44: _t->clientMinimized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 45: _t->clientUnminimized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 46: _t->paletteChanged((*reinterpret_cast<std::add_pointer_t<QPalette>>(_a[1]))); break;
        case 47: _t->colorSchemeChanged(); break;
        case 48: _t->captionChanged(); break;
        case 49: _t->clientMaximizedStateAboutToChange((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MaximizeMode>>(_a[2]))); break;
        case 50: _t->clientMaximizedStateChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MaximizeMode>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 51: _t->clientMaximizedStateChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MaximizeMode>>(_a[2]))); break;
        case 52: _t->clientMaximizedStateChanged((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 53: _t->transientChanged(); break;
        case 54: _t->modalChanged(); break;
        case 55: _t->quickTileModeChanged(); break;
        case 56: _t->moveResizedChanged(); break;
        case 57: _t->moveResizeCursorChanged((*reinterpret_cast<std::add_pointer_t<CursorShape>>(_a[1]))); break;
        case 58: _t->clientStartUserMovedResized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 59: _t->clientStepUserMovedResized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[2]))); break;
        case 60: _t->clientFinishUserMovedResized((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 61: _t->closeableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 62: _t->minimizeableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 63: _t->shadeableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->maximizeableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 65: _t->desktopFileNameChanged(); break;
        case 66: _t->applicationMenuChanged(); break;
        case 67: _t->hasApplicationMenuChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 68: _t->applicationMenuActiveChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 69: _t->unresponsiveChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 70: _t->decorationChanged(); break;
        case 71: _t->hiddenChanged(); break;
        case 72: _t->lockScreenOverlayChanged(); break;
        case 73: _t->triggerSplitPreview((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1]))); break;
        case 74: _t->swapSplitWindow((*reinterpret_cast<std::add_pointer_t<KWin::Window*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 75: _t->waylandShadowChanged(); break;
        case 76: _t->scissorForceChange(); break;
        case 77: _t->closeWindow(); break;
        case 78: _t->onWindowRadiusChanged((*reinterpret_cast<std::add_pointer_t<float&>>(_a[1]))); break;
        case 79: _t->onThemeChange((*reinterpret_cast<std::add_pointer_t<bool&>>(_a[1]))); break;
        case 80: _t->setReadyForPainting(); break;
        case 81: _t->clearRules(); break;
        case 82: _t->shadeHover(); break;
        case 83: _t->shadeUnhover(); break;
        case 84: _t->setMaximize((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 85: _t->setMaximize((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 19:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 39:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 44:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 45:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 50:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 51:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            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< KWin::Window* >(); break;
            }
            break;
        case 58:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 59:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 60:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 73:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        case 74:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KWin::Window* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::stackingOrderChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::shadeChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , qreal )>(_a, &Window::opacityChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::damaged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::inputTransformationChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::geometryChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , const QRectF & )>(_a, &Window::geometryShapeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , KWin::Deleted * )>(_a, &Window::windowClosed, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::windowShown, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::windowHidden, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::shapedChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::screenChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::skipCloseAnimationChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::windowRoleChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::windowClassChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::hasAlphaChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::surfaceChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::shadowChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , const QRectF & )>(_a, &Window::bufferGeometryChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , const QRectF & )>(_a, &Window::frameGeometryChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , const QRectF & )>(_a, &Window::clientGeometryChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::frameGeometryAboutToChange, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::visibleGeometryChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Tile * )>(_a, &Window::tileChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(QPointF )>(_a, &Window::waylandWindowRadiusChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(QString )>(_a, &Window::waylandShadowColorChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(qint32 )>(_a, &Window::waylandBorderWidthChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(QString )>(_a, &Window::waylandBorderColorChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(uint32_t )>(_a, &Window::waylandWindowEffectChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(uint32_t )>(_a, &Window::waylandWindowStartUpEffectChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::fullScreenChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::skipTaskbarChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::skipPagerChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::skipSwitcherChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::iconChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::activeChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::keepAboveChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::keepBelowChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::demandsAttentionChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , int )>(_a, &Window::desktopPresenceChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::desktopChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::activitiesChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::x11DesktopIdsChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::minimizedChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , bool )>(_a, &Window::clientMinimized, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , bool )>(_a, &Window::clientUnminimized, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(const QPalette & )>(_a, &Window::paletteChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::colorSchemeChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::captionChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , MaximizeMode )>(_a, &Window::clientMaximizedStateAboutToChange, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , MaximizeMode , bool )>(_a, &Window::clientMaximizedStateChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , bool , bool )>(_a, &Window::clientMaximizedStateChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::transientChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::modalChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::quickTileModeChanged, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::moveResizedChanged, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(CursorShape )>(_a, &Window::moveResizeCursorChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::clientStartUserMovedResized, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , const QRectF & )>(_a, &Window::clientStepUserMovedResized, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::clientFinishUserMovedResized, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::closeableChanged, 61))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::minimizeableChanged, 62))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::shadeableChanged, 63))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::maximizeableChanged, 64))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::desktopFileNameChanged, 65))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::applicationMenuChanged, 66))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::hasApplicationMenuChanged, 67))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::applicationMenuActiveChanged, 68))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(bool )>(_a, &Window::unresponsiveChanged, 69))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::decorationChanged, 70))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::hiddenChanged, 71))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::lockScreenOverlayChanged, 72))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * )>(_a, &Window::triggerSplitPreview, 73))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)(KWin::Window * , int )>(_a, &Window::swapSplitWindow, 74))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::waylandShadowChanged, 75))
            return;
        if (QtMocHelpers::indexOfMethod<void (Window::*)()>(_a, &Window::scissorForceChange, 76))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 73:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< KWin::Window* >(); break;
        case 53:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<uint> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QRectF*>(_v) = _t->bufferGeometry(); break;
        case 1: *reinterpret_cast<QPointF*>(_v) = _t->pos(); break;
        case 2: *reinterpret_cast<QSizeF*>(_v) = _t->size(); break;
        case 3: *reinterpret_cast<qreal*>(_v) = _t->x(); break;
        case 4: *reinterpret_cast<qreal*>(_v) = _t->y(); break;
        case 5: *reinterpret_cast<qreal*>(_v) = _t->width(); break;
        case 6: *reinterpret_cast<qreal*>(_v) = _t->height(); break;
        case 7: *reinterpret_cast<qreal*>(_v) = _t->opacity(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->screen(); break;
        case 9: *reinterpret_cast<KWin::Output**>(_v) = _t->output(); break;
        case 10: *reinterpret_cast<QRectF*>(_v) = _t->rect(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->resourceName(); break;
        case 12: *reinterpret_cast<QString*>(_v) = _t->resourceClass(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->windowRole(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->isDesktop(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->isDock(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->isToolbar(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->isMenu(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->isNormalWindow(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->isDialog(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->isSplash(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->isUtility(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->isDropdownMenu(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->isPopupMenu(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->isTooltip(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->isNotification(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->isCriticalNotification(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->isAppletPopup(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->isOnScreenDisplay(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->isComboBox(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->isDNDIcon(); break;
        case 31: *reinterpret_cast<int*>(_v) = _t->windowType(); break;
        case 32: *reinterpret_cast<bool*>(_v) = _t->isClient(); break;
        case 33: *reinterpret_cast<bool*>(_v) = _t->isDeleted(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->shape(); break;
        case 35: *reinterpret_cast<bool*>(_v) = _t->skipsCloseAnimation(); break;
        case 36: *reinterpret_cast<bool*>(_v) = _t->isPopupWindow(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->isOutline(); break;
        case 38: *reinterpret_cast<bool*>(_v) = _t->isSplitBar(); break;
        case 39: *reinterpret_cast<bool*>(_v) = _t->isWaterMark(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->isWindowMenu(); break;
        case 41: *reinterpret_cast<bool*>(_v) = _t->isSplitMenu(); break;
        case 42: *reinterpret_cast<bool*>(_v) = _t->isSwitcherWin(); break;
        case 43: *reinterpret_cast<QUuid*>(_v) = _t->internalId(); break;
        case 44: *reinterpret_cast<int*>(_v) = _t->pid(); break;
        case 45: *reinterpret_cast<int*>(_v) = _t->stackingOrder(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->isFullScreen(); break;
        case 47: *reinterpret_cast<bool*>(_v) = _t->isFullScreenable(); break;
        case 48: *reinterpret_cast<bool*>(_v) = _t->isActive(); break;
        case 49: *reinterpret_cast<int*>(_v) = _t->desktop(); break;
        case 50: *reinterpret_cast<QList<KWin::VirtualDesktop*>*>(_v) = _t->desktops(); break;
        case 51: *reinterpret_cast<bool*>(_v) = _t->isOnAllDesktops(); break;
        case 52: *reinterpret_cast<QStringList*>(_v) = _t->activities(); break;
        case 53: *reinterpret_cast<QList<uint>*>(_v) = _t->x11DesktopIds(); break;
        case 54: *reinterpret_cast<bool*>(_v) = _t->skipTaskbar(); break;
        case 55: *reinterpret_cast<bool*>(_v) = _t->skipPager(); break;
        case 56: *reinterpret_cast<bool*>(_v) = _t->skipSwitcher(); break;
        case 57: *reinterpret_cast<bool*>(_v) = _t->isCloseable(); break;
        case 58: *reinterpret_cast<QIcon*>(_v) = _t->icon(); break;
        case 59: *reinterpret_cast<bool*>(_v) = _t->keepAbove(); break;
        case 60: *reinterpret_cast<bool*>(_v) = _t->keepBelow(); break;
        case 61: *reinterpret_cast<bool*>(_v) = _t->isShadeable(); break;
        case 62: *reinterpret_cast<bool*>(_v) = _t->isShade(); break;
        case 63: *reinterpret_cast<bool*>(_v) = _t->isMinimizable(); break;
        case 64: *reinterpret_cast<bool*>(_v) = _t->isMinimized(); break;
        case 65: *reinterpret_cast<QRectF*>(_v) = _t->iconGeometry(); break;
        case 66: *reinterpret_cast<bool*>(_v) = _t->isSpecialWindow(); break;
        case 67: *reinterpret_cast<bool*>(_v) = _t->isDemandingAttention(); break;
        case 68: *reinterpret_cast<QString*>(_v) = _t->caption(); break;
        case 69: *reinterpret_cast<QSizeF*>(_v) = _t->minSize(); break;
        case 70: *reinterpret_cast<QSizeF*>(_v) = _t->maxSize(); break;
        case 71: *reinterpret_cast<bool*>(_v) = _t->wantsInput(); break;
        case 72: *reinterpret_cast<bool*>(_v) = _t->isTransient(); break;
        case 73: *reinterpret_cast<KWin::Window**>(_v) = _t->transientFor(); break;
        case 74: *reinterpret_cast<bool*>(_v) = _t->isModal(); break;
        case 75: *reinterpret_cast<QRectF*>(_v) = _t->frameGeometry(); break;
        case 76: *reinterpret_cast<QRectF*>(_v) = _t->frameGeometry(); break;
        case 77: *reinterpret_cast<bool*>(_v) = _t->isInteractiveMove(); break;
        case 78: *reinterpret_cast<bool*>(_v) = _t->isInteractiveResize(); break;
        case 79: *reinterpret_cast<bool*>(_v) = _t->decorationHasAlpha(); break;
        case 80: *reinterpret_cast<bool*>(_v) = _t->noBorder(); break;
        case 81: *reinterpret_cast<bool*>(_v) = _t->providesContextHelp(); break;
        case 82: *reinterpret_cast<bool*>(_v) = _t->isMaximizable(); break;
        case 83: *reinterpret_cast<bool*>(_v) = _t->isMovable(); break;
        case 84: *reinterpret_cast<bool*>(_v) = _t->isMovableAcrossScreens(); break;
        case 85: *reinterpret_cast<bool*>(_v) = _t->isResizable(); break;
        case 86: *reinterpret_cast<QString*>(_v) = _t->desktopFileName(); break;
        case 87: *reinterpret_cast<bool*>(_v) = _t->hasApplicationMenu(); break;
        case 88: *reinterpret_cast<bool*>(_v) = _t->applicationMenuActive(); break;
        case 89: *reinterpret_cast<bool*>(_v) = _t->unresponsive(); break;
        case 90: *reinterpret_cast<QString*>(_v) = _t->colorScheme(); break;
        case 91: *reinterpret_cast<KWin::Layer*>(_v) = _t->layer(); break;
        case 92: *reinterpret_cast<bool*>(_v) = _t->isHiddenInternal(); break;
        case 93: *reinterpret_cast<KWin::Tile**>(_v) = _t->tile(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 7: _t->setOpacity(*reinterpret_cast<qreal*>(_v)); break;
        case 35: _t->setSkipCloseAnimation(*reinterpret_cast<bool*>(_v)); break;
        case 46: _t->setFullScreen(*reinterpret_cast<bool*>(_v)); break;
        case 49: _t->setDesktop(*reinterpret_cast<int*>(_v)); break;
        case 50: _t->setDesktops(*reinterpret_cast<QList<KWin::VirtualDesktop*>*>(_v)); break;
        case 51: _t->setOnAllDesktops(*reinterpret_cast<bool*>(_v)); break;
        case 52: _t->setOnActivities(*reinterpret_cast<QStringList*>(_v)); break;
        case 54: _t->setSkipTaskbar(*reinterpret_cast<bool*>(_v)); break;
        case 55: _t->setSkipPager(*reinterpret_cast<bool*>(_v)); break;
        case 56: _t->setSkipSwitcher(*reinterpret_cast<bool*>(_v)); break;
        case 59: _t->setKeepAbove(*reinterpret_cast<bool*>(_v)); break;
        case 60: _t->setKeepBelow(*reinterpret_cast<bool*>(_v)); break;
        case 62: _t->setShade(*reinterpret_cast<bool*>(_v)); break;
        case 64: _t->setMinimized(*reinterpret_cast<bool*>(_v)); break;
        case 67: _t->demandAttention(*reinterpret_cast<bool*>(_v)); break;
        case 75: _t->moveResizeGeometry(*reinterpret_cast<QRectF*>(_v)); break;
        case 76: _t->moveResizeGeometry(*reinterpret_cast<QRectF*>(_v)); break;
        case 80: _t->setNoBorder(*reinterpret_cast<bool*>(_v)); break;
        case 93: _t->setTile(*reinterpret_cast<KWin::Tile**>(_v)); break;
        default: break;
        }
    }
}

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

void *KWin::Window::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4KWin6WindowE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int KWin::Window::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 86)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 86;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 86)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 86;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 94;
    }
    return _id;
}

// SIGNAL 0
void KWin::Window::stackingOrderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void KWin::Window::shadeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void KWin::Window::opacityChanged(KWin::Window * _t1, qreal _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void KWin::Window::damaged(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void KWin::Window::inputTransformationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void KWin::Window::geometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void KWin::Window::geometryShapeChanged(KWin::Window * _t1, const QRectF & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void KWin::Window::windowClosed(KWin::Window * _t1, KWin::Deleted * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}

// SIGNAL 8
void KWin::Window::windowShown(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void KWin::Window::windowHidden(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void KWin::Window::shapedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void KWin::Window::screenChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void KWin::Window::skipCloseAnimationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void KWin::Window::windowRoleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void KWin::Window::windowClassChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void KWin::Window::hasAlphaChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void KWin::Window::surfaceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void KWin::Window::shadowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void KWin::Window::bufferGeometryChanged(KWin::Window * _t1, const QRectF & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2);
}

// SIGNAL 19
void KWin::Window::frameGeometryChanged(KWin::Window * _t1, const QRectF & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void KWin::Window::clientGeometryChanged(KWin::Window * _t1, const QRectF & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2);
}

// SIGNAL 21
void KWin::Window::frameGeometryAboutToChange(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void KWin::Window::visibleGeometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void KWin::Window::tileChanged(KWin::Tile * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void KWin::Window::waylandWindowRadiusChanged(QPointF _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void KWin::Window::waylandShadowColorChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void KWin::Window::waylandBorderWidthChanged(qint32 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void KWin::Window::waylandBorderColorChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void KWin::Window::waylandWindowEffectChanged(uint32_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void KWin::Window::waylandWindowStartUpEffectChanged(uint32_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void KWin::Window::fullScreenChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void KWin::Window::skipTaskbarChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 31, nullptr);
}

// SIGNAL 32
void KWin::Window::skipPagerChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void KWin::Window::skipSwitcherChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void KWin::Window::iconChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void KWin::Window::activeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void KWin::Window::keepAboveChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

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

// SIGNAL 38
void KWin::Window::demandsAttentionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void KWin::Window::desktopPresenceChanged(KWin::Window * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1, _t2);
}

// SIGNAL 40
void KWin::Window::desktopChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 40, nullptr);
}

// SIGNAL 41
void KWin::Window::activitiesChanged(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void KWin::Window::x11DesktopIdsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 42, nullptr);
}

// SIGNAL 43
void KWin::Window::minimizedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 43, nullptr);
}

// SIGNAL 44
void KWin::Window::clientMinimized(KWin::Window * _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1, _t2);
}

// SIGNAL 45
void KWin::Window::clientUnminimized(KWin::Window * _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1, _t2);
}

// SIGNAL 46
void KWin::Window::paletteChanged(const QPalette & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void KWin::Window::colorSchemeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 47, nullptr);
}

// SIGNAL 48
void KWin::Window::captionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 48, nullptr);
}

// SIGNAL 49
void KWin::Window::clientMaximizedStateAboutToChange(KWin::Window * _t1, MaximizeMode _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1, _t2);
}

// SIGNAL 50
void KWin::Window::clientMaximizedStateChanged(KWin::Window * _t1, MaximizeMode _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 50, nullptr, _t1, _t2, _t3);
}

// SIGNAL 52
void KWin::Window::clientMaximizedStateChanged(KWin::Window * _t1, bool _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1, _t2, _t3);
}

// SIGNAL 53
void KWin::Window::transientChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 53, nullptr);
}

// SIGNAL 54
void KWin::Window::modalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 54, nullptr);
}

// SIGNAL 55
void KWin::Window::quickTileModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 55, nullptr);
}

// SIGNAL 56
void KWin::Window::moveResizedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 56, nullptr);
}

// SIGNAL 57
void KWin::Window::moveResizeCursorChanged(CursorShape _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 57, nullptr, _t1);
}

// SIGNAL 58
void KWin::Window::clientStartUserMovedResized(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 58, nullptr, _t1);
}

// SIGNAL 59
void KWin::Window::clientStepUserMovedResized(KWin::Window * _t1, const QRectF & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 59, nullptr, _t1, _t2);
}

// SIGNAL 60
void KWin::Window::clientFinishUserMovedResized(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 60, nullptr, _t1);
}

// SIGNAL 61
void KWin::Window::closeableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 61, nullptr, _t1);
}

// SIGNAL 62
void KWin::Window::minimizeableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 62, nullptr, _t1);
}

// SIGNAL 63
void KWin::Window::shadeableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 63, nullptr, _t1);
}

// SIGNAL 64
void KWin::Window::maximizeableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 64, nullptr, _t1);
}

// SIGNAL 65
void KWin::Window::desktopFileNameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 65, nullptr);
}

// SIGNAL 66
void KWin::Window::applicationMenuChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 66, nullptr);
}

// SIGNAL 67
void KWin::Window::hasApplicationMenuChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 67, nullptr, _t1);
}

// SIGNAL 68
void KWin::Window::applicationMenuActiveChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 68, nullptr, _t1);
}

// SIGNAL 69
void KWin::Window::unresponsiveChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 69, nullptr, _t1);
}

// SIGNAL 70
void KWin::Window::decorationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 70, nullptr);
}

// SIGNAL 71
void KWin::Window::hiddenChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 71, nullptr);
}

// SIGNAL 72
void KWin::Window::lockScreenOverlayChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 72, nullptr);
}

// SIGNAL 73
void KWin::Window::triggerSplitPreview(KWin::Window * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 73, nullptr, _t1);
}

// SIGNAL 74
void KWin::Window::swapSplitWindow(KWin::Window * _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 74, nullptr, _t1, _t2);
}

// SIGNAL 75
void KWin::Window::waylandShadowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 75, nullptr);
}

// SIGNAL 76
void KWin::Window::scissorForceChange()
{
    QMetaObject::activate(this, &staticMetaObject, 76, nullptr);
}
QT_WARNING_POP
