/****************************************************************************
** Meta object code from reading C++ file 'options.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/options.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'options.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__Options_t {
    QByteArrayData data[215];
    char stringdata0[4320];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KWin__Options_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KWin__Options_t qt_meta_stringdata_KWin__Options = {
    {
QT_MOC_LITERAL(0, 0, 13), // "KWin::Options"
QT_MOC_LITERAL(1, 14, 18), // "focusPolicyChanged"
QT_MOC_LITERAL(2, 33, 0), // ""
QT_MOC_LITERAL(3, 34, 29), // "focusPolicyIsResonableChanged"
QT_MOC_LITERAL(4, 64, 28), // "nextFocusPrefersMouseChanged"
QT_MOC_LITERAL(5, 93, 17), // "clickRaiseChanged"
QT_MOC_LITERAL(6, 111, 16), // "autoRaiseChanged"
QT_MOC_LITERAL(7, 128, 24), // "autoRaiseIntervalChanged"
QT_MOC_LITERAL(8, 153, 25), // "delayFocusIntervalChanged"
QT_MOC_LITERAL(9, 179, 17), // "shadeHoverChanged"
QT_MOC_LITERAL(10, 197, 25), // "shadeHoverIntervalChanged"
QT_MOC_LITERAL(11, 223, 26), // "separateScreenFocusChanged"
QT_MOC_LITERAL(12, 250, 16), // "placementChanged"
QT_MOC_LITERAL(13, 267, 21), // "borderSnapZoneChanged"
QT_MOC_LITERAL(14, 289, 21), // "windowSnapZoneChanged"
QT_MOC_LITERAL(15, 311, 21), // "centerSnapZoneChanged"
QT_MOC_LITERAL(16, 333, 30), // "snapOnlyWhenOverlappingChanged"
QT_MOC_LITERAL(17, 364, 23), // "rollOverDesktopsChanged"
QT_MOC_LITERAL(18, 388, 7), // "enabled"
QT_MOC_LITERAL(19, 396, 35), // "focusStealingPreventionLevelC..."
QT_MOC_LITERAL(20, 432, 30), // "legacyFullscreenSupportChanged"
QT_MOC_LITERAL(21, 463, 32), // "operationTitlebarDblClickChanged"
QT_MOC_LITERAL(22, 496, 34), // "operationMaxButtonLeftClickCh..."
QT_MOC_LITERAL(23, 531, 35), // "operationMaxButtonRightClickC..."
QT_MOC_LITERAL(24, 567, 36), // "operationMaxButtonMiddleClick..."
QT_MOC_LITERAL(25, 604, 29), // "commandActiveTitlebar1Changed"
QT_MOC_LITERAL(26, 634, 29), // "commandActiveTitlebar2Changed"
QT_MOC_LITERAL(27, 664, 29), // "commandActiveTitlebar3Changed"
QT_MOC_LITERAL(28, 694, 31), // "commandInactiveTitlebar1Changed"
QT_MOC_LITERAL(29, 726, 31), // "commandInactiveTitlebar2Changed"
QT_MOC_LITERAL(30, 758, 31), // "commandInactiveTitlebar3Changed"
QT_MOC_LITERAL(31, 790, 21), // "commandWindow1Changed"
QT_MOC_LITERAL(32, 812, 21), // "commandWindow2Changed"
QT_MOC_LITERAL(33, 834, 21), // "commandWindow3Changed"
QT_MOC_LITERAL(34, 856, 25), // "commandWindowWheelChanged"
QT_MOC_LITERAL(35, 882, 18), // "commandAll1Changed"
QT_MOC_LITERAL(36, 901, 18), // "commandAll2Changed"
QT_MOC_LITERAL(37, 920, 18), // "commandAll3Changed"
QT_MOC_LITERAL(38, 939, 22), // "keyCmdAllModKeyChanged"
QT_MOC_LITERAL(39, 962, 22), // "showGeometryTipChanged"
QT_MOC_LITERAL(40, 985, 21), // "condensedTitleChanged"
QT_MOC_LITERAL(41, 1007, 29), // "electricBorderMaximizeChanged"
QT_MOC_LITERAL(42, 1037, 27), // "electricBorderTilingChanged"
QT_MOC_LITERAL(43, 1065, 32), // "electricBorderCornerRatioChanged"
QT_MOC_LITERAL(44, 1098, 33), // "borderlessMaximizedWindowsCha..."
QT_MOC_LITERAL(45, 1132, 22), // "killPingTimeoutChanged"
QT_MOC_LITERAL(46, 1155, 36), // "hideUtilityWindowsForInactive..."
QT_MOC_LITERAL(47, 1192, 30), // "inactiveTabsSkipTaskbarChanged"
QT_MOC_LITERAL(48, 1223, 30), // "autogroupSimilarWindowsChanged"
QT_MOC_LITERAL(49, 1254, 28), // "autogroupInForegroundChanged"
QT_MOC_LITERAL(50, 1283, 22), // "compositingModeChanged"
QT_MOC_LITERAL(51, 1306, 21), // "useCompositingChanged"
QT_MOC_LITERAL(52, 1328, 29), // "compositingInitializedChanged"
QT_MOC_LITERAL(53, 1358, 21), // "hiddenPreviewsChanged"
QT_MOC_LITERAL(54, 1380, 27), // "unredirectFullscreenChanged"
QT_MOC_LITERAL(55, 1408, 20), // "glSmoothScaleChanged"
QT_MOC_LITERAL(56, 1429, 21), // "colorCorrectedChanged"
QT_MOC_LITERAL(57, 1451, 25), // "xrenderSmoothScaleChanged"
QT_MOC_LITERAL(58, 1477, 21), // "maxFpsIntervalChanged"
QT_MOC_LITERAL(59, 1499, 18), // "refreshRateChanged"
QT_MOC_LITERAL(60, 1518, 17), // "vBlankTimeChanged"
QT_MOC_LITERAL(61, 1536, 22), // "glStrictBindingChanged"
QT_MOC_LITERAL(62, 1559, 35), // "glStrictBindingFollowsDriverC..."
QT_MOC_LITERAL(63, 1595, 20), // "glCoreProfileChanged"
QT_MOC_LITERAL(64, 1616, 25), // "glPreferBufferSwapChanged"
QT_MOC_LITERAL(65, 1642, 26), // "glPlatformInterfaceChanged"
QT_MOC_LITERAL(66, 1669, 13), // "configChanged"
QT_MOC_LITERAL(67, 1683, 17), // "setColorCorrected"
QT_MOC_LITERAL(68, 1701, 14), // "colorCorrected"
QT_MOC_LITERAL(69, 1716, 11), // "focusPolicy"
QT_MOC_LITERAL(70, 1728, 11), // "FocusPolicy"
QT_MOC_LITERAL(71, 1740, 21), // "nextFocusPrefersMouse"
QT_MOC_LITERAL(72, 1762, 10), // "clickRaise"
QT_MOC_LITERAL(73, 1773, 9), // "autoRaise"
QT_MOC_LITERAL(74, 1783, 17), // "autoRaiseInterval"
QT_MOC_LITERAL(75, 1801, 18), // "delayFocusInterval"
QT_MOC_LITERAL(76, 1820, 10), // "shadeHover"
QT_MOC_LITERAL(77, 1831, 18), // "shadeHoverInterval"
QT_MOC_LITERAL(78, 1850, 19), // "separateScreenFocus"
QT_MOC_LITERAL(79, 1870, 9), // "placement"
QT_MOC_LITERAL(80, 1880, 23), // "focusPolicyIsReasonable"
QT_MOC_LITERAL(81, 1904, 14), // "borderSnapZone"
QT_MOC_LITERAL(82, 1919, 14), // "windowSnapZone"
QT_MOC_LITERAL(83, 1934, 14), // "centerSnapZone"
QT_MOC_LITERAL(84, 1949, 23), // "snapOnlyWhenOverlapping"
QT_MOC_LITERAL(85, 1973, 16), // "rollOverDesktops"
QT_MOC_LITERAL(86, 1990, 28), // "focusStealingPreventionLevel"
QT_MOC_LITERAL(87, 2019, 23), // "legacyFullscreenSupport"
QT_MOC_LITERAL(88, 2043, 25), // "operationTitlebarDblClick"
QT_MOC_LITERAL(89, 2069, 30), // "KWin::Options::WindowOperation"
QT_MOC_LITERAL(90, 2100, 27), // "operationMaxButtonLeftClick"
QT_MOC_LITERAL(91, 2128, 29), // "operationMaxButtonMiddleClick"
QT_MOC_LITERAL(92, 2158, 28), // "operationMaxButtonRightClick"
QT_MOC_LITERAL(93, 2187, 22), // "commandActiveTitlebar1"
QT_MOC_LITERAL(94, 2210, 12), // "MouseCommand"
QT_MOC_LITERAL(95, 2223, 22), // "commandActiveTitlebar2"
QT_MOC_LITERAL(96, 2246, 22), // "commandActiveTitlebar3"
QT_MOC_LITERAL(97, 2269, 24), // "commandInactiveTitlebar1"
QT_MOC_LITERAL(98, 2294, 24), // "commandInactiveTitlebar2"
QT_MOC_LITERAL(99, 2319, 24), // "commandInactiveTitlebar3"
QT_MOC_LITERAL(100, 2344, 14), // "commandWindow1"
QT_MOC_LITERAL(101, 2359, 14), // "commandWindow2"
QT_MOC_LITERAL(102, 2374, 14), // "commandWindow3"
QT_MOC_LITERAL(103, 2389, 18), // "commandWindowWheel"
QT_MOC_LITERAL(104, 2408, 11), // "commandAll1"
QT_MOC_LITERAL(105, 2420, 11), // "commandAll2"
QT_MOC_LITERAL(106, 2432, 11), // "commandAll3"
QT_MOC_LITERAL(107, 2444, 15), // "keyCmdAllModKey"
QT_MOC_LITERAL(108, 2460, 15), // "showGeometryTip"
QT_MOC_LITERAL(109, 2476, 14), // "condensedTitle"
QT_MOC_LITERAL(110, 2491, 22), // "electricBorderMaximize"
QT_MOC_LITERAL(111, 2514, 20), // "electricBorderTiling"
QT_MOC_LITERAL(112, 2535, 25), // "electricBorderCornerRatio"
QT_MOC_LITERAL(113, 2561, 26), // "borderlessMaximizedWindows"
QT_MOC_LITERAL(114, 2588, 15), // "killPingTimeout"
QT_MOC_LITERAL(115, 2604, 29), // "hideUtilityWindowsForInactive"
QT_MOC_LITERAL(116, 2634, 23), // "inactiveTabsSkipTaskbar"
QT_MOC_LITERAL(117, 2658, 23), // "autogroupSimilarWindows"
QT_MOC_LITERAL(118, 2682, 21), // "autogroupInForeground"
QT_MOC_LITERAL(119, 2704, 15), // "compositingMode"
QT_MOC_LITERAL(120, 2720, 14), // "useCompositing"
QT_MOC_LITERAL(121, 2735, 22), // "compositingInitialized"
QT_MOC_LITERAL(122, 2758, 14), // "hiddenPreviews"
QT_MOC_LITERAL(123, 2773, 20), // "unredirectFullscreen"
QT_MOC_LITERAL(124, 2794, 13), // "glSmoothScale"
QT_MOC_LITERAL(125, 2808, 18), // "xrenderSmoothScale"
QT_MOC_LITERAL(126, 2827, 14), // "maxFpsInterval"
QT_MOC_LITERAL(127, 2842, 11), // "refreshRate"
QT_MOC_LITERAL(128, 2854, 10), // "vBlankTime"
QT_MOC_LITERAL(129, 2865, 15), // "glStrictBinding"
QT_MOC_LITERAL(130, 2881, 28), // "glStrictBindingFollowsDriver"
QT_MOC_LITERAL(131, 2910, 13), // "glCoreProfile"
QT_MOC_LITERAL(132, 2924, 18), // "glPreferBufferSwap"
QT_MOC_LITERAL(133, 2943, 14), // "GlSwapStrategy"
QT_MOC_LITERAL(134, 2958, 19), // "glPlatformInterface"
QT_MOC_LITERAL(135, 2978, 29), // "KWin::OpenGLPlatformInterface"
QT_MOC_LITERAL(136, 3008, 12), // "ClickToFocus"
QT_MOC_LITERAL(137, 3021, 17), // "FocusFollowsMouse"
QT_MOC_LITERAL(138, 3039, 15), // "FocusUnderMouse"
QT_MOC_LITERAL(139, 3055, 23), // "FocusStrictlyUnderMouse"
QT_MOC_LITERAL(140, 3079, 15), // "WindowOperation"
QT_MOC_LITERAL(141, 3095, 10), // "MaximizeOp"
QT_MOC_LITERAL(142, 3106, 9), // "RestoreOp"
QT_MOC_LITERAL(143, 3116, 10), // "MinimizeOp"
QT_MOC_LITERAL(144, 3127, 6), // "MoveOp"
QT_MOC_LITERAL(145, 3134, 18), // "UnrestrictedMoveOp"
QT_MOC_LITERAL(146, 3153, 8), // "ResizeOp"
QT_MOC_LITERAL(147, 3162, 20), // "UnrestrictedResizeOp"
QT_MOC_LITERAL(148, 3183, 7), // "CloseOp"
QT_MOC_LITERAL(149, 3191, 15), // "OnAllDesktopsOp"
QT_MOC_LITERAL(150, 3207, 7), // "ShadeOp"
QT_MOC_LITERAL(151, 3215, 11), // "KeepAboveOp"
QT_MOC_LITERAL(152, 3227, 11), // "KeepBelowOp"
QT_MOC_LITERAL(153, 3239, 12), // "OperationsOp"
QT_MOC_LITERAL(154, 3252, 13), // "WindowRulesOp"
QT_MOC_LITERAL(155, 3266, 21), // "ToggleStoreSettingsOp"
QT_MOC_LITERAL(156, 3288, 11), // "HMaximizeOp"
QT_MOC_LITERAL(157, 3300, 11), // "VMaximizeOp"
QT_MOC_LITERAL(158, 3312, 7), // "LowerOp"
QT_MOC_LITERAL(159, 3320, 12), // "FullScreenOp"
QT_MOC_LITERAL(160, 3333, 10), // "NoBorderOp"
QT_MOC_LITERAL(161, 3344, 4), // "NoOp"
QT_MOC_LITERAL(162, 3349, 21), // "SetupWindowShortcutOp"
QT_MOC_LITERAL(163, 3371, 18), // "ApplicationRulesOp"
QT_MOC_LITERAL(164, 3390, 20), // "RemoveTabFromGroupOp"
QT_MOC_LITERAL(165, 3411, 15), // "CloseTabGroupOp"
QT_MOC_LITERAL(166, 3427, 17), // "ActivateNextTabOp"
QT_MOC_LITERAL(167, 3445, 21), // "ActivatePreviousTabOp"
QT_MOC_LITERAL(168, 3467, 9), // "TabDragOp"
QT_MOC_LITERAL(169, 3477, 10), // "MouseRaise"
QT_MOC_LITERAL(170, 3488, 10), // "MouseLower"
QT_MOC_LITERAL(171, 3499, 19), // "MouseOperationsMenu"
QT_MOC_LITERAL(172, 3519, 24), // "MouseToggleRaiseAndLower"
QT_MOC_LITERAL(173, 3544, 21), // "MouseActivateAndRaise"
QT_MOC_LITERAL(174, 3566, 21), // "MouseActivateAndLower"
QT_MOC_LITERAL(175, 3588, 13), // "MouseActivate"
QT_MOC_LITERAL(176, 3602, 30), // "MouseActivateRaiseAndPassClick"
QT_MOC_LITERAL(177, 3633, 25), // "MouseActivateAndPassClick"
QT_MOC_LITERAL(178, 3659, 9), // "MouseMove"
QT_MOC_LITERAL(179, 3669, 21), // "MouseUnrestrictedMove"
QT_MOC_LITERAL(180, 3691, 25), // "MouseActivateRaiseAndMove"
QT_MOC_LITERAL(181, 3717, 37), // "MouseActivateRaiseAndUnrestri..."
QT_MOC_LITERAL(182, 3755, 11), // "MouseResize"
QT_MOC_LITERAL(183, 3767, 23), // "MouseUnrestrictedResize"
QT_MOC_LITERAL(184, 3791, 10), // "MouseShade"
QT_MOC_LITERAL(185, 3802, 13), // "MouseSetShade"
QT_MOC_LITERAL(186, 3816, 15), // "MouseUnsetShade"
QT_MOC_LITERAL(187, 3832, 13), // "MouseMaximize"
QT_MOC_LITERAL(188, 3846, 12), // "MouseRestore"
QT_MOC_LITERAL(189, 3859, 13), // "MouseMinimize"
QT_MOC_LITERAL(190, 3873, 16), // "MouseNextDesktop"
QT_MOC_LITERAL(191, 3890, 20), // "MousePreviousDesktop"
QT_MOC_LITERAL(192, 3911, 10), // "MouseAbove"
QT_MOC_LITERAL(193, 3922, 10), // "MouseBelow"
QT_MOC_LITERAL(194, 3933, 16), // "MouseOpacityMore"
QT_MOC_LITERAL(195, 3950, 16), // "MouseOpacityLess"
QT_MOC_LITERAL(196, 3967, 10), // "MouseClose"
QT_MOC_LITERAL(197, 3978, 16), // "MousePreviousTab"
QT_MOC_LITERAL(198, 3995, 12), // "MouseNextTab"
QT_MOC_LITERAL(199, 4008, 12), // "MouseDragTab"
QT_MOC_LITERAL(200, 4021, 12), // "MouseNothing"
QT_MOC_LITERAL(201, 4034, 17), // "MouseWheelCommand"
QT_MOC_LITERAL(202, 4052, 20), // "MouseWheelRaiseLower"
QT_MOC_LITERAL(203, 4073, 22), // "MouseWheelShadeUnshade"
QT_MOC_LITERAL(204, 4096, 25), // "MouseWheelMaximizeRestore"
QT_MOC_LITERAL(205, 4122, 20), // "MouseWheelAboveBelow"
QT_MOC_LITERAL(206, 4143, 29), // "MouseWheelPreviousNextDesktop"
QT_MOC_LITERAL(207, 4173, 23), // "MouseWheelChangeOpacity"
QT_MOC_LITERAL(208, 4197, 26), // "MouseWheelChangeCurrentTab"
QT_MOC_LITERAL(209, 4224, 17), // "MouseWheelNothing"
QT_MOC_LITERAL(210, 4242, 15), // "NoSwapEncourage"
QT_MOC_LITERAL(211, 4258, 15), // "CopyFrontBuffer"
QT_MOC_LITERAL(212, 4274, 15), // "PaintFullScreen"
QT_MOC_LITERAL(213, 4290, 12), // "ExtendDamage"
QT_MOC_LITERAL(214, 4303, 16) // "AutoSwapStrategy"

    },
    "KWin::Options\0focusPolicyChanged\0\0"
    "focusPolicyIsResonableChanged\0"
    "nextFocusPrefersMouseChanged\0"
    "clickRaiseChanged\0autoRaiseChanged\0"
    "autoRaiseIntervalChanged\0"
    "delayFocusIntervalChanged\0shadeHoverChanged\0"
    "shadeHoverIntervalChanged\0"
    "separateScreenFocusChanged\0placementChanged\0"
    "borderSnapZoneChanged\0windowSnapZoneChanged\0"
    "centerSnapZoneChanged\0"
    "snapOnlyWhenOverlappingChanged\0"
    "rollOverDesktopsChanged\0enabled\0"
    "focusStealingPreventionLevelChanged\0"
    "legacyFullscreenSupportChanged\0"
    "operationTitlebarDblClickChanged\0"
    "operationMaxButtonLeftClickChanged\0"
    "operationMaxButtonRightClickChanged\0"
    "operationMaxButtonMiddleClickChanged\0"
    "commandActiveTitlebar1Changed\0"
    "commandActiveTitlebar2Changed\0"
    "commandActiveTitlebar3Changed\0"
    "commandInactiveTitlebar1Changed\0"
    "commandInactiveTitlebar2Changed\0"
    "commandInactiveTitlebar3Changed\0"
    "commandWindow1Changed\0commandWindow2Changed\0"
    "commandWindow3Changed\0commandWindowWheelChanged\0"
    "commandAll1Changed\0commandAll2Changed\0"
    "commandAll3Changed\0keyCmdAllModKeyChanged\0"
    "showGeometryTipChanged\0condensedTitleChanged\0"
    "electricBorderMaximizeChanged\0"
    "electricBorderTilingChanged\0"
    "electricBorderCornerRatioChanged\0"
    "borderlessMaximizedWindowsChanged\0"
    "killPingTimeoutChanged\0"
    "hideUtilityWindowsForInactiveChanged\0"
    "inactiveTabsSkipTaskbarChanged\0"
    "autogroupSimilarWindowsChanged\0"
    "autogroupInForegroundChanged\0"
    "compositingModeChanged\0useCompositingChanged\0"
    "compositingInitializedChanged\0"
    "hiddenPreviewsChanged\0unredirectFullscreenChanged\0"
    "glSmoothScaleChanged\0colorCorrectedChanged\0"
    "xrenderSmoothScaleChanged\0"
    "maxFpsIntervalChanged\0refreshRateChanged\0"
    "vBlankTimeChanged\0glStrictBindingChanged\0"
    "glStrictBindingFollowsDriverChanged\0"
    "glCoreProfileChanged\0glPreferBufferSwapChanged\0"
    "glPlatformInterfaceChanged\0configChanged\0"
    "setColorCorrected\0colorCorrected\0"
    "focusPolicy\0FocusPolicy\0nextFocusPrefersMouse\0"
    "clickRaise\0autoRaise\0autoRaiseInterval\0"
    "delayFocusInterval\0shadeHover\0"
    "shadeHoverInterval\0separateScreenFocus\0"
    "placement\0focusPolicyIsReasonable\0"
    "borderSnapZone\0windowSnapZone\0"
    "centerSnapZone\0snapOnlyWhenOverlapping\0"
    "rollOverDesktops\0focusStealingPreventionLevel\0"
    "legacyFullscreenSupport\0"
    "operationTitlebarDblClick\0"
    "KWin::Options::WindowOperation\0"
    "operationMaxButtonLeftClick\0"
    "operationMaxButtonMiddleClick\0"
    "operationMaxButtonRightClick\0"
    "commandActiveTitlebar1\0MouseCommand\0"
    "commandActiveTitlebar2\0commandActiveTitlebar3\0"
    "commandInactiveTitlebar1\0"
    "commandInactiveTitlebar2\0"
    "commandInactiveTitlebar3\0commandWindow1\0"
    "commandWindow2\0commandWindow3\0"
    "commandWindowWheel\0commandAll1\0"
    "commandAll2\0commandAll3\0keyCmdAllModKey\0"
    "showGeometryTip\0condensedTitle\0"
    "electricBorderMaximize\0electricBorderTiling\0"
    "electricBorderCornerRatio\0"
    "borderlessMaximizedWindows\0killPingTimeout\0"
    "hideUtilityWindowsForInactive\0"
    "inactiveTabsSkipTaskbar\0autogroupSimilarWindows\0"
    "autogroupInForeground\0compositingMode\0"
    "useCompositing\0compositingInitialized\0"
    "hiddenPreviews\0unredirectFullscreen\0"
    "glSmoothScale\0xrenderSmoothScale\0"
    "maxFpsInterval\0refreshRate\0vBlankTime\0"
    "glStrictBinding\0glStrictBindingFollowsDriver\0"
    "glCoreProfile\0glPreferBufferSwap\0"
    "GlSwapStrategy\0glPlatformInterface\0"
    "KWin::OpenGLPlatformInterface\0"
    "ClickToFocus\0FocusFollowsMouse\0"
    "FocusUnderMouse\0FocusStrictlyUnderMouse\0"
    "WindowOperation\0MaximizeOp\0RestoreOp\0"
    "MinimizeOp\0MoveOp\0UnrestrictedMoveOp\0"
    "ResizeOp\0UnrestrictedResizeOp\0CloseOp\0"
    "OnAllDesktopsOp\0ShadeOp\0KeepAboveOp\0"
    "KeepBelowOp\0OperationsOp\0WindowRulesOp\0"
    "ToggleStoreSettingsOp\0HMaximizeOp\0"
    "VMaximizeOp\0LowerOp\0FullScreenOp\0"
    "NoBorderOp\0NoOp\0SetupWindowShortcutOp\0"
    "ApplicationRulesOp\0RemoveTabFromGroupOp\0"
    "CloseTabGroupOp\0ActivateNextTabOp\0"
    "ActivatePreviousTabOp\0TabDragOp\0"
    "MouseRaise\0MouseLower\0MouseOperationsMenu\0"
    "MouseToggleRaiseAndLower\0MouseActivateAndRaise\0"
    "MouseActivateAndLower\0MouseActivate\0"
    "MouseActivateRaiseAndPassClick\0"
    "MouseActivateAndPassClick\0MouseMove\0"
    "MouseUnrestrictedMove\0MouseActivateRaiseAndMove\0"
    "MouseActivateRaiseAndUnrestrictedMove\0"
    "MouseResize\0MouseUnrestrictedResize\0"
    "MouseShade\0MouseSetShade\0MouseUnsetShade\0"
    "MouseMaximize\0MouseRestore\0MouseMinimize\0"
    "MouseNextDesktop\0MousePreviousDesktop\0"
    "MouseAbove\0MouseBelow\0MouseOpacityMore\0"
    "MouseOpacityLess\0MouseClose\0"
    "MousePreviousTab\0MouseNextTab\0"
    "MouseDragTab\0MouseNothing\0MouseWheelCommand\0"
    "MouseWheelRaiseLower\0MouseWheelShadeUnshade\0"
    "MouseWheelMaximizeRestore\0"
    "MouseWheelAboveBelow\0MouseWheelPreviousNextDesktop\0"
    "MouseWheelChangeOpacity\0"
    "MouseWheelChangeCurrentTab\0MouseWheelNothing\0"
    "NoSwapEncourage\0CopyFrontBuffer\0"
    "PaintFullScreen\0ExtendDamage\0"
    "AutoSwapStrategy"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KWin__Options[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      66,   14, // methods
      63,  416, // properties
       5,  668, // enums/sets
       0,    0, // constructors
       0,       // flags
      64,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,  344,    2, 0x06 /* Public */,
       3,    0,  345,    2, 0x06 /* Public */,
       4,    0,  346,    2, 0x06 /* Public */,
       5,    0,  347,    2, 0x06 /* Public */,
       6,    0,  348,    2, 0x06 /* Public */,
       7,    0,  349,    2, 0x06 /* Public */,
       8,    0,  350,    2, 0x06 /* Public */,
       9,    0,  351,    2, 0x06 /* Public */,
      10,    0,  352,    2, 0x06 /* Public */,
      11,    1,  353,    2, 0x06 /* Public */,
      12,    0,  356,    2, 0x06 /* Public */,
      13,    0,  357,    2, 0x06 /* Public */,
      14,    0,  358,    2, 0x06 /* Public */,
      15,    0,  359,    2, 0x06 /* Public */,
      16,    0,  360,    2, 0x06 /* Public */,
      17,    1,  361,    2, 0x06 /* Public */,
      19,    0,  364,    2, 0x06 /* Public */,
      20,    0,  365,    2, 0x06 /* Public */,
      21,    0,  366,    2, 0x06 /* Public */,
      22,    0,  367,    2, 0x06 /* Public */,
      23,    0,  368,    2, 0x06 /* Public */,
      24,    0,  369,    2, 0x06 /* Public */,
      25,    0,  370,    2, 0x06 /* Public */,
      26,    0,  371,    2, 0x06 /* Public */,
      27,    0,  372,    2, 0x06 /* Public */,
      28,    0,  373,    2, 0x06 /* Public */,
      29,    0,  374,    2, 0x06 /* Public */,
      30,    0,  375,    2, 0x06 /* Public */,
      31,    0,  376,    2, 0x06 /* Public */,
      32,    0,  377,    2, 0x06 /* Public */,
      33,    0,  378,    2, 0x06 /* Public */,
      34,    0,  379,    2, 0x06 /* Public */,
      35,    0,  380,    2, 0x06 /* Public */,
      36,    0,  381,    2, 0x06 /* Public */,
      37,    0,  382,    2, 0x06 /* Public */,
      38,    0,  383,    2, 0x06 /* Public */,
      39,    0,  384,    2, 0x06 /* Public */,
      40,    0,  385,    2, 0x06 /* Public */,
      41,    0,  386,    2, 0x06 /* Public */,
      42,    0,  387,    2, 0x06 /* Public */,
      43,    0,  388,    2, 0x06 /* Public */,
      44,    0,  389,    2, 0x06 /* Public */,
      45,    0,  390,    2, 0x06 /* Public */,
      46,    0,  391,    2, 0x06 /* Public */,
      47,    0,  392,    2, 0x06 /* Public */,
      48,    0,  393,    2, 0x06 /* Public */,
      49,    0,  394,    2, 0x06 /* Public */,
      50,    0,  395,    2, 0x06 /* Public */,
      51,    0,  396,    2, 0x06 /* Public */,
      52,    0,  397,    2, 0x06 /* Public */,
      53,    0,  398,    2, 0x06 /* Public */,
      54,    0,  399,    2, 0x06 /* Public */,
      55,    0,  400,    2, 0x06 /* Public */,
      56,    0,  401,    2, 0x06 /* Public */,
      57,    0,  402,    2, 0x06 /* Public */,
      58,    0,  403,    2, 0x06 /* Public */,
      59,    0,  404,    2, 0x06 /* Public */,
      60,    0,  405,    2, 0x06 /* Public */,
      61,    0,  406,    2, 0x06 /* Public */,
      62,    0,  407,    2, 0x06 /* Public */,
      63,    0,  408,    2, 0x06 /* Public */,
      64,    0,  409,    2, 0x06 /* Public */,
      65,    0,  410,    2, 0x06 /* Public */,
      66,    0,  411,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      67,    1,  412,    2, 0x0a /* Public */,
      67,    0,  415,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,   18,
    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,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,   68,
    QMetaType::Void,

 // properties: name, type, flags
      69, 0x80000000 | 70, 0x0049510b,
      71, QMetaType::Bool, 0x00495103,
      72, QMetaType::Bool, 0x00495103,
      73, QMetaType::Bool, 0x00495103,
      74, QMetaType::Int, 0x00495103,
      75, QMetaType::Int, 0x00495103,
      76, QMetaType::Bool, 0x00495103,
      77, QMetaType::Int, 0x00495103,
      78, QMetaType::Bool, 0x00495103,
      79, QMetaType::Int, 0x00495103,
      80, QMetaType::Bool, 0x00495001,
      81, QMetaType::Int, 0x00495103,
      82, QMetaType::Int, 0x00495103,
      83, QMetaType::Int, 0x00495103,
      84, QMetaType::Bool, 0x00495103,
      85, QMetaType::Bool, 0x00495103,
      86, QMetaType::Int, 0x00495103,
      87, QMetaType::Bool, 0x00495103,
      88, 0x80000000 | 89, 0x0049510b,
      90, 0x80000000 | 89, 0x0049510b,
      91, 0x80000000 | 89, 0x0049510b,
      92, 0x80000000 | 89, 0x0049510b,
      93, 0x80000000 | 94, 0x0049510b,
      95, 0x80000000 | 94, 0x0049510b,
      96, 0x80000000 | 94, 0x0049510b,
      97, 0x80000000 | 94, 0x0049510b,
      98, 0x80000000 | 94, 0x0049510b,
      99, 0x80000000 | 94, 0x0049510b,
     100, 0x80000000 | 94, 0x0049510b,
     101, 0x80000000 | 94, 0x0049510b,
     102, 0x80000000 | 94, 0x0049510b,
     103, 0x80000000 | 94, 0x0049510b,
     104, 0x80000000 | 94, 0x0049510b,
     105, 0x80000000 | 94, 0x0049510b,
     106, 0x80000000 | 94, 0x0049510b,
     107, QMetaType::UInt, 0x00495103,
     108, QMetaType::Bool, 0x00495103,
     109, QMetaType::Bool, 0x00495103,
     110, QMetaType::Bool, 0x00495103,
     111, QMetaType::Bool, 0x00495103,
     112, QMetaType::Float, 0x00495103,
     113, QMetaType::Bool, 0x00495103,
     114, QMetaType::Int, 0x00495103,
     115, QMetaType::Bool, 0x00495103,
     116, QMetaType::Bool, 0x00495103,
     117, QMetaType::Bool, 0x00495103,
     118, QMetaType::Bool, 0x00495103,
     119, QMetaType::Int, 0x00495103,
     120, QMetaType::Bool, 0x00495103,
     121, QMetaType::Bool, 0x00495103,
     122, QMetaType::Int, 0x00495103,
     123, QMetaType::Bool, 0x00495103,
     124, QMetaType::Int, 0x00495103,
      68, QMetaType::Bool, 0x00495103,
     125, QMetaType::Bool, 0x00495103,
     126, QMetaType::LongLong, 0x00495103,
     127, QMetaType::UInt, 0x00495103,
     128, QMetaType::LongLong, 0x00495103,
     129, QMetaType::Bool, 0x00495103,
     130, QMetaType::Bool, 0x00495103,
     131, QMetaType::Bool, 0x00495003,
     132, 0x80000000 | 133, 0x0049510b,
     134, 0x80000000 | 135, 0x0049510b,

 // properties: notify_signal_id
       0,
       2,
       3,
       4,
       5,
       6,
       7,
       8,
       9,
      10,
       1,
      11,
      12,
      13,
      14,
      15,
      16,
      17,
      18,
      19,
      21,
      20,
      22,
      23,
      24,
      25,
      26,
      27,
      28,
      29,
      30,
      31,
      32,
      33,
      34,
      35,
      36,
      37,
      38,
      39,
      40,
      41,
      42,
      43,
      44,
      45,
      46,
      47,
      48,
      49,
      50,
      51,
      52,
      53,
      54,
      55,
      56,
      57,
      58,
      59,
      60,
      61,
      62,

 // enums: name, flags, count, data
      70, 0x0,    4,  688,
     140, 0x0,   28,  696,
      94, 0x0,   32,  752,
     201, 0x0,    8,  816,
     133, 0x0,    5,  832,

 // enum data: key, value
     136, uint(KWin::Options::ClickToFocus),
     137, uint(KWin::Options::FocusFollowsMouse),
     138, uint(KWin::Options::FocusUnderMouse),
     139, uint(KWin::Options::FocusStrictlyUnderMouse),
     141, uint(KWin::Options::MaximizeOp),
     142, uint(KWin::Options::RestoreOp),
     143, uint(KWin::Options::MinimizeOp),
     144, uint(KWin::Options::MoveOp),
     145, uint(KWin::Options::UnrestrictedMoveOp),
     146, uint(KWin::Options::ResizeOp),
     147, uint(KWin::Options::UnrestrictedResizeOp),
     148, uint(KWin::Options::CloseOp),
     149, uint(KWin::Options::OnAllDesktopsOp),
     150, uint(KWin::Options::ShadeOp),
     151, uint(KWin::Options::KeepAboveOp),
     152, uint(KWin::Options::KeepBelowOp),
     153, uint(KWin::Options::OperationsOp),
     154, uint(KWin::Options::WindowRulesOp),
     155, uint(KWin::Options::ToggleStoreSettingsOp),
     156, uint(KWin::Options::HMaximizeOp),
     157, uint(KWin::Options::VMaximizeOp),
     158, uint(KWin::Options::LowerOp),
     159, uint(KWin::Options::FullScreenOp),
     160, uint(KWin::Options::NoBorderOp),
     161, uint(KWin::Options::NoOp),
     162, uint(KWin::Options::SetupWindowShortcutOp),
     163, uint(KWin::Options::ApplicationRulesOp),
     164, uint(KWin::Options::RemoveTabFromGroupOp),
     165, uint(KWin::Options::CloseTabGroupOp),
     166, uint(KWin::Options::ActivateNextTabOp),
     167, uint(KWin::Options::ActivatePreviousTabOp),
     168, uint(KWin::Options::TabDragOp),
     169, uint(KWin::Options::MouseRaise),
     170, uint(KWin::Options::MouseLower),
     171, uint(KWin::Options::MouseOperationsMenu),
     172, uint(KWin::Options::MouseToggleRaiseAndLower),
     173, uint(KWin::Options::MouseActivateAndRaise),
     174, uint(KWin::Options::MouseActivateAndLower),
     175, uint(KWin::Options::MouseActivate),
     176, uint(KWin::Options::MouseActivateRaiseAndPassClick),
     177, uint(KWin::Options::MouseActivateAndPassClick),
     178, uint(KWin::Options::MouseMove),
     179, uint(KWin::Options::MouseUnrestrictedMove),
     180, uint(KWin::Options::MouseActivateRaiseAndMove),
     181, uint(KWin::Options::MouseActivateRaiseAndUnrestrictedMove),
     182, uint(KWin::Options::MouseResize),
     183, uint(KWin::Options::MouseUnrestrictedResize),
     184, uint(KWin::Options::MouseShade),
     185, uint(KWin::Options::MouseSetShade),
     186, uint(KWin::Options::MouseUnsetShade),
     187, uint(KWin::Options::MouseMaximize),
     188, uint(KWin::Options::MouseRestore),
     189, uint(KWin::Options::MouseMinimize),
     190, uint(KWin::Options::MouseNextDesktop),
     191, uint(KWin::Options::MousePreviousDesktop),
     192, uint(KWin::Options::MouseAbove),
     193, uint(KWin::Options::MouseBelow),
     194, uint(KWin::Options::MouseOpacityMore),
     195, uint(KWin::Options::MouseOpacityLess),
     196, uint(KWin::Options::MouseClose),
     197, uint(KWin::Options::MousePreviousTab),
     198, uint(KWin::Options::MouseNextTab),
     199, uint(KWin::Options::MouseDragTab),
     200, uint(KWin::Options::MouseNothing),
     202, uint(KWin::Options::MouseWheelRaiseLower),
     203, uint(KWin::Options::MouseWheelShadeUnshade),
     204, uint(KWin::Options::MouseWheelMaximizeRestore),
     205, uint(KWin::Options::MouseWheelAboveBelow),
     206, uint(KWin::Options::MouseWheelPreviousNextDesktop),
     207, uint(KWin::Options::MouseWheelChangeOpacity),
     208, uint(KWin::Options::MouseWheelChangeCurrentTab),
     209, uint(KWin::Options::MouseWheelNothing),
     210, uint(KWin::Options::NoSwapEncourage),
     211, uint(KWin::Options::CopyFrontBuffer),
     212, uint(KWin::Options::PaintFullScreen),
     213, uint(KWin::Options::ExtendDamage),
     214, uint(KWin::Options::AutoSwapStrategy),

       0        // eod
};

void KWin::Options::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Options *_t = static_cast<Options *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->focusPolicyChanged(); break;
        case 1: _t->focusPolicyIsResonableChanged(); break;
        case 2: _t->nextFocusPrefersMouseChanged(); break;
        case 3: _t->clickRaiseChanged(); break;
        case 4: _t->autoRaiseChanged(); break;
        case 5: _t->autoRaiseIntervalChanged(); break;
        case 6: _t->delayFocusIntervalChanged(); break;
        case 7: _t->shadeHoverChanged(); break;
        case 8: _t->shadeHoverIntervalChanged(); break;
        case 9: _t->separateScreenFocusChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 10: _t->placementChanged(); break;
        case 11: _t->borderSnapZoneChanged(); break;
        case 12: _t->windowSnapZoneChanged(); break;
        case 13: _t->centerSnapZoneChanged(); break;
        case 14: _t->snapOnlyWhenOverlappingChanged(); break;
        case 15: _t->rollOverDesktopsChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 16: _t->focusStealingPreventionLevelChanged(); break;
        case 17: _t->legacyFullscreenSupportChanged(); break;
        case 18: _t->operationTitlebarDblClickChanged(); break;
        case 19: _t->operationMaxButtonLeftClickChanged(); break;
        case 20: _t->operationMaxButtonRightClickChanged(); break;
        case 21: _t->operationMaxButtonMiddleClickChanged(); break;
        case 22: _t->commandActiveTitlebar1Changed(); break;
        case 23: _t->commandActiveTitlebar2Changed(); break;
        case 24: _t->commandActiveTitlebar3Changed(); break;
        case 25: _t->commandInactiveTitlebar1Changed(); break;
        case 26: _t->commandInactiveTitlebar2Changed(); break;
        case 27: _t->commandInactiveTitlebar3Changed(); break;
        case 28: _t->commandWindow1Changed(); break;
        case 29: _t->commandWindow2Changed(); break;
        case 30: _t->commandWindow3Changed(); break;
        case 31: _t->commandWindowWheelChanged(); break;
        case 32: _t->commandAll1Changed(); break;
        case 33: _t->commandAll2Changed(); break;
        case 34: _t->commandAll3Changed(); break;
        case 35: _t->keyCmdAllModKeyChanged(); break;
        case 36: _t->showGeometryTipChanged(); break;
        case 37: _t->condensedTitleChanged(); break;
        case 38: _t->electricBorderMaximizeChanged(); break;
        case 39: _t->electricBorderTilingChanged(); break;
        case 40: _t->electricBorderCornerRatioChanged(); break;
        case 41: _t->borderlessMaximizedWindowsChanged(); break;
        case 42: _t->killPingTimeoutChanged(); break;
        case 43: _t->hideUtilityWindowsForInactiveChanged(); break;
        case 44: _t->inactiveTabsSkipTaskbarChanged(); break;
        case 45: _t->autogroupSimilarWindowsChanged(); break;
        case 46: _t->autogroupInForegroundChanged(); break;
        case 47: _t->compositingModeChanged(); break;
        case 48: _t->useCompositingChanged(); break;
        case 49: _t->compositingInitializedChanged(); break;
        case 50: _t->hiddenPreviewsChanged(); break;
        case 51: _t->unredirectFullscreenChanged(); break;
        case 52: _t->glSmoothScaleChanged(); break;
        case 53: _t->colorCorrectedChanged(); break;
        case 54: _t->xrenderSmoothScaleChanged(); break;
        case 55: _t->maxFpsIntervalChanged(); break;
        case 56: _t->refreshRateChanged(); break;
        case 57: _t->vBlankTimeChanged(); break;
        case 58: _t->glStrictBindingChanged(); break;
        case 59: _t->glStrictBindingFollowsDriverChanged(); break;
        case 60: _t->glCoreProfileChanged(); break;
        case 61: _t->glPreferBufferSwapChanged(); break;
        case 62: _t->glPlatformInterfaceChanged(); break;
        case 63: _t->configChanged(); break;
        case 64: _t->setColorCorrected((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 65: _t->setColorCorrected(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::focusPolicyChanged)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::focusPolicyIsResonableChanged)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::nextFocusPrefersMouseChanged)) {
                *result = 2;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::clickRaiseChanged)) {
                *result = 3;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::autoRaiseChanged)) {
                *result = 4;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::autoRaiseIntervalChanged)) {
                *result = 5;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::delayFocusIntervalChanged)) {
                *result = 6;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::shadeHoverChanged)) {
                *result = 7;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::shadeHoverIntervalChanged)) {
                *result = 8;
                return;
            }
        }
        {
            typedef void (Options::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::separateScreenFocusChanged)) {
                *result = 9;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::placementChanged)) {
                *result = 10;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::borderSnapZoneChanged)) {
                *result = 11;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::windowSnapZoneChanged)) {
                *result = 12;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::centerSnapZoneChanged)) {
                *result = 13;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::snapOnlyWhenOverlappingChanged)) {
                *result = 14;
                return;
            }
        }
        {
            typedef void (Options::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::rollOverDesktopsChanged)) {
                *result = 15;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::focusStealingPreventionLevelChanged)) {
                *result = 16;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::legacyFullscreenSupportChanged)) {
                *result = 17;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::operationTitlebarDblClickChanged)) {
                *result = 18;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::operationMaxButtonLeftClickChanged)) {
                *result = 19;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::operationMaxButtonRightClickChanged)) {
                *result = 20;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::operationMaxButtonMiddleClickChanged)) {
                *result = 21;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandActiveTitlebar1Changed)) {
                *result = 22;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandActiveTitlebar2Changed)) {
                *result = 23;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandActiveTitlebar3Changed)) {
                *result = 24;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandInactiveTitlebar1Changed)) {
                *result = 25;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandInactiveTitlebar2Changed)) {
                *result = 26;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandInactiveTitlebar3Changed)) {
                *result = 27;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandWindow1Changed)) {
                *result = 28;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandWindow2Changed)) {
                *result = 29;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandWindow3Changed)) {
                *result = 30;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandWindowWheelChanged)) {
                *result = 31;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandAll1Changed)) {
                *result = 32;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandAll2Changed)) {
                *result = 33;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::commandAll3Changed)) {
                *result = 34;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::keyCmdAllModKeyChanged)) {
                *result = 35;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::showGeometryTipChanged)) {
                *result = 36;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::condensedTitleChanged)) {
                *result = 37;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::electricBorderMaximizeChanged)) {
                *result = 38;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::electricBorderTilingChanged)) {
                *result = 39;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::electricBorderCornerRatioChanged)) {
                *result = 40;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::borderlessMaximizedWindowsChanged)) {
                *result = 41;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::killPingTimeoutChanged)) {
                *result = 42;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::hideUtilityWindowsForInactiveChanged)) {
                *result = 43;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::inactiveTabsSkipTaskbarChanged)) {
                *result = 44;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::autogroupSimilarWindowsChanged)) {
                *result = 45;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::autogroupInForegroundChanged)) {
                *result = 46;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::compositingModeChanged)) {
                *result = 47;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::useCompositingChanged)) {
                *result = 48;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::compositingInitializedChanged)) {
                *result = 49;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::hiddenPreviewsChanged)) {
                *result = 50;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::unredirectFullscreenChanged)) {
                *result = 51;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glSmoothScaleChanged)) {
                *result = 52;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::colorCorrectedChanged)) {
                *result = 53;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::xrenderSmoothScaleChanged)) {
                *result = 54;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::maxFpsIntervalChanged)) {
                *result = 55;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::refreshRateChanged)) {
                *result = 56;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::vBlankTimeChanged)) {
                *result = 57;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glStrictBindingChanged)) {
                *result = 58;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glStrictBindingFollowsDriverChanged)) {
                *result = 59;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glCoreProfileChanged)) {
                *result = 60;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glPreferBufferSwapChanged)) {
                *result = 61;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::glPlatformInterfaceChanged)) {
                *result = 62;
                return;
            }
        }
        {
            typedef void (Options::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Options::configChanged)) {
                *result = 63;
                return;
            }
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 62:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< KWin::OpenGLPlatformInterface >(); break;
        case 21:
        case 20:
        case 19:
        case 18:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< KWin::Options::WindowOperation >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        Options *_t = static_cast<Options *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< FocusPolicy*>(_v) = _t->focusPolicy(); break;
        case 1: *reinterpret_cast< bool*>(_v) = _t->isNextFocusPrefersMouse(); break;
        case 2: *reinterpret_cast< bool*>(_v) = _t->isClickRaise(); break;
        case 3: *reinterpret_cast< bool*>(_v) = _t->isAutoRaise(); break;
        case 4: *reinterpret_cast< int*>(_v) = _t->autoRaiseInterval(); break;
        case 5: *reinterpret_cast< int*>(_v) = _t->delayFocusInterval(); break;
        case 6: *reinterpret_cast< bool*>(_v) = _t->isShadeHover(); break;
        case 7: *reinterpret_cast< int*>(_v) = _t->shadeHoverInterval(); break;
        case 8: *reinterpret_cast< bool*>(_v) = _t->isSeparateScreenFocus(); break;
        case 9: *reinterpret_cast< int*>(_v) = _t->placement(); break;
        case 10: *reinterpret_cast< bool*>(_v) = _t->focusPolicyIsReasonable(); break;
        case 11: *reinterpret_cast< int*>(_v) = _t->borderSnapZone(); break;
        case 12: *reinterpret_cast< int*>(_v) = _t->windowSnapZone(); break;
        case 13: *reinterpret_cast< int*>(_v) = _t->centerSnapZone(); break;
        case 14: *reinterpret_cast< bool*>(_v) = _t->isSnapOnlyWhenOverlapping(); break;
        case 15: *reinterpret_cast< bool*>(_v) = _t->isRollOverDesktops(); break;
        case 16: *reinterpret_cast< int*>(_v) = _t->focusStealingPreventionLevel(); break;
        case 17: *reinterpret_cast< bool*>(_v) = _t->isLegacyFullscreenSupport(); break;
        case 18: *reinterpret_cast< KWin::Options::WindowOperation*>(_v) = _t->operationTitlebarDblClick(); break;
        case 19: *reinterpret_cast< KWin::Options::WindowOperation*>(_v) = _t->operationMaxButtonLeftClick(); break;
        case 20: *reinterpret_cast< KWin::Options::WindowOperation*>(_v) = _t->operationMaxButtonMiddleClick(); break;
        case 21: *reinterpret_cast< KWin::Options::WindowOperation*>(_v) = _t->operationMaxButtonRightClick(); break;
        case 22: *reinterpret_cast< MouseCommand*>(_v) = _t->commandActiveTitlebar1(); break;
        case 23: *reinterpret_cast< MouseCommand*>(_v) = _t->commandActiveTitlebar2(); break;
        case 24: *reinterpret_cast< MouseCommand*>(_v) = _t->commandActiveTitlebar3(); break;
        case 25: *reinterpret_cast< MouseCommand*>(_v) = _t->commandInactiveTitlebar1(); break;
        case 26: *reinterpret_cast< MouseCommand*>(_v) = _t->commandInactiveTitlebar2(); break;
        case 27: *reinterpret_cast< MouseCommand*>(_v) = _t->commandInactiveTitlebar3(); break;
        case 28: *reinterpret_cast< MouseCommand*>(_v) = _t->commandWindow1(); break;
        case 29: *reinterpret_cast< MouseCommand*>(_v) = _t->commandWindow2(); break;
        case 30: *reinterpret_cast< MouseCommand*>(_v) = _t->commandWindow3(); break;
        case 31: *reinterpret_cast< MouseCommand*>(_v) = _t->commandWindowWheel(); break;
        case 32: *reinterpret_cast< MouseCommand*>(_v) = _t->commandAll1(); break;
        case 33: *reinterpret_cast< MouseCommand*>(_v) = _t->commandAll2(); break;
        case 34: *reinterpret_cast< MouseCommand*>(_v) = _t->commandAll3(); break;
        case 35: *reinterpret_cast< uint*>(_v) = _t->keyCmdAllModKey(); break;
        case 36: *reinterpret_cast< bool*>(_v) = _t->showGeometryTip(); break;
        case 37: *reinterpret_cast< bool*>(_v) = _t->condensedTitle(); break;
        case 38: *reinterpret_cast< bool*>(_v) = _t->electricBorderMaximize(); break;
        case 39: *reinterpret_cast< bool*>(_v) = _t->electricBorderTiling(); break;
        case 40: *reinterpret_cast< float*>(_v) = _t->electricBorderCornerRatio(); break;
        case 41: *reinterpret_cast< bool*>(_v) = _t->borderlessMaximizedWindows(); break;
        case 42: *reinterpret_cast< int*>(_v) = _t->killPingTimeout(); break;
        case 43: *reinterpret_cast< bool*>(_v) = _t->isHideUtilityWindowsForInactive(); break;
        case 44: *reinterpret_cast< bool*>(_v) = _t->isInactiveTabsSkipTaskbar(); break;
        case 45: *reinterpret_cast< bool*>(_v) = _t->isAutogroupSimilarWindows(); break;
        case 46: *reinterpret_cast< bool*>(_v) = _t->isAutogroupInForeground(); break;
        case 47: *reinterpret_cast< int*>(_v) = _t->compositingMode(); break;
        case 48: *reinterpret_cast< bool*>(_v) = _t->isUseCompositing(); break;
        case 49: *reinterpret_cast< bool*>(_v) = _t->isCompositingInitialized(); break;
        case 50: *reinterpret_cast< int*>(_v) = _t->hiddenPreviews(); break;
        case 51: *reinterpret_cast< bool*>(_v) = _t->isUnredirectFullscreen(); break;
        case 52: *reinterpret_cast< int*>(_v) = _t->glSmoothScale(); break;
        case 53: *reinterpret_cast< bool*>(_v) = _t->isColorCorrected(); break;
        case 54: *reinterpret_cast< bool*>(_v) = _t->isXrenderSmoothScale(); break;
        case 55: *reinterpret_cast< qint64*>(_v) = _t->maxFpsInterval(); break;
        case 56: *reinterpret_cast< uint*>(_v) = _t->refreshRate(); break;
        case 57: *reinterpret_cast< qint64*>(_v) = _t->vBlankTime(); break;
        case 58: *reinterpret_cast< bool*>(_v) = _t->isGlStrictBinding(); break;
        case 59: *reinterpret_cast< bool*>(_v) = _t->isGlStrictBindingFollowsDriver(); break;
        case 60: *reinterpret_cast< bool*>(_v) = _t->glCoreProfile(); break;
        case 61: *reinterpret_cast< GlSwapStrategy*>(_v) = _t->glPreferBufferSwap(); break;
        case 62: *reinterpret_cast< KWin::OpenGLPlatformInterface*>(_v) = _t->glPlatformInterface(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        Options *_t = static_cast<Options *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFocusPolicy(*reinterpret_cast< FocusPolicy*>(_v)); break;
        case 1: _t->setNextFocusPrefersMouse(*reinterpret_cast< bool*>(_v)); break;
        case 2: _t->setClickRaise(*reinterpret_cast< bool*>(_v)); break;
        case 3: _t->setAutoRaise(*reinterpret_cast< bool*>(_v)); break;
        case 4: _t->setAutoRaiseInterval(*reinterpret_cast< int*>(_v)); break;
        case 5: _t->setDelayFocusInterval(*reinterpret_cast< int*>(_v)); break;
        case 6: _t->setShadeHover(*reinterpret_cast< bool*>(_v)); break;
        case 7: _t->setShadeHoverInterval(*reinterpret_cast< int*>(_v)); break;
        case 8: _t->setSeparateScreenFocus(*reinterpret_cast< bool*>(_v)); break;
        case 9: _t->setPlacement(*reinterpret_cast< int*>(_v)); break;
        case 11: _t->setBorderSnapZone(*reinterpret_cast< int*>(_v)); break;
        case 12: _t->setWindowSnapZone(*reinterpret_cast< int*>(_v)); break;
        case 13: _t->setCenterSnapZone(*reinterpret_cast< int*>(_v)); break;
        case 14: _t->setSnapOnlyWhenOverlapping(*reinterpret_cast< bool*>(_v)); break;
        case 15: _t->setRollOverDesktops(*reinterpret_cast< bool*>(_v)); break;
        case 16: _t->setFocusStealingPreventionLevel(*reinterpret_cast< int*>(_v)); break;
        case 17: _t->setLegacyFullscreenSupport(*reinterpret_cast< bool*>(_v)); break;
        case 18: _t->setOperationTitlebarDblClick(*reinterpret_cast< KWin::Options::WindowOperation*>(_v)); break;
        case 19: _t->setOperationMaxButtonLeftClick(*reinterpret_cast< KWin::Options::WindowOperation*>(_v)); break;
        case 20: _t->setOperationMaxButtonMiddleClick(*reinterpret_cast< KWin::Options::WindowOperation*>(_v)); break;
        case 21: _t->setOperationMaxButtonRightClick(*reinterpret_cast< KWin::Options::WindowOperation*>(_v)); break;
        case 22: _t->setCommandActiveTitlebar1(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 23: _t->setCommandActiveTitlebar2(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 24: _t->setCommandActiveTitlebar3(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 25: _t->setCommandInactiveTitlebar1(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 26: _t->setCommandInactiveTitlebar2(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 27: _t->setCommandInactiveTitlebar3(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 28: _t->setCommandWindow1(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 29: _t->setCommandWindow2(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 30: _t->setCommandWindow3(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 31: _t->setCommandWindowWheel(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 32: _t->setCommandAll1(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 33: _t->setCommandAll2(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 34: _t->setCommandAll3(*reinterpret_cast< MouseCommand*>(_v)); break;
        case 35: _t->setKeyCmdAllModKey(*reinterpret_cast< uint*>(_v)); break;
        case 36: _t->setShowGeometryTip(*reinterpret_cast< bool*>(_v)); break;
        case 37: _t->setCondensedTitle(*reinterpret_cast< bool*>(_v)); break;
        case 38: _t->setElectricBorderMaximize(*reinterpret_cast< bool*>(_v)); break;
        case 39: _t->setElectricBorderTiling(*reinterpret_cast< bool*>(_v)); break;
        case 40: _t->setElectricBorderCornerRatio(*reinterpret_cast< float*>(_v)); break;
        case 41: _t->setBorderlessMaximizedWindows(*reinterpret_cast< bool*>(_v)); break;
        case 42: _t->setKillPingTimeout(*reinterpret_cast< int*>(_v)); break;
        case 43: _t->setHideUtilityWindowsForInactive(*reinterpret_cast< bool*>(_v)); break;
        case 44: _t->setInactiveTabsSkipTaskbar(*reinterpret_cast< bool*>(_v)); break;
        case 45: _t->setAutogroupSimilarWindows(*reinterpret_cast< bool*>(_v)); break;
        case 46: _t->setAutogroupInForeground(*reinterpret_cast< bool*>(_v)); break;
        case 47: _t->setCompositingMode(*reinterpret_cast< int*>(_v)); break;
        case 48: _t->setUseCompositing(*reinterpret_cast< bool*>(_v)); break;
        case 49: _t->setCompositingInitialized(*reinterpret_cast< bool*>(_v)); break;
        case 50: _t->setHiddenPreviews(*reinterpret_cast< int*>(_v)); break;
        case 51: _t->setUnredirectFullscreen(*reinterpret_cast< bool*>(_v)); break;
        case 52: _t->setGlSmoothScale(*reinterpret_cast< int*>(_v)); break;
        case 53: _t->setColorCorrected(*reinterpret_cast< bool*>(_v)); break;
        case 54: _t->setXrenderSmoothScale(*reinterpret_cast< bool*>(_v)); break;
        case 55: _t->setMaxFpsInterval(*reinterpret_cast< qint64*>(_v)); break;
        case 56: _t->setRefreshRate(*reinterpret_cast< uint*>(_v)); break;
        case 57: _t->setVBlankTime(*reinterpret_cast< qint64*>(_v)); break;
        case 58: _t->setGlStrictBinding(*reinterpret_cast< bool*>(_v)); break;
        case 59: _t->setGlStrictBindingFollowsDriver(*reinterpret_cast< bool*>(_v)); break;
        case 60: _t->setGLCoreProfile(*reinterpret_cast< bool*>(_v)); break;
        case 61: _t->setGlPreferBufferSwap(*reinterpret_cast< GlSwapStrategy*>(_v)); break;
        case 62: _t->setGlPlatformInterface(*reinterpret_cast< KWin::OpenGLPlatformInterface*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

const QMetaObject KWin::Options::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_KWin__Options.data,
      qt_meta_data_KWin__Options,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

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

int KWin::Options::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 < 66)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 66;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 66)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 66;
    }
#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 -= 63;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 63;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 63;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 63;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 63;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 63;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void KWin::Options::focusPolicyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
}

// SIGNAL 1
void KWin::Options::focusPolicyIsResonableChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, Q_NULLPTR);
}

// SIGNAL 2
void KWin::Options::nextFocusPrefersMouseChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, Q_NULLPTR);
}

// SIGNAL 3
void KWin::Options::clickRaiseChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, Q_NULLPTR);
}

// SIGNAL 4
void KWin::Options::autoRaiseChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, Q_NULLPTR);
}

// SIGNAL 5
void KWin::Options::autoRaiseIntervalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, Q_NULLPTR);
}

// SIGNAL 6
void KWin::Options::delayFocusIntervalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, Q_NULLPTR);
}

// SIGNAL 7
void KWin::Options::shadeHoverChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, Q_NULLPTR);
}

// SIGNAL 8
void KWin::Options::shadeHoverIntervalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, Q_NULLPTR);
}

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

// SIGNAL 10
void KWin::Options::placementChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, Q_NULLPTR);
}

// SIGNAL 11
void KWin::Options::borderSnapZoneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, Q_NULLPTR);
}

// SIGNAL 12
void KWin::Options::windowSnapZoneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, Q_NULLPTR);
}

// SIGNAL 13
void KWin::Options::centerSnapZoneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, Q_NULLPTR);
}

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

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

// SIGNAL 16
void KWin::Options::focusStealingPreventionLevelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, Q_NULLPTR);
}

// SIGNAL 17
void KWin::Options::legacyFullscreenSupportChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, Q_NULLPTR);
}

// SIGNAL 18
void KWin::Options::operationTitlebarDblClickChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, Q_NULLPTR);
}

// SIGNAL 19
void KWin::Options::operationMaxButtonLeftClickChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, Q_NULLPTR);
}

// SIGNAL 20
void KWin::Options::operationMaxButtonRightClickChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, Q_NULLPTR);
}

// SIGNAL 21
void KWin::Options::operationMaxButtonMiddleClickChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, Q_NULLPTR);
}

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

// SIGNAL 23
void KWin::Options::commandActiveTitlebar2Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 23, Q_NULLPTR);
}

// SIGNAL 24
void KWin::Options::commandActiveTitlebar3Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 24, Q_NULLPTR);
}

// SIGNAL 25
void KWin::Options::commandInactiveTitlebar1Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 25, Q_NULLPTR);
}

// SIGNAL 26
void KWin::Options::commandInactiveTitlebar2Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 26, Q_NULLPTR);
}

// SIGNAL 27
void KWin::Options::commandInactiveTitlebar3Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 27, Q_NULLPTR);
}

// SIGNAL 28
void KWin::Options::commandWindow1Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 28, Q_NULLPTR);
}

// SIGNAL 29
void KWin::Options::commandWindow2Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 29, Q_NULLPTR);
}

// SIGNAL 30
void KWin::Options::commandWindow3Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 30, Q_NULLPTR);
}

// SIGNAL 31
void KWin::Options::commandWindowWheelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 31, Q_NULLPTR);
}

// SIGNAL 32
void KWin::Options::commandAll1Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 32, Q_NULLPTR);
}

// SIGNAL 33
void KWin::Options::commandAll2Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 33, Q_NULLPTR);
}

// SIGNAL 34
void KWin::Options::commandAll3Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 34, Q_NULLPTR);
}

// SIGNAL 35
void KWin::Options::keyCmdAllModKeyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, Q_NULLPTR);
}

// SIGNAL 36
void KWin::Options::showGeometryTipChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 36, Q_NULLPTR);
}

// SIGNAL 37
void KWin::Options::condensedTitleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 37, Q_NULLPTR);
}

// SIGNAL 38
void KWin::Options::electricBorderMaximizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 38, Q_NULLPTR);
}

// SIGNAL 39
void KWin::Options::electricBorderTilingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 39, Q_NULLPTR);
}

// SIGNAL 40
void KWin::Options::electricBorderCornerRatioChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 40, Q_NULLPTR);
}

// SIGNAL 41
void KWin::Options::borderlessMaximizedWindowsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 41, Q_NULLPTR);
}

// SIGNAL 42
void KWin::Options::killPingTimeoutChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 42, Q_NULLPTR);
}

// SIGNAL 43
void KWin::Options::hideUtilityWindowsForInactiveChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 43, Q_NULLPTR);
}

// SIGNAL 44
void KWin::Options::inactiveTabsSkipTaskbarChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 44, Q_NULLPTR);
}

// SIGNAL 45
void KWin::Options::autogroupSimilarWindowsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 45, Q_NULLPTR);
}

// SIGNAL 46
void KWin::Options::autogroupInForegroundChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 46, Q_NULLPTR);
}

// SIGNAL 47
void KWin::Options::compositingModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 47, Q_NULLPTR);
}

// SIGNAL 48
void KWin::Options::useCompositingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 48, Q_NULLPTR);
}

// SIGNAL 49
void KWin::Options::compositingInitializedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 49, Q_NULLPTR);
}

// SIGNAL 50
void KWin::Options::hiddenPreviewsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 50, Q_NULLPTR);
}

// SIGNAL 51
void KWin::Options::unredirectFullscreenChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 51, Q_NULLPTR);
}

// SIGNAL 52
void KWin::Options::glSmoothScaleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 52, Q_NULLPTR);
}

// SIGNAL 53
void KWin::Options::colorCorrectedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 53, Q_NULLPTR);
}

// SIGNAL 54
void KWin::Options::xrenderSmoothScaleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 54, Q_NULLPTR);
}

// SIGNAL 55
void KWin::Options::maxFpsIntervalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 55, Q_NULLPTR);
}

// SIGNAL 56
void KWin::Options::refreshRateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 56, Q_NULLPTR);
}

// SIGNAL 57
void KWin::Options::vBlankTimeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 57, Q_NULLPTR);
}

// SIGNAL 58
void KWin::Options::glStrictBindingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 58, Q_NULLPTR);
}

// SIGNAL 59
void KWin::Options::glStrictBindingFollowsDriverChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 59, Q_NULLPTR);
}

// SIGNAL 60
void KWin::Options::glCoreProfileChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 60, Q_NULLPTR);
}

// SIGNAL 61
void KWin::Options::glPreferBufferSwapChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 61, Q_NULLPTR);
}

// SIGNAL 62
void KWin::Options::glPlatformInterfaceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 62, Q_NULLPTR);
}

// SIGNAL 63
void KWin::Options::configChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 63, Q_NULLPTR);
}
QT_END_MOC_NAMESPACE
