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

#include "../src/kwin-5.4.3/scripting/workspace_wrapper.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'workspace_wrapper.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.6.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_KWin__WorkspaceWrapper_t {
    QByteArrayData data[151];
    char stringdata0[2581];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KWin__WorkspaceWrapper_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KWin__WorkspaceWrapper_t qt_meta_stringdata_KWin__WorkspaceWrapper = {
    {
QT_MOC_LITERAL(0, 0, 22), // "KWin::WorkspaceWrapper"
QT_MOC_LITERAL(1, 23, 22), // "desktopPresenceChanged"
QT_MOC_LITERAL(2, 46, 0), // ""
QT_MOC_LITERAL(3, 47, 21), // "KWin::AbstractClient*"
QT_MOC_LITERAL(4, 69, 6), // "client"
QT_MOC_LITERAL(5, 76, 7), // "desktop"
QT_MOC_LITERAL(6, 84, 21), // "currentDesktopChanged"
QT_MOC_LITERAL(7, 106, 11), // "clientAdded"
QT_MOC_LITERAL(8, 118, 13), // "KWin::Client*"
QT_MOC_LITERAL(9, 132, 13), // "clientRemoved"
QT_MOC_LITERAL(10, 146, 14), // "clientManaging"
QT_MOC_LITERAL(11, 161, 15), // "clientMinimized"
QT_MOC_LITERAL(12, 177, 17), // "clientUnminimized"
QT_MOC_LITERAL(13, 195, 14), // "clientRestored"
QT_MOC_LITERAL(14, 210, 17), // "clientMaximizeSet"
QT_MOC_LITERAL(15, 228, 1), // "h"
QT_MOC_LITERAL(16, 230, 1), // "v"
QT_MOC_LITERAL(17, 232, 16), // "killWindowCalled"
QT_MOC_LITERAL(18, 249, 15), // "clientActivated"
QT_MOC_LITERAL(19, 265, 19), // "clientFullScreenSet"
QT_MOC_LITERAL(20, 285, 10), // "fullScreen"
QT_MOC_LITERAL(21, 296, 4), // "user"
QT_MOC_LITERAL(22, 301, 18), // "clientSetKeepAbove"
QT_MOC_LITERAL(23, 320, 9), // "keepAbove"
QT_MOC_LITERAL(24, 330, 21), // "numberDesktopsChanged"
QT_MOC_LITERAL(25, 352, 19), // "oldNumberOfDesktops"
QT_MOC_LITERAL(26, 372, 20), // "desktopLayoutChanged"
QT_MOC_LITERAL(27, 393, 29), // "clientDemandsAttentionChanged"
QT_MOC_LITERAL(28, 423, 3), // "set"
QT_MOC_LITERAL(29, 427, 20), // "numberScreensChanged"
QT_MOC_LITERAL(30, 448, 5), // "count"
QT_MOC_LITERAL(31, 454, 13), // "screenResized"
QT_MOC_LITERAL(32, 468, 6), // "screen"
QT_MOC_LITERAL(33, 475, 22), // "currentActivityChanged"
QT_MOC_LITERAL(34, 498, 2), // "id"
QT_MOC_LITERAL(35, 501, 17), // "activitiesChanged"
QT_MOC_LITERAL(36, 519, 13), // "activityAdded"
QT_MOC_LITERAL(37, 533, 15), // "activityRemoved"
QT_MOC_LITERAL(38, 549, 24), // "virtualScreenSizeChanged"
QT_MOC_LITERAL(39, 574, 28), // "virtualScreenGeometryChanged"
QT_MOC_LITERAL(40, 603, 21), // "slotSwitchDesktopNext"
QT_MOC_LITERAL(41, 625, 25), // "slotSwitchDesktopPrevious"
QT_MOC_LITERAL(42, 651, 22), // "slotSwitchDesktopRight"
QT_MOC_LITERAL(43, 674, 21), // "slotSwitchDesktopLeft"
QT_MOC_LITERAL(44, 696, 19), // "slotSwitchDesktopUp"
QT_MOC_LITERAL(45, 716, 21), // "slotSwitchDesktopDown"
QT_MOC_LITERAL(46, 738, 22), // "slotSwitchToNextScreen"
QT_MOC_LITERAL(47, 761, 22), // "slotWindowToNextScreen"
QT_MOC_LITERAL(48, 784, 21), // "slotToggleShowDesktop"
QT_MOC_LITERAL(49, 806, 18), // "slotWindowMaximize"
QT_MOC_LITERAL(50, 825, 26), // "slotWindowMaximizeVertical"
QT_MOC_LITERAL(51, 852, 28), // "slotWindowMaximizeHorizontal"
QT_MOC_LITERAL(52, 881, 18), // "slotWindowMinimize"
QT_MOC_LITERAL(53, 900, 15), // "slotWindowShade"
QT_MOC_LITERAL(54, 916, 15), // "slotWindowRaise"
QT_MOC_LITERAL(55, 932, 15), // "slotWindowLower"
QT_MOC_LITERAL(56, 948, 22), // "slotWindowRaiseOrLower"
QT_MOC_LITERAL(57, 971, 27), // "slotActivateAttentionWindow"
QT_MOC_LITERAL(58, 999, 18), // "slotWindowPackLeft"
QT_MOC_LITERAL(59, 1018, 19), // "slotWindowPackRight"
QT_MOC_LITERAL(60, 1038, 16), // "slotWindowPackUp"
QT_MOC_LITERAL(61, 1055, 18), // "slotWindowPackDown"
QT_MOC_LITERAL(62, 1074, 24), // "slotWindowGrowHorizontal"
QT_MOC_LITERAL(63, 1099, 22), // "slotWindowGrowVertical"
QT_MOC_LITERAL(64, 1122, 26), // "slotWindowShrinkHorizontal"
QT_MOC_LITERAL(65, 1149, 24), // "slotWindowShrinkVertical"
QT_MOC_LITERAL(66, 1174, 23), // "slotWindowQuickTileLeft"
QT_MOC_LITERAL(67, 1198, 24), // "slotWindowQuickTileRight"
QT_MOC_LITERAL(68, 1223, 22), // "slotWindowQuickTileTop"
QT_MOC_LITERAL(69, 1246, 25), // "slotWindowQuickTileBottom"
QT_MOC_LITERAL(70, 1272, 26), // "slotWindowQuickTileTopLeft"
QT_MOC_LITERAL(71, 1299, 27), // "slotWindowQuickTileTopRight"
QT_MOC_LITERAL(72, 1327, 29), // "slotWindowQuickTileBottomLeft"
QT_MOC_LITERAL(73, 1357, 30), // "slotWindowQuickTileBottomRight"
QT_MOC_LITERAL(74, 1388, 18), // "slotSwitchWindowUp"
QT_MOC_LITERAL(75, 1407, 20), // "slotSwitchWindowDown"
QT_MOC_LITERAL(76, 1428, 21), // "slotSwitchWindowRight"
QT_MOC_LITERAL(77, 1450, 20), // "slotSwitchWindowLeft"
QT_MOC_LITERAL(78, 1471, 25), // "slotIncreaseWindowOpacity"
QT_MOC_LITERAL(79, 1497, 22), // "slotLowerWindowOpacity"
QT_MOC_LITERAL(80, 1520, 20), // "slotWindowOperations"
QT_MOC_LITERAL(81, 1541, 15), // "slotWindowClose"
QT_MOC_LITERAL(82, 1557, 14), // "slotWindowMove"
QT_MOC_LITERAL(83, 1572, 16), // "slotWindowResize"
QT_MOC_LITERAL(84, 1589, 15), // "slotWindowAbove"
QT_MOC_LITERAL(85, 1605, 15), // "slotWindowBelow"
QT_MOC_LITERAL(86, 1621, 23), // "slotWindowOnAllDesktops"
QT_MOC_LITERAL(87, 1645, 20), // "slotWindowFullScreen"
QT_MOC_LITERAL(88, 1666, 18), // "slotWindowNoBorder"
QT_MOC_LITERAL(89, 1685, 23), // "slotWindowToNextDesktop"
QT_MOC_LITERAL(90, 1709, 27), // "slotWindowToPreviousDesktop"
QT_MOC_LITERAL(91, 1737, 24), // "slotWindowToDesktopRight"
QT_MOC_LITERAL(92, 1762, 23), // "slotWindowToDesktopLeft"
QT_MOC_LITERAL(93, 1786, 21), // "slotWindowToDesktopUp"
QT_MOC_LITERAL(94, 1808, 23), // "slotWindowToDesktopDown"
QT_MOC_LITERAL(95, 1832, 11), // "showOutline"
QT_MOC_LITERAL(96, 1844, 8), // "geometry"
QT_MOC_LITERAL(97, 1853, 1), // "x"
QT_MOC_LITERAL(98, 1855, 1), // "y"
QT_MOC_LITERAL(99, 1857, 5), // "width"
QT_MOC_LITERAL(100, 1863, 6), // "height"
QT_MOC_LITERAL(101, 1870, 11), // "hideOutline"
QT_MOC_LITERAL(102, 1882, 22), // "setupClientConnections"
QT_MOC_LITERAL(103, 1905, 10), // "clientList"
QT_MOC_LITERAL(104, 1916, 20), // "QList<KWin::Client*>"
QT_MOC_LITERAL(105, 1937, 10), // "clientArea"
QT_MOC_LITERAL(106, 1948, 16), // "ClientAreaOption"
QT_MOC_LITERAL(107, 1965, 6), // "option"
QT_MOC_LITERAL(108, 1972, 5), // "point"
QT_MOC_LITERAL(109, 1978, 19), // "const KWin::Client*"
QT_MOC_LITERAL(110, 1998, 11), // "desktopName"
QT_MOC_LITERAL(111, 2010, 18), // "supportInformation"
QT_MOC_LITERAL(112, 2029, 9), // "getClient"
QT_MOC_LITERAL(113, 2039, 8), // "windowId"
QT_MOC_LITERAL(114, 2048, 14), // "currentDesktop"
QT_MOC_LITERAL(115, 2063, 12), // "activeClient"
QT_MOC_LITERAL(116, 2076, 15), // "desktopGridSize"
QT_MOC_LITERAL(117, 2092, 16), // "desktopGridWidth"
QT_MOC_LITERAL(118, 2109, 17), // "desktopGridHeight"
QT_MOC_LITERAL(119, 2127, 14), // "workspaceWidth"
QT_MOC_LITERAL(120, 2142, 15), // "workspaceHeight"
QT_MOC_LITERAL(121, 2158, 13), // "workspaceSize"
QT_MOC_LITERAL(122, 2172, 8), // "desktops"
QT_MOC_LITERAL(123, 2181, 11), // "displaySize"
QT_MOC_LITERAL(124, 2193, 12), // "displayWidth"
QT_MOC_LITERAL(125, 2206, 13), // "displayHeight"
QT_MOC_LITERAL(126, 2220, 12), // "activeScreen"
QT_MOC_LITERAL(127, 2233, 10), // "numScreens"
QT_MOC_LITERAL(128, 2244, 15), // "currentActivity"
QT_MOC_LITERAL(129, 2260, 10), // "activities"
QT_MOC_LITERAL(130, 2271, 17), // "virtualScreenSize"
QT_MOC_LITERAL(131, 2289, 21), // "virtualScreenGeometry"
QT_MOC_LITERAL(132, 2311, 13), // "PlacementArea"
QT_MOC_LITERAL(133, 2325, 12), // "MovementArea"
QT_MOC_LITERAL(134, 2338, 12), // "MaximizeArea"
QT_MOC_LITERAL(135, 2351, 16), // "MaximizeFullArea"
QT_MOC_LITERAL(136, 2368, 14), // "FullScreenArea"
QT_MOC_LITERAL(137, 2383, 8), // "WorkArea"
QT_MOC_LITERAL(138, 2392, 8), // "FullArea"
QT_MOC_LITERAL(139, 2401, 10), // "ScreenArea"
QT_MOC_LITERAL(140, 2412, 14), // "ElectricBorder"
QT_MOC_LITERAL(141, 2427, 11), // "ElectricTop"
QT_MOC_LITERAL(142, 2439, 16), // "ElectricTopRight"
QT_MOC_LITERAL(143, 2456, 13), // "ElectricRight"
QT_MOC_LITERAL(144, 2470, 19), // "ElectricBottomRight"
QT_MOC_LITERAL(145, 2490, 14), // "ElectricBottom"
QT_MOC_LITERAL(146, 2505, 18), // "ElectricBottomLeft"
QT_MOC_LITERAL(147, 2524, 12), // "ElectricLeft"
QT_MOC_LITERAL(148, 2537, 15), // "ElectricTopLeft"
QT_MOC_LITERAL(149, 2553, 14), // "ELECTRIC_COUNT"
QT_MOC_LITERAL(150, 2568, 12) // "ElectricNone"

    },
    "KWin::WorkspaceWrapper\0desktopPresenceChanged\0"
    "\0KWin::AbstractClient*\0client\0desktop\0"
    "currentDesktopChanged\0clientAdded\0"
    "KWin::Client*\0clientRemoved\0clientManaging\0"
    "clientMinimized\0clientUnminimized\0"
    "clientRestored\0clientMaximizeSet\0h\0v\0"
    "killWindowCalled\0clientActivated\0"
    "clientFullScreenSet\0fullScreen\0user\0"
    "clientSetKeepAbove\0keepAbove\0"
    "numberDesktopsChanged\0oldNumberOfDesktops\0"
    "desktopLayoutChanged\0clientDemandsAttentionChanged\0"
    "set\0numberScreensChanged\0count\0"
    "screenResized\0screen\0currentActivityChanged\0"
    "id\0activitiesChanged\0activityAdded\0"
    "activityRemoved\0virtualScreenSizeChanged\0"
    "virtualScreenGeometryChanged\0"
    "slotSwitchDesktopNext\0slotSwitchDesktopPrevious\0"
    "slotSwitchDesktopRight\0slotSwitchDesktopLeft\0"
    "slotSwitchDesktopUp\0slotSwitchDesktopDown\0"
    "slotSwitchToNextScreen\0slotWindowToNextScreen\0"
    "slotToggleShowDesktop\0slotWindowMaximize\0"
    "slotWindowMaximizeVertical\0"
    "slotWindowMaximizeHorizontal\0"
    "slotWindowMinimize\0slotWindowShade\0"
    "slotWindowRaise\0slotWindowLower\0"
    "slotWindowRaiseOrLower\0"
    "slotActivateAttentionWindow\0"
    "slotWindowPackLeft\0slotWindowPackRight\0"
    "slotWindowPackUp\0slotWindowPackDown\0"
    "slotWindowGrowHorizontal\0"
    "slotWindowGrowVertical\0"
    "slotWindowShrinkHorizontal\0"
    "slotWindowShrinkVertical\0"
    "slotWindowQuickTileLeft\0"
    "slotWindowQuickTileRight\0"
    "slotWindowQuickTileTop\0slotWindowQuickTileBottom\0"
    "slotWindowQuickTileTopLeft\0"
    "slotWindowQuickTileTopRight\0"
    "slotWindowQuickTileBottomLeft\0"
    "slotWindowQuickTileBottomRight\0"
    "slotSwitchWindowUp\0slotSwitchWindowDown\0"
    "slotSwitchWindowRight\0slotSwitchWindowLeft\0"
    "slotIncreaseWindowOpacity\0"
    "slotLowerWindowOpacity\0slotWindowOperations\0"
    "slotWindowClose\0slotWindowMove\0"
    "slotWindowResize\0slotWindowAbove\0"
    "slotWindowBelow\0slotWindowOnAllDesktops\0"
    "slotWindowFullScreen\0slotWindowNoBorder\0"
    "slotWindowToNextDesktop\0"
    "slotWindowToPreviousDesktop\0"
    "slotWindowToDesktopRight\0"
    "slotWindowToDesktopLeft\0slotWindowToDesktopUp\0"
    "slotWindowToDesktopDown\0showOutline\0"
    "geometry\0x\0y\0width\0height\0hideOutline\0"
    "setupClientConnections\0clientList\0"
    "QList<KWin::Client*>\0clientArea\0"
    "ClientAreaOption\0option\0point\0"
    "const KWin::Client*\0desktopName\0"
    "supportInformation\0getClient\0windowId\0"
    "currentDesktop\0activeClient\0desktopGridSize\0"
    "desktopGridWidth\0desktopGridHeight\0"
    "workspaceWidth\0workspaceHeight\0"
    "workspaceSize\0desktops\0displaySize\0"
    "displayWidth\0displayHeight\0activeScreen\0"
    "numScreens\0currentActivity\0activities\0"
    "virtualScreenSize\0virtualScreenGeometry\0"
    "PlacementArea\0MovementArea\0MaximizeArea\0"
    "MaximizeFullArea\0FullScreenArea\0"
    "WorkArea\0FullArea\0ScreenArea\0"
    "ElectricBorder\0ElectricTop\0ElectricTopRight\0"
    "ElectricRight\0ElectricBottomRight\0"
    "ElectricBottom\0ElectricBottomLeft\0"
    "ElectricLeft\0ElectricTopLeft\0"
    "ELECTRIC_COUNT\0ElectricNone"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KWin__WorkspaceWrapper[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      90,   14, // methods
      18,  644, // properties
       2,  716, // enums/sets
       0,    0, // constructors
       0,       // flags
      24,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,  464,    2, 0x06 /* Public */,
       6,    2,  469,    2, 0x06 /* Public */,
       7,    1,  474,    2, 0x06 /* Public */,
       9,    1,  477,    2, 0x06 /* Public */,
      10,    1,  480,    2, 0x06 /* Public */,
      11,    1,  483,    2, 0x06 /* Public */,
      12,    1,  486,    2, 0x06 /* Public */,
      13,    1,  489,    2, 0x06 /* Public */,
      14,    3,  492,    2, 0x06 /* Public */,
      17,    1,  499,    2, 0x06 /* Public */,
      18,    1,  502,    2, 0x06 /* Public */,
      19,    3,  505,    2, 0x06 /* Public */,
      22,    2,  512,    2, 0x06 /* Public */,
      24,    1,  517,    2, 0x06 /* Public */,
      26,    0,  520,    2, 0x06 /* Public */,
      27,    2,  521,    2, 0x06 /* Public */,
      29,    1,  526,    2, 0x06 /* Public */,
      31,    1,  529,    2, 0x06 /* Public */,
      33,    1,  532,    2, 0x06 /* Public */,
      35,    1,  535,    2, 0x06 /* Public */,
      36,    1,  538,    2, 0x06 /* Public */,
      37,    1,  541,    2, 0x06 /* Public */,
      38,    0,  544,    2, 0x06 /* Public */,
      39,    0,  545,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      40,    0,  546,    2, 0x0a /* Public */,
      41,    0,  547,    2, 0x0a /* Public */,
      42,    0,  548,    2, 0x0a /* Public */,
      43,    0,  549,    2, 0x0a /* Public */,
      44,    0,  550,    2, 0x0a /* Public */,
      45,    0,  551,    2, 0x0a /* Public */,
      46,    0,  552,    2, 0x0a /* Public */,
      47,    0,  553,    2, 0x0a /* Public */,
      48,    0,  554,    2, 0x0a /* Public */,
      49,    0,  555,    2, 0x0a /* Public */,
      50,    0,  556,    2, 0x0a /* Public */,
      51,    0,  557,    2, 0x0a /* Public */,
      52,    0,  558,    2, 0x0a /* Public */,
      53,    0,  559,    2, 0x0a /* Public */,
      54,    0,  560,    2, 0x0a /* Public */,
      55,    0,  561,    2, 0x0a /* Public */,
      56,    0,  562,    2, 0x0a /* Public */,
      57,    0,  563,    2, 0x0a /* Public */,
      58,    0,  564,    2, 0x0a /* Public */,
      59,    0,  565,    2, 0x0a /* Public */,
      60,    0,  566,    2, 0x0a /* Public */,
      61,    0,  567,    2, 0x0a /* Public */,
      62,    0,  568,    2, 0x0a /* Public */,
      63,    0,  569,    2, 0x0a /* Public */,
      64,    0,  570,    2, 0x0a /* Public */,
      65,    0,  571,    2, 0x0a /* Public */,
      66,    0,  572,    2, 0x0a /* Public */,
      67,    0,  573,    2, 0x0a /* Public */,
      68,    0,  574,    2, 0x0a /* Public */,
      69,    0,  575,    2, 0x0a /* Public */,
      70,    0,  576,    2, 0x0a /* Public */,
      71,    0,  577,    2, 0x0a /* Public */,
      72,    0,  578,    2, 0x0a /* Public */,
      73,    0,  579,    2, 0x0a /* Public */,
      74,    0,  580,    2, 0x0a /* Public */,
      75,    0,  581,    2, 0x0a /* Public */,
      76,    0,  582,    2, 0x0a /* Public */,
      77,    0,  583,    2, 0x0a /* Public */,
      78,    0,  584,    2, 0x0a /* Public */,
      79,    0,  585,    2, 0x0a /* Public */,
      80,    0,  586,    2, 0x0a /* Public */,
      81,    0,  587,    2, 0x0a /* Public */,
      82,    0,  588,    2, 0x0a /* Public */,
      83,    0,  589,    2, 0x0a /* Public */,
      84,    0,  590,    2, 0x0a /* Public */,
      85,    0,  591,    2, 0x0a /* Public */,
      86,    0,  592,    2, 0x0a /* Public */,
      87,    0,  593,    2, 0x0a /* Public */,
      88,    0,  594,    2, 0x0a /* Public */,
      89,    0,  595,    2, 0x0a /* Public */,
      90,    0,  596,    2, 0x0a /* Public */,
      91,    0,  597,    2, 0x0a /* Public */,
      92,    0,  598,    2, 0x0a /* Public */,
      93,    0,  599,    2, 0x0a /* Public */,
      94,    0,  600,    2, 0x0a /* Public */,
      95,    1,  601,    2, 0x0a /* Public */,
      95,    4,  604,    2, 0x0a /* Public */,
     101,    0,  613,    2, 0x0a /* Public */,
     102,    1,  614,    2, 0x08 /* Private */,

 // methods: name, argc, parameters, tag, flags
     103,    0,  617,    2, 0x02 /* Public */,
     105,    3,  618,    2, 0x42 /* Public | isScriptable */,
     105,    3,  625,    2, 0x42 /* Public | isScriptable */,
     105,    2,  632,    2, 0x42 /* Public | isScriptable */,
     110,    1,  637,    2, 0x42 /* Public | isScriptable */,
     111,    0,  640,    2, 0x42 /* Public | isScriptable */,
     112,    1,  641,    2, 0x42 /* Public | isScriptable */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::Int,    4,    5,
    QMetaType::Void, QMetaType::Int, 0x80000000 | 3,    5,    4,
    QMetaType::Void, 0x80000000 | 8,    4,
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 8,    4,
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 8,    4,
    QMetaType::Void, 0x80000000 | 3, QMetaType::Bool, QMetaType::Bool,    4,   15,   16,
    QMetaType::Void, 0x80000000 | 8,    4,
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 8, QMetaType::Bool, QMetaType::Bool,    4,   20,   21,
    QMetaType::Void, 0x80000000 | 8, QMetaType::Bool,    4,   23,
    QMetaType::Void, QMetaType::UInt,   25,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 3, QMetaType::Bool,    4,   28,
    QMetaType::Void, QMetaType::Int,   30,
    QMetaType::Void, QMetaType::Int,   32,
    QMetaType::Void, QMetaType::QString,   34,
    QMetaType::Void, QMetaType::QString,   34,
    QMetaType::Void, QMetaType::QString,   34,
    QMetaType::Void, QMetaType::QString,   34,
    QMetaType::Void,
    QMetaType::Void,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QRect,   96,
    QMetaType::Void, QMetaType::Int, QMetaType::Int, QMetaType::Int, QMetaType::Int,   97,   98,   99,  100,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 8,    4,

 // methods: parameters
    0x80000000 | 104,
    QMetaType::QRect, 0x80000000 | 106, QMetaType::Int, QMetaType::Int,  107,   32,    5,
    QMetaType::QRect, 0x80000000 | 106, QMetaType::QPoint, QMetaType::Int,  107,  108,    5,
    QMetaType::QRect, 0x80000000 | 106, 0x80000000 | 109,  107,    4,
    QMetaType::QString, QMetaType::Int,    5,
    QMetaType::QString,
    0x80000000 | 8, QMetaType::ULongLong,  113,

 // properties: name, type, flags
     114, QMetaType::Int, 0x00495103,
     115, 0x80000000 | 3, 0x0049510b,
     116, QMetaType::QSize, 0x00495001,
     117, QMetaType::Int, 0x00495001,
     118, QMetaType::Int, 0x00495001,
     119, QMetaType::Int, 0x00095001,
     120, QMetaType::Int, 0x00095001,
     121, QMetaType::QSize, 0x00095001,
     122, QMetaType::Int, 0x00495003,
     123, QMetaType::QSize, 0x00095001,
     124, QMetaType::Int, 0x00095001,
     125, QMetaType::Int, 0x00095001,
     126, QMetaType::Int, 0x00095001,
     127, QMetaType::Int, 0x00495001,
     128, QMetaType::QString, 0x00495001,
     129, QMetaType::QStringList, 0x00495001,
     130, QMetaType::QSize, 0x00495001,
     131, QMetaType::QRect, 0x00495001,

 // properties: notify_signal_id
       1,
      10,
      14,
      14,
      14,
       0,
       0,
       0,
      13,
       0,
       0,
       0,
       0,
      16,
      18,
      19,
      22,
      23,

 // enums: name, flags, count, data
     106, 0x0,    8,  724,
     140, 0x0,   10,  740,

 // enum data: key, value
     132, uint(KWin::WorkspaceWrapper::PlacementArea),
     133, uint(KWin::WorkspaceWrapper::MovementArea),
     134, uint(KWin::WorkspaceWrapper::MaximizeArea),
     135, uint(KWin::WorkspaceWrapper::MaximizeFullArea),
     136, uint(KWin::WorkspaceWrapper::FullScreenArea),
     137, uint(KWin::WorkspaceWrapper::WorkArea),
     138, uint(KWin::WorkspaceWrapper::FullArea),
     139, uint(KWin::WorkspaceWrapper::ScreenArea),
     141, uint(KWin::WorkspaceWrapper::ElectricTop),
     142, uint(KWin::WorkspaceWrapper::ElectricTopRight),
     143, uint(KWin::WorkspaceWrapper::ElectricRight),
     144, uint(KWin::WorkspaceWrapper::ElectricBottomRight),
     145, uint(KWin::WorkspaceWrapper::ElectricBottom),
     146, uint(KWin::WorkspaceWrapper::ElectricBottomLeft),
     147, uint(KWin::WorkspaceWrapper::ElectricLeft),
     148, uint(KWin::WorkspaceWrapper::ElectricTopLeft),
     149, uint(KWin::WorkspaceWrapper::ELECTRIC_COUNT),
     150, uint(KWin::WorkspaceWrapper::ElectricNone),

       0        // eod
};

void KWin::WorkspaceWrapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        WorkspaceWrapper *_t = static_cast<WorkspaceWrapper *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->desktopPresenceChanged((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 1: _t->currentDesktopChanged((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< KWin::AbstractClient*(*)>(_a[2]))); break;
        case 2: _t->clientAdded((*reinterpret_cast< KWin::Client*(*)>(_a[1]))); break;
        case 3: _t->clientRemoved((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1]))); break;
        case 4: _t->clientManaging((*reinterpret_cast< KWin::Client*(*)>(_a[1]))); break;
        case 5: _t->clientMinimized((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1]))); break;
        case 6: _t->clientUnminimized((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1]))); break;
        case 7: _t->clientRestored((*reinterpret_cast< KWin::Client*(*)>(_a[1]))); break;
        case 8: _t->clientMaximizeSet((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
        case 9: _t->killWindowCalled((*reinterpret_cast< KWin::Client*(*)>(_a[1]))); break;
        case 10: _t->clientActivated((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1]))); break;
        case 11: _t->clientFullScreenSet((*reinterpret_cast< KWin::Client*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
        case 12: _t->clientSetKeepAbove((*reinterpret_cast< KWin::Client*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
        case 13: _t->numberDesktopsChanged((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 14: _t->desktopLayoutChanged(); break;
        case 15: _t->clientDemandsAttentionChanged((*reinterpret_cast< KWin::AbstractClient*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
        case 16: _t->numberScreensChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 17: _t->screenResized((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 18: _t->currentActivityChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 19: _t->activitiesChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 20: _t->activityAdded((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 21: _t->activityRemoved((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 22: _t->virtualScreenSizeChanged(); break;
        case 23: _t->virtualScreenGeometryChanged(); break;
        case 24: _t->slotSwitchDesktopNext(); break;
        case 25: _t->slotSwitchDesktopPrevious(); break;
        case 26: _t->slotSwitchDesktopRight(); break;
        case 27: _t->slotSwitchDesktopLeft(); break;
        case 28: _t->slotSwitchDesktopUp(); break;
        case 29: _t->slotSwitchDesktopDown(); break;
        case 30: _t->slotSwitchToNextScreen(); break;
        case 31: _t->slotWindowToNextScreen(); break;
        case 32: _t->slotToggleShowDesktop(); break;
        case 33: _t->slotWindowMaximize(); break;
        case 34: _t->slotWindowMaximizeVertical(); break;
        case 35: _t->slotWindowMaximizeHorizontal(); break;
        case 36: _t->slotWindowMinimize(); break;
        case 37: _t->slotWindowShade(); break;
        case 38: _t->slotWindowRaise(); break;
        case 39: _t->slotWindowLower(); break;
        case 40: _t->slotWindowRaiseOrLower(); break;
        case 41: _t->slotActivateAttentionWindow(); break;
        case 42: _t->slotWindowPackLeft(); break;
        case 43: _t->slotWindowPackRight(); break;
        case 44: _t->slotWindowPackUp(); break;
        case 45: _t->slotWindowPackDown(); break;
        case 46: _t->slotWindowGrowHorizontal(); break;
        case 47: _t->slotWindowGrowVertical(); break;
        case 48: _t->slotWindowShrinkHorizontal(); break;
        case 49: _t->slotWindowShrinkVertical(); break;
        case 50: _t->slotWindowQuickTileLeft(); break;
        case 51: _t->slotWindowQuickTileRight(); break;
        case 52: _t->slotWindowQuickTileTop(); break;
        case 53: _t->slotWindowQuickTileBottom(); break;
        case 54: _t->slotWindowQuickTileTopLeft(); break;
        case 55: _t->slotWindowQuickTileTopRight(); break;
        case 56: _t->slotWindowQuickTileBottomLeft(); break;
        case 57: _t->slotWindowQuickTileBottomRight(); break;
        case 58: _t->slotSwitchWindowUp(); break;
        case 59: _t->slotSwitchWindowDown(); break;
        case 60: _t->slotSwitchWindowRight(); break;
        case 61: _t->slotSwitchWindowLeft(); break;
        case 62: _t->slotIncreaseWindowOpacity(); break;
        case 63: _t->slotLowerWindowOpacity(); break;
        case 64: _t->slotWindowOperations(); break;
        case 65: _t->slotWindowClose(); break;
        case 66: _t->slotWindowMove(); break;
        case 67: _t->slotWindowResize(); break;
        case 68: _t->slotWindowAbove(); break;
        case 69: _t->slotWindowBelow(); break;
        case 70: _t->slotWindowOnAllDesktops(); break;
        case 71: _t->slotWindowFullScreen(); break;
        case 72: _t->slotWindowNoBorder(); break;
        case 73: _t->slotWindowToNextDesktop(); break;
        case 74: _t->slotWindowToPreviousDesktop(); break;
        case 75: _t->slotWindowToDesktopRight(); break;
        case 76: _t->slotWindowToDesktopLeft(); break;
        case 77: _t->slotWindowToDesktopUp(); break;
        case 78: _t->slotWindowToDesktopDown(); break;
        case 79: _t->showOutline((*reinterpret_cast< const QRect(*)>(_a[1]))); break;
        case 80: _t->showOutline((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4]))); break;
        case 81: _t->hideOutline(); break;
        case 82: _t->setupClientConnections((*reinterpret_cast< KWin::Client*(*)>(_a[1]))); break;
        case 83: { QList<KWin::Client*> _r = _t->clientList();
            if (_a[0]) *reinterpret_cast< QList<KWin::Client*>*>(_a[0]) = _r; }  break;
        case 84: { QRect _r = _t->clientArea((*reinterpret_cast< ClientAreaOption(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QRect*>(_a[0]) = _r; }  break;
        case 85: { QRect _r = _t->clientArea((*reinterpret_cast< ClientAreaOption(*)>(_a[1])),(*reinterpret_cast< const QPoint(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QRect*>(_a[0]) = _r; }  break;
        case 86: { QRect _r = _t->clientArea((*reinterpret_cast< ClientAreaOption(*)>(_a[1])),(*reinterpret_cast< const KWin::Client*(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QRect*>(_a[0]) = _r; }  break;
        case 87: { QString _r = _t->desktopName((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 88: { QString _r = _t->supportInformation();
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 89: { KWin::Client* _r = _t->getClient((*reinterpret_cast< qulonglong(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< KWin::Client**>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * , int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::desktopPresenceChanged)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(int , KWin::AbstractClient * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::currentDesktopChanged)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientAdded)) {
                *result = 2;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientRemoved)) {
                *result = 3;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientManaging)) {
                *result = 4;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientMinimized)) {
                *result = 5;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientUnminimized)) {
                *result = 6;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientRestored)) {
                *result = 7;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * , bool , bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientMaximizeSet)) {
                *result = 8;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::killWindowCalled)) {
                *result = 9;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientActivated)) {
                *result = 10;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * , bool , bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientFullScreenSet)) {
                *result = 11;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::Client * , bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientSetKeepAbove)) {
                *result = 12;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::numberDesktopsChanged)) {
                *result = 13;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::desktopLayoutChanged)) {
                *result = 14;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(KWin::AbstractClient * , bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::clientDemandsAttentionChanged)) {
                *result = 15;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::numberScreensChanged)) {
                *result = 16;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::screenResized)) {
                *result = 17;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::currentActivityChanged)) {
                *result = 18;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::activitiesChanged)) {
                *result = 19;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::activityAdded)) {
                *result = 20;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::activityRemoved)) {
                *result = 21;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::virtualScreenSizeChanged)) {
                *result = 22;
                return;
            }
        }
        {
            typedef void (WorkspaceWrapper::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&WorkspaceWrapper::virtualScreenGeometryChanged)) {
                *result = 23;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        WorkspaceWrapper *_t = static_cast<WorkspaceWrapper *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< int*>(_v) = _t->currentDesktop(); break;
        case 1: *reinterpret_cast< KWin::AbstractClient**>(_v) = _t->activeClient(); break;
        case 2: *reinterpret_cast< QSize*>(_v) = _t->desktopGridSize(); break;
        case 3: *reinterpret_cast< int*>(_v) = _t->desktopGridWidth(); break;
        case 4: *reinterpret_cast< int*>(_v) = _t->desktopGridHeight(); break;
        case 5: *reinterpret_cast< int*>(_v) = _t->workspaceWidth(); break;
        case 6: *reinterpret_cast< int*>(_v) = _t->workspaceHeight(); break;
        case 7: *reinterpret_cast< QSize*>(_v) = _t->workspaceSize(); break;
        case 8: *reinterpret_cast< int*>(_v) = _t->numberOfDesktops(); break;
        case 9: *reinterpret_cast< QSize*>(_v) = _t->displaySize(); break;
        case 10: *reinterpret_cast< int*>(_v) = _t->displayWidth(); break;
        case 11: *reinterpret_cast< int*>(_v) = _t->displayHeight(); break;
        case 12: *reinterpret_cast< int*>(_v) = _t->activeScreen(); break;
        case 13: *reinterpret_cast< int*>(_v) = _t->numScreens(); break;
        case 14: *reinterpret_cast< QString*>(_v) = _t->currentActivity(); break;
        case 15: *reinterpret_cast< QStringList*>(_v) = _t->activityList(); break;
        case 16: *reinterpret_cast< QSize*>(_v) = _t->virtualScreenSize(); break;
        case 17: *reinterpret_cast< QRect*>(_v) = _t->virtualScreenGeometry(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        WorkspaceWrapper *_t = static_cast<WorkspaceWrapper *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCurrentDesktop(*reinterpret_cast< int*>(_v)); break;
        case 1: _t->setActiveClient(*reinterpret_cast< KWin::AbstractClient**>(_v)); break;
        case 8: _t->setNumberOfDesktops(*reinterpret_cast< int*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

const QMetaObject KWin::WorkspaceWrapper::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_KWin__WorkspaceWrapper.data,
      qt_meta_data_KWin__WorkspaceWrapper,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *KWin::WorkspaceWrapper::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_KWin__WorkspaceWrapper.stringdata0))
        return static_cast<void*>(const_cast< WorkspaceWrapper*>(this));
    return QObject::qt_metacast(_clname);
}

int KWin::WorkspaceWrapper::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 < 90)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 90;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 90)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 90;
    }
#ifndef QT_NO_PROPERTIES
   else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 18;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 18;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 18;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 18;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 18;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 18;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void KWin::WorkspaceWrapper::desktopPresenceChanged(KWin::AbstractClient * _t1, int _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void KWin::WorkspaceWrapper::currentDesktopChanged(int _t1, KWin::AbstractClient * _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void KWin::WorkspaceWrapper::clientAdded(KWin::Client * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void KWin::WorkspaceWrapper::clientRemoved(KWin::AbstractClient * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void KWin::WorkspaceWrapper::clientManaging(KWin::Client * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void KWin::WorkspaceWrapper::clientMinimized(KWin::AbstractClient * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void KWin::WorkspaceWrapper::clientUnminimized(KWin::AbstractClient * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

// SIGNAL 7
void KWin::WorkspaceWrapper::clientRestored(KWin::Client * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
}

// SIGNAL 8
void KWin::WorkspaceWrapper::clientMaximizeSet(KWin::AbstractClient * _t1, bool _t2, bool _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 8, _a);
}

// SIGNAL 9
void KWin::WorkspaceWrapper::killWindowCalled(KWin::Client * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
}

// SIGNAL 10
void KWin::WorkspaceWrapper::clientActivated(KWin::AbstractClient * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 10, _a);
}

// SIGNAL 11
void KWin::WorkspaceWrapper::clientFullScreenSet(KWin::Client * _t1, bool _t2, bool _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
}

// SIGNAL 12
void KWin::WorkspaceWrapper::clientSetKeepAbove(KWin::Client * _t1, bool _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 12, _a);
}

// SIGNAL 13
void KWin::WorkspaceWrapper::numberDesktopsChanged(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 13, _a);
}

// SIGNAL 14
void KWin::WorkspaceWrapper::desktopLayoutChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, Q_NULLPTR);
}

// SIGNAL 15
void KWin::WorkspaceWrapper::clientDemandsAttentionChanged(KWin::AbstractClient * _t1, bool _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 15, _a);
}

// SIGNAL 16
void KWin::WorkspaceWrapper::numberScreensChanged(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 16, _a);
}

// SIGNAL 17
void KWin::WorkspaceWrapper::screenResized(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 17, _a);
}

// SIGNAL 18
void KWin::WorkspaceWrapper::currentActivityChanged(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 18, _a);
}

// SIGNAL 19
void KWin::WorkspaceWrapper::activitiesChanged(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 19, _a);
}

// SIGNAL 20
void KWin::WorkspaceWrapper::activityAdded(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 20, _a);
}

// SIGNAL 21
void KWin::WorkspaceWrapper::activityRemoved(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 21, _a);
}

// SIGNAL 22
void KWin::WorkspaceWrapper::virtualScreenSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, Q_NULLPTR);
}

// SIGNAL 23
void KWin::WorkspaceWrapper::virtualScreenGeometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, Q_NULLPTR);
}
QT_END_MOC_NAMESPACE
