diff --git a/options.cpp b/options.cpp
index a250e79139..0e26929b13 100644
--- a/options.cpp
+++ b/options.cpp
@@ -127,6 +127,564 @@ Options::~Options()
 {
 }
 
+void Options::setFocusPolicy(FocusPolicy focusPolicy)
+{
+    if (m_focusPolicy == focusPolicy) {
+        return;
+    }
+    m_focusPolicy = focusPolicy;
+    emit focusPolicyChanged();
+}
+
+void Options::setNextFocusPrefersMouse(bool nextFocusPrefersMouse)
+{
+    if (m_nextFocusPrefersMouse == nextFocusPrefersMouse) {
+        return;
+    }
+    m_nextFocusPrefersMouse = nextFocusPrefersMouse;
+    emit nextFocusPrefersMouseChanged();
+}
+
+void Options::setClickRaise(bool clickRaise)
+{
+    if (m_clickRaise == clickRaise) {
+        return;
+    }
+    m_clickRaise = clickRaise;
+    emit clickRaiseChanged();
+}
+
+void Options::setAutoRaise(bool autoRaise)
+{
+    if (m_autoRaise == autoRaise) {
+        return;
+    }
+    m_autoRaise = autoRaise;
+    emit autoRaiseChanged();
+}
+
+void Options::setAutoRaiseInterval(int autoRaiseInterval)
+{
+    if (m_autoRaiseInterval == autoRaiseInterval) {
+        return;
+    }
+    m_autoRaiseInterval = autoRaiseInterval;
+    emit autoRaiseIntervalChanged();
+}
+
+void Options::setDelayFocusInterval(int delayFocusInterval)
+{
+    if (m_delayFocusInterval == delayFocusInterval) {
+        return;
+    }
+    m_delayFocusInterval = delayFocusInterval;
+    emit delayFocusIntervalChanged();
+}
+
+void Options::setShadeHover(bool shadeHover)
+{
+    if (m_shadeHover == shadeHover) {
+        return;
+    }
+    m_shadeHover = shadeHover;
+    emit shadeHoverChanged();
+}
+
+void Options::setShadeHoverInterval(int shadeHoverInterval)
+{
+    if (m_shadeHoverInterval == shadeHoverInterval) {
+        return;
+    }
+    m_shadeHoverInterval = shadeHoverInterval;
+    emit shadeHoverIntervalChanged();
+}
+
+void Options::setTiling(bool tiling)
+{
+    if (m_tilingOn == tiling) {
+        return;
+    }
+    m_tilingOn = tiling;
+    emit tilingChanged();
+}
+
+void Options::setTilingLayout(int tilingLayout)
+{
+    if (m_tilingLayout == static_cast<TilingLayoutFactory::Layouts>(tilingLayout)) {
+        return;
+    }
+    m_tilingLayout = static_cast<TilingLayoutFactory::Layouts>(tilingLayout);
+    emit tilingLayoutChanged();
+}
+
+void Options::setTilingRaisePolicy(int tilingRaisePolicy)
+{
+    if (m_tilingRaisePolicy == tilingRaisePolicy) {
+        return;
+    }
+    m_tilingRaisePolicy = tilingRaisePolicy;
+    emit tilingRaisePolicyChanged();
+}
+
+void Options::setSeparateScreenFocus(bool separateScreenFocus)
+{
+    if (m_separateScreenFocus == separateScreenFocus) {
+        return;
+    }
+    m_separateScreenFocus = separateScreenFocus;
+    emit separateScreenFocusChanged();
+}
+
+void Options::setActiveMouseScreen(bool activeMouseScreen)
+{
+    if (m_activeMouseScreen == activeMouseScreen) {
+        return;
+    }
+    m_activeMouseScreen = activeMouseScreen;
+    emit activeMouseScreenChanged();
+}
+
+void Options::setPlacement(int placement)
+{
+    if (m_placement == static_cast<Placement::Policy>(placement)) {
+        return;
+    }
+    m_placement = static_cast<Placement::Policy>(placement);
+    emit placementChanged();
+}
+
+void Options::setBorderSnapZone(int borderSnapZone)
+{
+    if (m_borderSnapZone == borderSnapZone) {
+        return;
+    }
+    m_borderSnapZone = borderSnapZone;
+    emit borderSnapZoneChanged();
+}
+
+void Options::setWindowSnapZone(int windowSnapZone)
+{
+    if (m_windowSnapZone == windowSnapZone) {
+        return;
+    }
+    m_windowSnapZone = windowSnapZone;
+    emit windowSnapZoneChanged();
+}
+
+void Options::setCenterSnapZone(int centerSnapZone)
+{
+    if (m_centerSnapZone == centerSnapZone) {
+        return;
+    }
+    m_centerSnapZone = centerSnapZone;
+    emit centerSnapZoneChanged();
+}
+
+void Options::setSnapOnlyWhenOverlapping(bool snapOnlyWhenOverlapping)
+{
+    if (m_snapOnlyWhenOverlapping == snapOnlyWhenOverlapping) {
+        return;
+    }
+    m_snapOnlyWhenOverlapping = snapOnlyWhenOverlapping;
+    emit snapOnlyWhenOverlappingChanged();
+}
+
+void Options::setShowDesktopIsMinimizeAll(bool showDesktopIsMinimizeAll)
+{
+    if (m_showDesktopIsMinimizeAll == showDesktopIsMinimizeAll) {
+        return;
+    }
+    m_showDesktopIsMinimizeAll = showDesktopIsMinimizeAll;
+    emit showDesktopIsMinimizeAllChanged();
+}
+
+void Options::setRollOverDesktops(bool rollOverDesktops)
+{
+    if (m_rollOverDesktops == rollOverDesktops) {
+        return;
+    }
+    m_rollOverDesktops = rollOverDesktops;
+    emit rollOverDesktopsChanged();
+}
+
+void Options::setFocusStealingPreventionLevel(int focusStealingPreventionLevel)
+{
+    if (m_focusStealingPreventionLevel == focusStealingPreventionLevel) {
+        return;
+    }
+    m_focusStealingPreventionLevel = focusStealingPreventionLevel;
+    emit focusStealingPreventionLevelChanged();
+}
+
+void Options::setLegacyFullscreenSupport(bool legacyFullscreenSupport)
+{
+    if (m_legacyFullscreenSupport == legacyFullscreenSupport) {
+        return;
+    }
+    m_legacyFullscreenSupport = legacyFullscreenSupport;
+    emit legacyFullscreenSupportChanged();
+}
+
+void Options::setOperationTitlebarDblClick(WindowOperation operationTitlebarDblClick)
+{
+    if (OpTitlebarDblClick == operationTitlebarDblClick) {
+        return;
+    }
+    OpTitlebarDblClick = operationTitlebarDblClick;
+    emit operationTitlebarDblClickChanged();
+}
+
+void Options::setCommandActiveTitlebar1(MouseCommand commandActiveTitlebar1)
+{
+    if (CmdActiveTitlebar1 == commandActiveTitlebar1) {
+        return;
+    }
+    CmdActiveTitlebar1 = commandActiveTitlebar1;
+    emit commandActiveTitlebar1Changed();
+}
+
+void Options::setCommandActiveTitlebar2(MouseCommand commandActiveTitlebar2)
+{
+    if (CmdActiveTitlebar2 == commandActiveTitlebar2) {
+        return;
+    }
+    CmdActiveTitlebar2 = commandActiveTitlebar2;
+    emit commandActiveTitlebar2Changed();
+}
+
+void Options::setCommandActiveTitlebar3(MouseCommand commandActiveTitlebar3)
+{
+    if (CmdActiveTitlebar3 == commandActiveTitlebar3) {
+        return;
+    }
+    CmdActiveTitlebar3 = commandActiveTitlebar3;
+    emit commandActiveTitlebar3Changed();
+}
+
+void Options::setCommandInactiveTitlebar1(MouseCommand commandInactiveTitlebar1)
+{
+    if (CmdInactiveTitlebar1 == commandInactiveTitlebar1) {
+        return;
+    }
+    CmdInactiveTitlebar1 = commandInactiveTitlebar1;
+    emit commandInactiveTitlebar1Changed();
+}
+
+void Options::setCommandInactiveTitlebar2(MouseCommand commandInactiveTitlebar2)
+{
+    if (CmdInactiveTitlebar2 == commandInactiveTitlebar2) {
+        return;
+    }
+    CmdInactiveTitlebar2 = commandInactiveTitlebar2;
+    emit commandInactiveTitlebar2Changed();
+}
+
+void Options::setCommandInactiveTitlebar3(MouseCommand commandInactiveTitlebar3)
+{
+    if (CmdInactiveTitlebar3 == commandInactiveTitlebar3) {
+        return;
+    }
+    CmdInactiveTitlebar3 = commandInactiveTitlebar3;
+    emit commandInactiveTitlebar3Changed();
+}
+
+void Options::setCommandWindow1(MouseCommand commandWindow1)
+{
+    if (CmdWindow1 == commandWindow1) {
+        return;
+    }
+    CmdWindow1 = commandWindow1;
+    emit commandWindow1Changed();
+}
+
+void Options::setCommandWindow2(MouseCommand commandWindow2)
+{
+    if (CmdWindow2 == commandWindow2) {
+        return;
+    }
+    CmdWindow2 = commandWindow2;
+    emit commandWindow2Changed();
+}
+
+void Options::setCommandWindow3(MouseCommand commandWindow3)
+{
+    if (CmdWindow3 == commandWindow3) {
+        return;
+    }
+    CmdWindow3 = commandWindow3;
+    emit commandWindow3Changed();
+}
+
+void Options::setCommandWindowWheel(MouseCommand commandWindowWheel)
+{
+    if (CmdWindowWheel == commandWindowWheel) {
+        return;
+    }
+    CmdWindowWheel = commandWindowWheel;
+    emit commandWindowWheelChanged();
+}
+
+void Options::setCommandAll1(MouseCommand commandAll1)
+{
+    if (CmdAll1 == commandAll1) {
+        return;
+    }
+    CmdAll1 = commandAll1;
+    emit commandAll1Changed();
+}
+
+void Options::setCommandAll2(MouseCommand commandAll2)
+{
+    if (CmdAll2 == commandAll2) {
+        return;
+    }
+    CmdAll2 = commandAll2;
+    emit commandAll2Changed();
+}
+
+void Options::setCommandAll3(MouseCommand commandAll3)
+{
+    if (CmdAll3 == commandAll3) {
+        return;
+    }
+    CmdAll3 = commandAll3;
+    emit commandAll3Changed();
+}
+
+void Options::setKeyCmdAllModKey(uint keyCmdAllModKey)
+{
+    if (CmdAllModKey == keyCmdAllModKey) {
+        return;
+    }
+    CmdAllModKey = keyCmdAllModKey;
+    emit keyCmdAllModKeyChanged();
+}
+
+void Options::setShowGeometryTip(bool showGeometryTip)
+{
+    if (show_geometry_tip == showGeometryTip) {
+        return;
+    }
+    show_geometry_tip = showGeometryTip;
+    emit showGeometryTipChanged();
+}
+
+void Options::setElectricBorderDelay(int electricBorderDelay)
+{
+    if (electric_border_delay == electricBorderDelay) {
+        return;
+    }
+    electric_border_delay = electricBorderDelay;
+    emit electricBorderDelayChanged();
+}
+
+void Options::setElectricBorderCooldown(int electricBorderCooldown)
+{
+    if (electric_border_cooldown == electricBorderCooldown) {
+        return;
+    }
+    electric_border_cooldown = electricBorderCooldown;
+    emit electricBorderCooldownChanged();
+}
+
+void Options::setElectricBorderPushbackPixels(int electricBorderPushbackPixels)
+{
+    if (electric_border_pushback_pixels == electricBorderPushbackPixels) {
+        return;
+    }
+    electric_border_pushback_pixels = electricBorderPushbackPixels;
+    emit electricBorderPushbackPixelsChanged();
+}
+
+void Options::setElectricBorderMaximize(bool electricBorderMaximize)
+{
+    if (electric_border_maximize == electricBorderMaximize) {
+        return;
+    }
+    electric_border_maximize = electricBorderMaximize;
+    emit electricBorderMaximizeChanged();
+}
+
+void Options::setElectricBorderTiling(bool electricBorderTiling)
+{
+    if (electric_border_tiling == electricBorderTiling) {
+        return;
+    }
+    electric_border_tiling = electricBorderTiling;
+    emit electricBorderTilingChanged();
+}
+
+void Options::setBorderlessMaximizedWindows(bool borderlessMaximizedWindows)
+{
+    if (borderless_maximized_windows == borderlessMaximizedWindows) {
+        return;
+    }
+    borderless_maximized_windows = borderlessMaximizedWindows;
+    emit borderlessMaximizedWindowsChanged();
+}
+
+void Options::setKillPingTimeout(int killPingTimeout)
+{
+    if (m_killPingTimeout == killPingTimeout) {
+        return;
+    }
+    m_killPingTimeout = killPingTimeout;
+    emit killPingTimeoutChanged();
+}
+
+void Options::setHideUtilityWindowsForInactive(bool hideUtilityWindowsForInactive)
+{
+    if (m_hideUtilityWindowsForInactive == hideUtilityWindowsForInactive) {
+        return;
+    }
+    m_hideUtilityWindowsForInactive = hideUtilityWindowsForInactive;
+    emit hideUtilityWindowsForInactiveChanged();
+}
+
+void Options::setInactiveTabsSkipTaskbar(bool inactiveTabsSkipTaskbar)
+{
+    if (m_inactiveTabsSkipTaskbar == inactiveTabsSkipTaskbar) {
+        return;
+    }
+    m_inactiveTabsSkipTaskbar = inactiveTabsSkipTaskbar;
+    emit inactiveTabsSkipTaskbarChanged();
+}
+
+void Options::setAutogroupSimilarWindows(bool autogroupSimilarWindows)
+{
+    if (m_autogroupSimilarWindows == autogroupSimilarWindows) {
+        return;
+    }
+    m_autogroupSimilarWindows = autogroupSimilarWindows;
+    emit autogroupSimilarWindowsChanged();
+}
+
+void Options::setAutogroupInForeground(bool autogroupInForeground)
+{
+    if (m_autogroupInForeground == autogroupInForeground) {
+        return;
+    }
+    m_autogroupInForeground = autogroupInForeground;
+    emit autogroupInForegroundChanged();
+}
+
+void Options::setCompositingMode(int compositingMode)
+{
+    if (m_compositingMode == static_cast<CompositingType>(compositingMode)) {
+        return;
+    }
+    m_compositingMode = static_cast<CompositingType>(compositingMode);
+    emit compositingModeChanged();
+}
+
+void Options::setUseCompositing(bool useCompositing)
+{
+    if (m_useCompositing == useCompositing) {
+        return;
+    }
+    m_useCompositing = useCompositing;
+    emit useCompositingChanged();
+}
+
+void Options::setCompositingInitialized(bool compositingInitialized)
+{
+    if (m_compositingInitialized == compositingInitialized) {
+        return;
+    }
+    m_compositingInitialized = compositingInitialized;
+    emit compositingInitializedChanged();
+}
+
+void Options::setHiddenPreviews(int hiddenPreviews)
+{
+    if (m_hiddenPreviews == static_cast<HiddenPreviews>(hiddenPreviews)) {
+        return;
+    }
+    m_hiddenPreviews = static_cast<HiddenPreviews>(hiddenPreviews);
+    emit hiddenPreviewsChanged();
+}
+
+void Options::setUnredirectFullscreen(bool unredirectFullscreen)
+{
+    if (m_unredirectFullscreen == unredirectFullscreen) {
+        return;
+    }
+    m_unredirectFullscreen = unredirectFullscreen;
+    emit unredirectFullscreenChanged();
+}
+
+void Options::setGlSmoothScale(int glSmoothScale)
+{
+    if (m_glSmoothScale == glSmoothScale) {
+        return;
+    }
+    m_glSmoothScale = glSmoothScale;
+    emit glSmoothScaleChanged();
+}
+
+void Options::setGlVSync(bool glVSync)
+{
+    if (m_glVSync == glVSync) {
+        return;
+    }
+    m_glVSync = glVSync;
+    emit glVSyncChanged();
+}
+
+void Options::setXrenderSmoothScale(bool xrenderSmoothScale)
+{
+    if (m_xrenderSmoothScale == xrenderSmoothScale) {
+        return;
+    }
+    m_xrenderSmoothScale = xrenderSmoothScale;
+    emit xrenderSmoothScaleChanged();
+}
+
+void Options::setMaxFpsInterval(uint maxFpsInterval)
+{
+    if (m_maxFpsInterval == maxFpsInterval) {
+        return;
+    }
+    m_maxFpsInterval = maxFpsInterval;
+    emit maxFpsIntervalChanged();
+}
+
+void Options::setRefreshRate(uint refreshRate)
+{
+    if (m_refreshRate == refreshRate) {
+        return;
+    }
+    m_refreshRate = refreshRate;
+    emit refreshRateChanged();
+}
+
+void Options::setGlDirect(bool glDirect)
+{
+    if (m_glDirect == glDirect) {
+        return;
+    }
+    m_glDirect = glDirect;
+    emit glDirectChanged();
+}
+
+void Options::setGlStrictBinding(bool glStrictBinding)
+{
+    if (m_glStrictBinding == glStrictBinding) {
+        return;
+    }
+    m_glStrictBinding = glStrictBinding;
+    emit glStrictBindingChanged();
+}
+
+void Options::setElectricBorders(int borders)
+{
+    if (electric_borders == borders) {
+        return;
+    }
+    electric_borders = borders;
+    emit electricBordersChanged();
+}
+
 unsigned long Options::updateSettings()
 {
     KSharedConfig::Ptr _config = KGlobal::config();
diff --git a/options.h b/options.h
index 855ed78ccc..356e67c95f 100644
--- a/options.h
+++ b/options.h
@@ -44,155 +44,155 @@ class Options : public QObject, public KDecorationOptions
     Q_ENUMS(MouseCommand)
     Q_ENUMS(MouseWheelCommand)
 
-    Q_PROPERTY(FocusPolicy focusPolicy READ focusPolicy NOTIFY configChanged)
-    Q_PROPERTY(bool nextFocusPrefersMouse READ isNextFocusPrefersMouse NOTIFY configChanged)
+    Q_PROPERTY(FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy NOTIFY focusPolicyChanged)
+    Q_PROPERTY(bool nextFocusPrefersMouse READ isNextFocusPrefersMouse WRITE setNextFocusPrefersMouse NOTIFY nextFocusPrefersMouseChanged)
     /**
        Whether clicking on a window raises it in FocusFollowsMouse
        mode or not.
      */
-    Q_PROPERTY(bool clickRaise READ isClickRaise NOTIFY configChanged)
+    Q_PROPERTY(bool clickRaise READ isClickRaise WRITE setClickRaise NOTIFY clickRaiseChanged)
     /**
        whether autoraise is enabled FocusFollowsMouse mode or not.
      */
-    Q_PROPERTY(bool autoRaise READ isAutoRaise NOTIFY configChanged)
+    Q_PROPERTY(bool autoRaise READ isAutoRaise WRITE setAutoRaise NOTIFY autoRaiseChanged)
     /**
        autoraise interval
      */
-    Q_PROPERTY(int autoRaiseInterval READ autoRaiseInterval NOTIFY configChanged)
+    Q_PROPERTY(int autoRaiseInterval READ autoRaiseInterval WRITE setAutoRaiseInterval NOTIFY autoRaiseIntervalChanged)
     /**
        delayed focus interval
      */
-    Q_PROPERTY(int delayFocusInterval READ delayFocusInterval NOTIFY configChanged)
+    Q_PROPERTY(int delayFocusInterval READ delayFocusInterval WRITE setDelayFocusInterval NOTIFY delayFocusIntervalChanged)
     /**
        Whether shade hover is enabled or not
      */
-    Q_PROPERTY(bool shadeHover READ isShadeHover NOTIFY configChanged)
+    Q_PROPERTY(bool shadeHover READ isShadeHover WRITE setShadeHover NOTIFY shadeHoverChanged)
     /**
        shade hover interval
      */
-    Q_PROPERTY(int shadeHoverInterval READ shadeHoverInterval NOTIFY configChanged)
+    Q_PROPERTY(int shadeHoverInterval READ shadeHoverInterval WRITE setShadeHoverInterval NOTIFY shadeHoverIntervalChanged)
     /**
      * Whether tiling is enabled or not
      */
-    Q_PROPERTY(bool tiling  READ isTilingOn WRITE setTilingOn NOTIFY configChanged)
-    Q_PROPERTY(int tilingLayout READ tilingLayout NOTIFY configChanged)
+    Q_PROPERTY(bool tiling READ isTilingOn WRITE setTilingOn WRITE setTiling NOTIFY tilingChanged)
+    Q_PROPERTY(int tilingLayout READ tilingLayout WRITE setTilingLayout NOTIFY tilingLayoutChanged)
     /**
      * Tiling window raise policy.
      */
-    Q_PROPERTY(int tilingRaisePolicy READ tilingRaisePolicy NOTIFY configChanged)
+    Q_PROPERTY(int tilingRaisePolicy READ tilingRaisePolicy WRITE setTilingRaisePolicy NOTIFY tilingRaisePolicyChanged)
     /**
      * whether to see Xinerama screens separately for focus (in Alt+Tab, when activating next client)
      **/
-    Q_PROPERTY(bool separateScreenFocus READ isSeparateScreenFocus NOTIFY configChanged)
+    Q_PROPERTY(bool separateScreenFocus READ isSeparateScreenFocus WRITE setSeparateScreenFocus NOTIFY separateScreenFocusChanged)
     /**
      * whether active Xinerama screen is the one with mouse (or with the active window)
      **/
-    Q_PROPERTY(bool activeMouseScreen READ isActiveMouseScreen NOTIFY configChanged)
-    Q_PROPERTY(int placement READ placement NOTIFY configChanged)
+    Q_PROPERTY(bool activeMouseScreen READ isActiveMouseScreen WRITE setActiveMouseScreen NOTIFY activeMouseScreenChanged)
+    Q_PROPERTY(int placement READ placement WRITE setPlacement NOTIFY placementChanged)
     Q_PROPERTY(bool focusPolicyIsReasonable READ focusPolicyIsReasonable NOTIFY configChanged)
     /**
      * the size of the zone that triggers snapping on desktop borders
      */
-    Q_PROPERTY(int borderSnapZone READ borderSnapZone NOTIFY configChanged)
+    Q_PROPERTY(int borderSnapZone READ borderSnapZone WRITE setBorderSnapZone NOTIFY borderSnapZoneChanged)
     /**
      * the size of the zone that triggers snapping with other windows
      */
-    Q_PROPERTY(int windowSnapZone READ windowSnapZone NOTIFY configChanged)
+    Q_PROPERTY(int windowSnapZone READ windowSnapZone WRITE setWindowSnapZone NOTIFY windowSnapZoneChanged)
     /**
      * the size of the zone that triggers snapping on the screen center
      */
-    Q_PROPERTY(int centerSnapZone READ centerSnapZone NOTIFY configChanged)
+    Q_PROPERTY(int centerSnapZone READ centerSnapZone WRITE setCenterSnapZone NOTIFY centerSnapZoneChanged)
     /**
      * snap only when windows will overlap
      */
-    Q_PROPERTY(bool snapOnlyWhenOverlapping READ isSnapOnlyWhenOverlapping NOTIFY configChanged)
-    Q_PROPERTY(bool showDesktopIsMinimizeAll READ isShowDesktopIsMinimizeAll NOTIFY configChanged)
+    Q_PROPERTY(bool snapOnlyWhenOverlapping READ isSnapOnlyWhenOverlapping WRITE setSnapOnlyWhenOverlapping NOTIFY snapOnlyWhenOverlappingChanged)
+    Q_PROPERTY(bool showDesktopIsMinimizeAll READ isShowDesktopIsMinimizeAll WRITE setShowDesktopIsMinimizeAll NOTIFY showDesktopIsMinimizeAllChanged)
     /**
      * whether or not we roll over to the other edge when switching desktops past the edge
      */
-    Q_PROPERTY(bool rollOverDesktops READ isRollOverDesktops NOTIFY configChanged)
+    Q_PROPERTY(bool rollOverDesktops READ isRollOverDesktops WRITE setRollOverDesktops NOTIFY rollOverDesktopsChanged)
     /**
      * 0 - 4 , see Workspace::allowClientActivation()
      **/
-    Q_PROPERTY(int focusStealingPreventionLevel READ focusStealingPreventionLevel NOTIFY configChanged)
+    Q_PROPERTY(int focusStealingPreventionLevel READ focusStealingPreventionLevel WRITE setFocusStealingPreventionLevel NOTIFY focusStealingPreventionLevelChanged)
     /**
     * support legacy fullscreen windows hack: borderless non-netwm windows with screen geometry
     */
-    Q_PROPERTY(bool legacyFullscreenSupport READ isLegacyFullscreenSupport NOTIFY configChanged)
-    Q_PROPERTY(WindowOperation operationTitlebarDblClick READ operationTitlebarDblClick NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandActiveTitlebar1 READ commandActiveTitlebar1 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandActiveTitlebar2 READ commandActiveTitlebar2 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandActiveTitlebar3 READ commandActiveTitlebar3 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandInactiveTitlebar1 READ commandInactiveTitlebar1 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandInactiveTitlebar2 READ commandInactiveTitlebar2 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandInactiveTitlebar3 READ commandInactiveTitlebar3 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandWindow1 READ commandWindow1 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandWindow2 READ commandWindow2 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandWindow3 READ commandWindow3 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandWindowWheel READ commandWindowWheel NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandAll1 READ commandAll1 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandAll2 READ commandAll2 NOTIFY configChanged)
-    Q_PROPERTY(MouseCommand commandAll3 READ commandAll3 NOTIFY configChanged)
-    Q_PROPERTY(uint keyCmdAllModKey READ keyCmdAllModKey NOTIFY configChanged)
+    Q_PROPERTY(bool legacyFullscreenSupport READ isLegacyFullscreenSupport WRITE setLegacyFullscreenSupport NOTIFY legacyFullscreenSupportChanged)
+    Q_PROPERTY(WindowOperation operationTitlebarDblClick READ operationTitlebarDblClick WRITE setOperationTitlebarDblClick NOTIFY operationTitlebarDblClickChanged)
+    Q_PROPERTY(MouseCommand commandActiveTitlebar1 READ commandActiveTitlebar1 WRITE setCommandActiveTitlebar1 NOTIFY commandActiveTitlebar1Changed)
+    Q_PROPERTY(MouseCommand commandActiveTitlebar2 READ commandActiveTitlebar2 WRITE setCommandActiveTitlebar2 NOTIFY commandActiveTitlebar2Changed)
+    Q_PROPERTY(MouseCommand commandActiveTitlebar3 READ commandActiveTitlebar3 WRITE setCommandActiveTitlebar3 NOTIFY commandActiveTitlebar3Changed)
+    Q_PROPERTY(MouseCommand commandInactiveTitlebar1 READ commandInactiveTitlebar1 WRITE setCommandInactiveTitlebar1 NOTIFY commandInactiveTitlebar1Changed)
+    Q_PROPERTY(MouseCommand commandInactiveTitlebar2 READ commandInactiveTitlebar2 WRITE setCommandInactiveTitlebar2 NOTIFY commandInactiveTitlebar2Changed)
+    Q_PROPERTY(MouseCommand commandInactiveTitlebar3 READ commandInactiveTitlebar3 WRITE setCommandInactiveTitlebar3 NOTIFY commandInactiveTitlebar3Changed)
+    Q_PROPERTY(MouseCommand commandWindow1 READ commandWindow1 WRITE setCommandWindow1 NOTIFY commandWindow1Changed)
+    Q_PROPERTY(MouseCommand commandWindow2 READ commandWindow2 WRITE setCommandWindow2 NOTIFY commandWindow2Changed)
+    Q_PROPERTY(MouseCommand commandWindow3 READ commandWindow3 WRITE setCommandWindow3 NOTIFY commandWindow3Changed)
+    Q_PROPERTY(MouseCommand commandWindowWheel READ commandWindowWheel WRITE setCommandWindowWheel NOTIFY commandWindowWheelChanged)
+    Q_PROPERTY(MouseCommand commandAll1 READ commandAll1 WRITE setCommandAll1 NOTIFY commandAll1Changed)
+    Q_PROPERTY(MouseCommand commandAll2 READ commandAll2 WRITE setCommandAll2 NOTIFY commandAll2Changed)
+    Q_PROPERTY(MouseCommand commandAll3 READ commandAll3 WRITE setCommandAll3 NOTIFY commandAll3Changed)
+    Q_PROPERTY(uint keyCmdAllModKey READ keyCmdAllModKey WRITE setKeyCmdAllModKey NOTIFY keyCmdAllModKeyChanged)
     /**
     * whether the Geometry Tip should be shown during a window move/resize.
     */
-    Q_PROPERTY(bool showGeometryTip READ showGeometryTip NOTIFY configChanged)
+    Q_PROPERTY(bool showGeometryTip READ showGeometryTip WRITE setShowGeometryTip NOTIFY showGeometryTipChanged)
     /**
     * Whether electric borders are enabled. With electric borders
     * you can change desktop by moving the mouse pointer towards the edge
     * of the screen
     */
-    Q_PROPERTY(bool electricBorders READ electricBorders NOTIFY configChanged)
+    Q_PROPERTY(bool electricBorders READ electricBorders NOTIFY electricBordersChanged)
     /**
     * the activation delay for electric borders in milliseconds.
     */
-    Q_PROPERTY(int electricBorderDelay READ electricBorderDelay NOTIFY configChanged)
+    Q_PROPERTY(int electricBorderDelay READ electricBorderDelay WRITE setElectricBorderDelay NOTIFY electricBorderDelayChanged)
     /**
     * the trigger cooldown for electric borders in milliseconds.
     */
-    Q_PROPERTY(int electricBorderCooldown READ electricBorderCooldown NOTIFY configChanged)
+    Q_PROPERTY(int electricBorderCooldown READ electricBorderCooldown WRITE setElectricBorderCooldown NOTIFY electricBorderCooldownChanged)
     /**
     * the number of pixels the mouse cursor is pushed back when it reaches the screen edge.
     */
-    Q_PROPERTY(int electricBorderPushbackPixels READ electricBorderPushbackPixels NOTIFY configChanged)
+    Q_PROPERTY(int electricBorderPushbackPixels READ electricBorderPushbackPixels WRITE setElectricBorderPushbackPixels NOTIFY electricBorderPushbackPixelsChanged)
     /**
     * Whether a window gets maximized when it reaches top screen edge while being moved.
     */
-    Q_PROPERTY(bool electricBorderMaximize READ electricBorderMaximize NOTIFY configChanged)
+    Q_PROPERTY(bool electricBorderMaximize READ electricBorderMaximize WRITE setElectricBorderMaximize NOTIFY electricBorderMaximizeChanged)
     /**
     * Whether a window is tiled to half screen when reaching left or right screen edge while been moved
     */
-    Q_PROPERTY(bool electricBorderTiling READ electricBorderTiling NOTIFY configChanged)
-    Q_PROPERTY(bool borderlessMaximizedWindows READ borderlessMaximizedWindows NOTIFY configChanged)
+    Q_PROPERTY(bool electricBorderTiling READ electricBorderTiling WRITE setElectricBorderTiling NOTIFY electricBorderTilingChanged)
+    Q_PROPERTY(bool borderlessMaximizedWindows READ borderlessMaximizedWindows WRITE setBorderlessMaximizedWindows NOTIFY borderlessMaximizedWindowsChanged)
     /**
      * timeout before non-responding application will be killed after attempt to close
      **/
-    Q_PROPERTY(int killPingTimeout READ killPingTimeout NOTIFY configChanged)
+    Q_PROPERTY(int killPingTimeout READ killPingTimeout WRITE setKillPingTimeout NOTIFY killPingTimeoutChanged)
     /**
      * Whether to hide utility windows for inactive applications.
      **/
-    Q_PROPERTY(bool hideUtilityWindowsForInactive READ isHideUtilityWindowsForInactive NOTIFY configChanged)
-    Q_PROPERTY(bool inactiveTabsSkipTaskbar READ isInactiveTabsSkipTaskbar NOTIFY configChanged)
-    Q_PROPERTY(bool autogroupSimilarWindows READ isAutogroupSimilarWindows NOTIFY configChanged)
-    Q_PROPERTY(bool autogroupInForeground READ isAutogroupInForeground NOTIFY configChanged)
-    Q_PROPERTY(int compositingMode READ compositingMode NOTIFY configChanged)
-    Q_PROPERTY(bool useCompositing READ isUseCompositing NOTIFY configChanged)
-    Q_PROPERTY(bool compositingInitialized READ isCompositingInitialized WRITE setCompositingInitialized NOTIFY configChanged)
-    Q_PROPERTY(int hiddenPreviews READ hiddenPreviews NOTIFY configChanged)
-    Q_PROPERTY(bool unredirectFullscreen READ isUnredirectFullscreen NOTIFY configChanged)
+    Q_PROPERTY(bool hideUtilityWindowsForInactive READ isHideUtilityWindowsForInactive WRITE setHideUtilityWindowsForInactive NOTIFY hideUtilityWindowsForInactiveChanged)
+    Q_PROPERTY(bool inactiveTabsSkipTaskbar READ isInactiveTabsSkipTaskbar WRITE setInactiveTabsSkipTaskbar NOTIFY inactiveTabsSkipTaskbarChanged)
+    Q_PROPERTY(bool autogroupSimilarWindows READ isAutogroupSimilarWindows WRITE setAutogroupSimilarWindows NOTIFY autogroupSimilarWindowsChanged)
+    Q_PROPERTY(bool autogroupInForeground READ isAutogroupInForeground WRITE setAutogroupInForeground NOTIFY autogroupInForegroundChanged)
+    Q_PROPERTY(int compositingMode READ compositingMode WRITE setCompositingMode NOTIFY compositingModeChanged)
+    Q_PROPERTY(bool useCompositing READ isUseCompositing WRITE setUseCompositing NOTIFY useCompositingChanged)
+    Q_PROPERTY(bool compositingInitialized READ isCompositingInitialized WRITE setCompositingInitialized NOTIFY compositingInitializedChanged)
+    Q_PROPERTY(int hiddenPreviews READ hiddenPreviews WRITE setHiddenPreviews NOTIFY hiddenPreviewsChanged)
+    Q_PROPERTY(bool unredirectFullscreen READ isUnredirectFullscreen WRITE setUnredirectFullscreen NOTIFY unredirectFullscreenChanged)
     /**
      * 0 = no, 1 = yes when transformed,
      * 2 = try trilinear when transformed; else 1,
      * -1 = auto
      **/
-    Q_PROPERTY(int glSmoothScale READ glSmoothScale NOTIFY configChanged)
-    Q_PROPERTY(bool glVSync READ isGlVSync NOTIFY configChanged)
-    Q_PROPERTY(bool xrenderSmoothScale READ isXrenderSmoothScale NOTIFY configChanged)
-    Q_PROPERTY(uint maxFpsInterval READ maxFpsInterval NOTIFY configChanged)
-    Q_PROPERTY(uint refreshRate READ refreshRate NOTIFY configChanged)
-    Q_PROPERTY(bool glDirect READ isGlDirect NOTIFY configChanged)
-    Q_PROPERTY(bool glStrictBinding READ isGlStrictBinding NOTIFY configChanged)
+    Q_PROPERTY(int glSmoothScale READ glSmoothScale WRITE setGlSmoothScale NOTIFY glSmoothScaleChanged)
+    Q_PROPERTY(bool glVSync READ isGlVSync WRITE setGlVSync NOTIFY glVSyncChanged)
+    Q_PROPERTY(bool xrenderSmoothScale READ isXrenderSmoothScale WRITE setXrenderSmoothScale NOTIFY xrenderSmoothScaleChanged)
+    Q_PROPERTY(uint maxFpsInterval READ maxFpsInterval WRITE setMaxFpsInterval NOTIFY maxFpsIntervalChanged)
+    Q_PROPERTY(uint refreshRate READ refreshRate WRITE setRefreshRate NOTIFY refreshRateChanged)
+    Q_PROPERTY(bool glDirect READ isGlDirect WRITE setGlDirect NOTIFY glDirectChanged)
+    Q_PROPERTY(bool glStrictBinding READ isGlStrictBinding WRITE setGlStrictBinding NOTIFY glStrictBindingChanged)
 public:
 
     Options(QObject *parent = NULL);
@@ -546,9 +546,6 @@ public:
     bool isCompositingInitialized() const {
         return m_compositingInitialized;
     }
-    void setCompositingInitialized(bool set) {
-        m_compositingInitialized = set;
-    }
 
     // General preferences
     HiddenPreviews hiddenPreviews() const {
@@ -586,11 +583,139 @@ public:
         return m_glStrictBinding;
     }
 
+    // setters
+    void setFocusPolicy(FocusPolicy focusPolicy);
+    void setNextFocusPrefersMouse(bool nextFocusPrefersMouse);
+    void setClickRaise(bool clickRaise);
+    void setAutoRaise(bool autoRaise);
+    void setAutoRaiseInterval(int autoRaiseInterval);
+    void setDelayFocusInterval(int delayFocusInterval);
+    void setShadeHover(bool shadeHover);
+    void setShadeHoverInterval(int shadeHoverInterval);
+    void setTiling(bool tiling);
+    void setTilingLayout(int tilingLayout);
+    void setTilingRaisePolicy(int tilingRaisePolicy);
+    void setSeparateScreenFocus(bool separateScreenFocus);
+    void setActiveMouseScreen(bool activeMouseScreen);
+    void setPlacement(int placement);
+    void setBorderSnapZone(int borderSnapZone);
+    void setWindowSnapZone(int windowSnapZone);
+    void setCenterSnapZone(int centerSnapZone);
+    void setSnapOnlyWhenOverlapping(bool snapOnlyWhenOverlapping);
+    void setShowDesktopIsMinimizeAll(bool showDesktopIsMinimizeAll);
+    void setRollOverDesktops(bool rollOverDesktops);
+    void setFocusStealingPreventionLevel(int focusStealingPreventionLevel);
+    void setLegacyFullscreenSupport(bool legacyFullscreenSupport);
+    void setOperationTitlebarDblClick(WindowOperation operationTitlebarDblClick);
+    void setCommandActiveTitlebar1(MouseCommand commandActiveTitlebar1);
+    void setCommandActiveTitlebar2(MouseCommand commandActiveTitlebar2);
+    void setCommandActiveTitlebar3(MouseCommand commandActiveTitlebar3);
+    void setCommandInactiveTitlebar1(MouseCommand commandInactiveTitlebar1);
+    void setCommandInactiveTitlebar2(MouseCommand commandInactiveTitlebar2);
+    void setCommandInactiveTitlebar3(MouseCommand commandInactiveTitlebar3);
+    void setCommandWindow1(MouseCommand commandWindow1);
+    void setCommandWindow2(MouseCommand commandWindow2);
+    void setCommandWindow3(MouseCommand commandWindow3);
+    void setCommandWindowWheel(MouseCommand commandWindowWheel);
+    void setCommandAll1(MouseCommand commandAll1);
+    void setCommandAll2(MouseCommand commandAll2);
+    void setCommandAll3(MouseCommand commandAll3);
+    void setKeyCmdAllModKey(uint keyCmdAllModKey);
+    void setShowGeometryTip(bool showGeometryTip);
+    void setElectricBorderDelay(int electricBorderDelay);
+    void setElectricBorderCooldown(int electricBorderCooldown);
+    void setElectricBorderPushbackPixels(int electricBorderPushbackPixels);
+    void setElectricBorderMaximize(bool electricBorderMaximize);
+    void setElectricBorderTiling(bool electricBorderTiling);
+    void setBorderlessMaximizedWindows(bool borderlessMaximizedWindows);
+    void setKillPingTimeout(int killPingTimeout);
+    void setHideUtilityWindowsForInactive(bool hideUtilityWindowsForInactive);
+    void setInactiveTabsSkipTaskbar(bool inactiveTabsSkipTaskbar);
+    void setAutogroupSimilarWindows(bool autogroupSimilarWindows);
+    void setAutogroupInForeground(bool autogroupInForeground);
+    void setCompositingMode(int compositingMode);
+    void setUseCompositing(bool useCompositing);
+    void setCompositingInitialized(bool compositingInitialized);
+    void setHiddenPreviews(int hiddenPreviews);
+    void setUnredirectFullscreen(bool unredirectFullscreen);
+    void setGlSmoothScale(int glSmoothScale);
+    void setGlVSync(bool glVSync);
+    void setXrenderSmoothScale(bool xrenderSmoothScale);
+    void setMaxFpsInterval(uint maxFpsInterval);
+    void setRefreshRate(uint refreshRate);
+    void setGlDirect(bool glDirect);
+    void setGlStrictBinding(bool glStrictBinding);
+
     //----------------------
 Q_SIGNALS:
     void configChanged();
 
+    // for properties
+    void focusPolicyChanged();
+    void nextFocusPrefersMouseChanged();
+    void clickRaiseChanged();
+    void autoRaiseChanged();
+    void autoRaiseIntervalChanged();
+    void delayFocusIntervalChanged();
+    void shadeHoverChanged();
+    void shadeHoverIntervalChanged();
+    void tilingChanged();
+    void tilingLayoutChanged();
+    void tilingRaisePolicyChanged();
+    void separateScreenFocusChanged();
+    void activeMouseScreenChanged();
+    void placementChanged();
+    void borderSnapZoneChanged();
+    void windowSnapZoneChanged();
+    void centerSnapZoneChanged();
+    void snapOnlyWhenOverlappingChanged();
+    void showDesktopIsMinimizeAllChanged();
+    void rollOverDesktopsChanged();
+    void focusStealingPreventionLevelChanged();
+    void legacyFullscreenSupportChanged();
+    void operationTitlebarDblClickChanged();
+    void commandActiveTitlebar1Changed();
+    void commandActiveTitlebar2Changed();
+    void commandActiveTitlebar3Changed();
+    void commandInactiveTitlebar1Changed();
+    void commandInactiveTitlebar2Changed();
+    void commandInactiveTitlebar3Changed();
+    void commandWindow1Changed();
+    void commandWindow2Changed();
+    void commandWindow3Changed();
+    void commandWindowWheelChanged();
+    void commandAll1Changed();
+    void commandAll2Changed();
+    void commandAll3Changed();
+    void keyCmdAllModKeyChanged();
+    void showGeometryTipChanged();
+    void electricBordersChanged();
+    void electricBorderDelayChanged();
+    void electricBorderCooldownChanged();
+    void electricBorderPushbackPixelsChanged();
+    void electricBorderMaximizeChanged();
+    void electricBorderTilingChanged();
+    void borderlessMaximizedWindowsChanged();
+    void killPingTimeoutChanged();
+    void hideUtilityWindowsForInactiveChanged();
+    void inactiveTabsSkipTaskbarChanged();
+    void autogroupSimilarWindowsChanged();
+    void autogroupInForegroundChanged();
+    void compositingModeChanged();
+    void useCompositingChanged();
+    void compositingInitializedChanged();
+    void hiddenPreviewsChanged();
+    void unredirectFullscreenChanged();
+    void glSmoothScaleChanged();
+    void glVSyncChanged();
+    void xrenderSmoothScaleChanged();
+    void maxFpsIntervalChanged();
+    void refreshRateChanged();
+    void glDirectChanged();
+    void glStrictBindingChanged();
+
 private:
+    void setElectricBorders(int borders);
     FocusPolicy m_focusPolicy;
     bool m_nextFocusPrefersMouse;
     bool m_clickRaise;