diff --git a/effects/slide/slide.cpp b/effects/slide/slide.cpp
index 579c15bce..adaa71480 100644
--- a/effects/slide/slide.cpp
+++ b/effects/slide/slide.cpp
@@ -1,537 +1,550 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 // Qt
 #include <QEasingCurve>
 
 // KWayland
 #include <KWayland/Server/surface_interface.h>
 #include <KWayland/Server/blur_interface.h>
 #include <KWayland/Server/contrast_interface.h>
 
 #include "slide.h"
 // KConfigSkeleton
 #include "slideconfig.h"
 
 namespace KWin
 {
 
 SlideEffect::SlideEffect()
 {
     initConfig<SlideConfig>();
     reconfigure(ReconfigureAll);
 
     QEasingCurve curve(QEasingCurve::OutCubic);
     m_timeline.setEasingCurve(curve);
 
     connect(effects, static_cast<void (EffectsHandler::*)(int,int,EffectWindow*)>(&EffectsHandler::desktopChanged),
             this, &SlideEffect::desktopChanged);
     connect(effects, &EffectsHandler::windowAdded,
             this, &SlideEffect::windowAdded);
     connect(effects, &EffectsHandler::windowDeleted,
             this, &SlideEffect::windowDeleted);
     connect(effects, &EffectsHandler::numberDesktopsChanged,
             this, &SlideEffect::numberDesktopsChanged);
     connect(effects, &EffectsHandler::numberScreensChanged,
             this, &SlideEffect::numberScreensChanged);
 }
 
 bool SlideEffect::supported()
 {
     return effects->animationsSupported();
 }
 
 void SlideEffect::reconfigure(ReconfigureFlags)
 {
     SlideConfig::self()->read();
 
     const int d = animationTime(
         SlideConfig::duration() > 0 ? SlideConfig::duration() : 500);
     m_timeline.setDuration(d);
 
     m_hGap = SlideConfig::horizontalGap();
     m_vGap = SlideConfig::verticalGap();
     m_slideDocks = SlideConfig::slideDocks();
+    m_slideBackground = SlideConfig::slideBackground();
 }
 
 void SlideEffect::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (m_active) {
         m_timeline.setCurrentTime(m_timeline.currentTime() + time);
         data.mask |= PAINT_SCREEN_TRANSFORMED
                   |  PAINT_SCREEN_BACKGROUND_FIRST;
     }
 
     effects->prePaintScreen(data, time);
 }
 
 /**
  * Wrap vector @p diff around grid @p w x @p h.
  *
  * Wrapping is done in such a way that magnitude of x and y component of vector
  * @p diff is less than half of @p w and half of @p h, respectively. This will
  * result in having the "shortest" path between two points.
  *
  * @param diff Vector between two points
  * @param w Width of the desktop grid
  * @param h Height of the desktop grid
  */
 inline void wrapDiff(QPoint& diff, int w, int h)
 {
     if (diff.x() > w/2) {
         diff.setX(diff.x() - w);
     } else if (diff.x() < -w/2) {
         diff.setX(diff.x() + w);
     }
 
     if (diff.y() > h/2) {
         diff.setY(diff.y() - h);
     } else if (diff.y() < -h/2) {
         diff.setY(diff.y() + h);
     }
 }
 
 inline QRegion buildClipRegion(const QPoint& pos, int w, int h)
 {
     const QSize screenSize = effects->virtualScreenSize();
     QRegion r = QRect(pos, screenSize);
     if (effects->optionRollOverDesktops()) {
         r |= (r & QRect(-w, 0, w, h)).translated(w, 0);  // W
         r |= (r & QRect(w, 0, w, h)).translated(-w, 0);  // E
 
         r |= (r & QRect(0, -h, w, h)).translated(0, h);  // N
         r |= (r & QRect(0, h, w, h)).translated(0, -h);  // S
 
         r |= (r & QRect(-w, -h, w, h)).translated(w, h); // NW
         r |= (r & QRect(w, -h, w, h)).translated(-w, h); // NE
         r |= (r & QRect(w, h, w, h)).translated(-w, -h); // SE
         r |= (r & QRect(-w, h, w, h)).translated(w, -h); // SW
     }
     return r;
 }
 
 void SlideEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
 {
     if (! m_active) {
         effects->paintScreen(mask, region, data);
         return;
     }
 
     const bool wrap = effects->optionRollOverDesktops();
     const int w = workspaceWidth();
     const int h = workspaceHeight();
 
     QPoint currentPos = m_startPos + m_diff * m_timeline.currentValue();
 
     // When "Desktop navigation wraps around" checkbox is checked, currentPos
     // can be outside the rectangle Rect{x:-w, y:-h, width:2*w, height: 2*h},
     // so we map currentPos back to the rect.
     if (wrap) {
         currentPos.setX(currentPos.x() % w);
         currentPos.setY(currentPos.y() % h);
     }
 
     QVector<int> visibleDesktops;
     visibleDesktops.reserve(4); // 4 - maximum number of visible desktops
     const QRegion clipRegion = buildClipRegion(currentPos, w, h);
     for (int i = 1; i <= effects->numberOfDesktops(); i++) {
         const QRect desktopGeo = desktopGeometry(i);
         if (! clipRegion.contains(desktopGeo)) {
             continue;
         }
         visibleDesktops << i;
     }
 
     // When we enter a virtual desktop that has a window in fullscreen mode,
     // stacking order is fine. When we leave a virtual desktop that has
     // a window in fullscreen mode, stacking order is no longer valid
     // because panels are raised above the fullscreen window. Construct
     // a list of fullscreen windows, so we can decide later whether
     // docks should be visible on different virtual desktops.
     if (m_slideDocks) {
         const auto windows = effects->stackingOrder();
         m_paintCtx.fullscreenWindows.clear();
         for (EffectWindow* w : windows) {
             if (! w->isFullScreen()) {
                 continue;
             }
             m_paintCtx.fullscreenWindows << w;
         }
     }
 
     // If screen is painted with either PAINT_SCREEN_TRANSFORMED or
     // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS there is no clipping!!
     // Push the screen geometry to the paint clipper so everything outside
     // of the screen geometry is clipped.
     PaintClipper pc(QRegion(effects->virtualScreenGeometry()));
 
     // Screen is painted in several passes. Each painting pass paints
     // a single virtual desktop. There could be either 2 or 4 painting
     // passes, depending how an user moves between virtual desktops.
     // Windows, such as docks or keep-above windows, are painted in
     // the last pass so they are above other windows.
+    m_paintCtx.firstPass = true;
     const int lastDesktop = visibleDesktops.last();
     for (int desktop : qAsConst(visibleDesktops)) {
         m_paintCtx.desktop = desktop;
         m_paintCtx.lastPass = (lastDesktop == desktop);
         m_paintCtx.translation = desktopCoords(desktop) - currentPos;
         if (wrap) {
             wrapDiff(m_paintCtx.translation, w, h);
         }
         effects->paintScreen(mask, region, data);
+        m_paintCtx.firstPass = false;
     }
 }
 
 /**
  * Decide whether given window @p w should be transformed/translated.
  * @returns @c true if given window @p w should be transformed, otherwise @c false
  */
 bool SlideEffect::isTranslated(const EffectWindow* w) const
 {
     if (w->isOnAllDesktops()) {
         if (w->isDock()) {
             return m_slideDocks;
         }
-        return w->isDesktop();
+        if (w->isDesktop()) {
+            return m_slideBackground;
+        }
+        return false;
     } else if (w == m_movingWindow) {
         return false;
     } else if (w->isOnDesktop(m_paintCtx.desktop)) {
         return true;
     }
     return false;
 }
 
 /**
  * Decide whether given window @p w should be painted.
  * @returns @c true if given window @p w should be painted, otherwise @c false
  */
 bool SlideEffect::isPainted(const EffectWindow* w) const
 {
     if (w->isOnAllDesktops()) {
         if (w->isDock()) {
             if (! m_slideDocks) {
                 return m_paintCtx.lastPass;
             }
             for (const EffectWindow* fw : qAsConst(m_paintCtx.fullscreenWindows)) {
                 if (fw->isOnDesktop(m_paintCtx.desktop)
                     && fw->screen() == w->screen()) {
                     return false;
                 }
             }
             return true;
         }
+        if (w->isDesktop()) {
+            // If desktop background is not being slided, draw it only
+            // in the first pass. Otherwise, desktop backgrounds from
+            // follow-up virtual desktops will be drawn above windows
+            // from previous virtual desktops.
+            return m_slideBackground || m_paintCtx.firstPass;
+        }
         // In order to make sure that 'keep above' windows are above
         // other windows during transition to another virtual desktop,
         // they should be painted in the last pass.
         if (w->keepAbove()) {
             return m_paintCtx.lastPass;
         }
         return true;
     } else if (w == m_movingWindow) {
         return m_paintCtx.lastPass;
     } else if (w->isOnDesktop(m_paintCtx.desktop)) {
         return true;
     }
     return false;
 }
 
 void SlideEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     if (m_active) {
         const bool painted = isPainted(w);
         if (painted) {
             w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
         } else {
             w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
         }
         if (painted && isTranslated(w)) {
             data.setTransformed();
         }
     }
     effects->prePaintWindow(w, data, time);
 }
 
 void SlideEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (m_active && isTranslated(w)) {
         data += m_paintCtx.translation;
     }
     effects->paintWindow(w, mask, region, data);
 }
 
 void SlideEffect::postPaintScreen()
 {
     if (m_active) {
         if (m_timeline.currentValue() == 1) {
             stop();
         }
         effects->addRepaintFull();
     }
     effects->postPaintScreen();
 }
 
 /**
  * Get position of the top-left corner of desktop @p id within desktop grid with gaps.
  * @param id ID of a virtual desktop
  */
 QPoint SlideEffect::desktopCoords(int id) const
 {
     QPoint c = effects->desktopCoords(id);
     const QPoint gridPos = effects->desktopGridCoords(id);
     c.setX(c.x() + m_hGap * gridPos.x());
     c.setY(c.y() + m_vGap * gridPos.y());
     return c;
 }
 
 /**
  * Get geometry of desktop @p id within desktop grid with gaps.
  * @param id ID of a virtual desktop
  */
 QRect SlideEffect::desktopGeometry(int id) const
 {
     QRect g = effects->virtualScreenGeometry();
     g.translate(desktopCoords(id));
     return g;
 }
 
 /**
  * Get width of a virtual desktop grid.
  */
 int SlideEffect::workspaceWidth() const
 {
     int w = effects->workspaceWidth();
     w += m_hGap * effects->desktopGridWidth();
     return w;
 }
 
 /**
  * Get height of a virtual desktop grid.
  */
 int SlideEffect::workspaceHeight() const
 {
     int h = effects->workspaceHeight();
     h += m_vGap * effects->desktopGridHeight();
     return h;
 }
 
 bool SlideEffect::shouldForceBlur(const EffectWindow* w) const
 {
     // While there is an active fullscreen effect, the blur effect
     // tends to do nothing, i.e. it doesn't blur behind windows.
     // So, we should force the blur effect to blur by setting
     // WindowForceBlurRole.
 
     if (w->data(WindowForceBlurRole).toBool()) {
         return false;
     }
 
     if (w->data(WindowBlurBehindRole).isValid()) {
         return true;
     }
 
     if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
         return true;
     }
 
     // FIXME: it should be something like this:
     //        if (surf) {
     //            return !surf->blur().isNull();
     //        }
     const KWayland::Server::SurfaceInterface* surf = w->surface();
     if (surf && surf->blur()) {
         return true;
     }
 
     // TODO: make it X11-specific(check _KDE_NET_WM_BLUR_BEHIND_REGION)
     //       or delete it in the future
     return w->hasAlpha();
 }
 
 bool SlideEffect::shouldForceBackgroundContrast(const EffectWindow* w) const
 {
     // While there is an active fullscreen effect, the background
     // contrast effect tends to do nothing, i.e. it doesn't change
     // contrast. So, we should force the background contrast effect
     // to change contrast by setting WindowForceBackgroundContrastRole.
 
     if (w->data(WindowForceBackgroundContrastRole).toBool()) {
         return false;
     }
 
     if (w->data(WindowBackgroundContrastRole).isValid()) {
         return true;
     }
 
     // FIXME: it should be something like this:
     //        if (surf) {
     //            return !surf->contrast().isNull();
     //        }
     const KWayland::Server::SurfaceInterface* surf = w->surface();
     if (surf && surf->contrast()) {
         return true;
     }
 
     // TODO: make it X11-specific(check _KDE_NET_WM_BACKGROUND_CONTRAST_REGION)
     //       or delete it in the future
     return w->hasAlpha()
         && w->isOnAllDesktops()
         && (w->isDock() || w->keepAbove());
 }
 
 bool SlideEffect::shouldElevate(const EffectWindow* w) const
 {
     // Static docks(i.e. this effect doesn't slide docks) should be elevated
     // so they can properly animate themselves when an user enters or leaves
     // a virtual desktop with a window in fullscreen mode.
     return w->isDock() && !m_slideDocks;
 }
 
 void SlideEffect::start(int old, int current, EffectWindow* movingWindow)
 {
     m_movingWindow = movingWindow;
 
     const bool wrap = effects->optionRollOverDesktops();
     const int w = workspaceWidth();
     const int h = workspaceHeight();
 
     if (m_active) {
         QPoint passed = m_diff * m_timeline.currentValue();
         QPoint currentPos = m_startPos + passed;
         QPoint delta = desktopCoords(current) - desktopCoords(old);
         if (wrap) {
             wrapDiff(delta, w, h);
         }
         m_diff += delta - passed;
         m_startPos = currentPos;
         m_timeline.setCurrentTime(0);
         return;
     }
 
     const auto windows = effects->stackingOrder();
     for (EffectWindow* w : windows) {
         if (shouldForceBlur(w)) {
             w->setData(WindowForceBlurRole, QVariant(true));
             m_forcedRoles.blur << w;
         }
         if (shouldForceBackgroundContrast(w)) {
             w->setData(WindowForceBackgroundContrastRole, QVariant(true));
             m_forcedRoles.backgroundContrast << w;
         }
         if (shouldElevate(w)) {
             effects->setElevatedWindow(w, true);
             m_elevatedWindows << w;
         }
     }
 
     m_diff = desktopCoords(current) - desktopCoords(old);
     if (wrap) {
         wrapDiff(m_diff, w, h);
     }
     m_startPos = desktopCoords(old);
     m_timeline.setCurrentTime(0);
     m_active = true;
     effects->setActiveFullScreenEffect(this);
     effects->addRepaintFull();
 }
 
 void SlideEffect::stop()
 {
     for (EffectWindow* w : m_forcedRoles.blur) {
         w->setData(WindowForceBlurRole, QVariant());
     }
     m_forcedRoles.blur.clear();
 
     for (EffectWindow* w : m_forcedRoles.backgroundContrast) {
         w->setData(WindowForceBackgroundContrastRole, QVariant());
     }
     m_forcedRoles.backgroundContrast.clear();
 
     for (EffectWindow* w : m_elevatedWindows) {
         effects->setElevatedWindow(w, false);
     }
     m_elevatedWindows.clear();
 
     m_paintCtx.fullscreenWindows.clear();
     m_timeline.setCurrentTime(0);
     m_movingWindow = nullptr;
     m_active = false;
     effects->setActiveFullScreenEffect(nullptr);
 }
 
 void SlideEffect::desktopChanged(int old, int current, EffectWindow* with)
 {
     if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this) {
         return;
     }
     start(old, current, with);
 }
 
 void SlideEffect::windowAdded(EffectWindow *w)
 {
     if (! m_active) {
         return;
     }
     if (shouldForceBlur(w)) {
         w->setData(WindowForceBlurRole, QVariant(true));
         m_forcedRoles.blur << w;
     }
     if (shouldForceBackgroundContrast(w)) {
         w->setData(WindowForceBackgroundContrastRole, QVariant(true));
         m_forcedRoles.backgroundContrast << w;
     }
     if (shouldElevate(w)) {
         effects->setElevatedWindow(w, true);
         m_elevatedWindows << w;
     }
 }
 
 void SlideEffect::windowDeleted(EffectWindow *w)
 {
     if (! m_active) {
         return;
     }
     if (w == m_movingWindow) {
         m_movingWindow = nullptr;
     }
     m_forcedRoles.blur.removeAll(w);
     m_forcedRoles.backgroundContrast.removeAll(w);
     m_elevatedWindows.removeAll(w);
     m_paintCtx.fullscreenWindows.removeAll(w);
 }
 
 void SlideEffect::numberDesktopsChanged(uint)
 {
     if (! m_active) {
         return;
     }
     stop();
 }
 
 void SlideEffect::numberScreensChanged()
 {
     if (! m_active) {
         return;
     }
     stop();
 }
 
 } // namespace
diff --git a/effects/slide/slide.h b/effects/slide/slide.h
index 3df02b22b..02e46527a 100644
--- a/effects/slide/slide.h
+++ b/effects/slide/slide.h
@@ -1,114 +1,116 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SLIDE_H
 #define KWIN_SLIDE_H
 
 // KDE
 #include <kwineffects.h>
 
 // Qt
 #include <QObject>
 #include <QTimeLine>
 
 namespace KWin
 {
 
 class SlideEffect : public Effect
 {
     Q_OBJECT
 public:
     SlideEffect();
 
     void reconfigure(ReconfigureFlags) override;
 
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, QRegion region, ScreenPaintData& data) override;
     void postPaintScreen() override;
 
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) override;
 
     bool isActive() const override {
         return m_active;
     }
 
     int requestedEffectChainPosition() const override {
         return 50;
     }
 
     static bool supported();
 
 private Q_SLOTS:
     void desktopChanged(int old, int current, EffectWindow* with);
     void windowAdded(EffectWindow* w);
     void windowDeleted(EffectWindow* w);
 
     void numberDesktopsChanged(uint old);
     void numberScreensChanged();
 
 private:
     QPoint desktopCoords(int id) const;
     QRect desktopGeometry(int id) const;
     int workspaceWidth() const;
     int workspaceHeight() const;
 
     bool isTranslated(const EffectWindow* w) const;
     bool isPainted(const EffectWindow* w) const;
 
     bool shouldForceBlur(const EffectWindow* w) const;
     bool shouldForceBackgroundContrast(const EffectWindow* w) const;
     bool shouldElevate(const EffectWindow* w) const;
 
     void start(int old, int current, EffectWindow* movingWindow = nullptr);
     void stop();
 
 private:
     int m_hGap;
     int m_vGap;
     bool m_slideDocks;
+    bool m_slideBackground;
 
     bool m_active = false;
     QTimeLine m_timeline;
     QPoint m_startPos;
     QPoint m_diff;
     EffectWindow* m_movingWindow = nullptr;
 
     struct {
         int desktop;
+        bool firstPass;
         bool lastPass;
         QPoint translation;
 
         EffectWindowList fullscreenWindows;
     } m_paintCtx;
 
     struct {
         QList<EffectWindow*> blur;
         QList<EffectWindow*> backgroundContrast;
     } m_forcedRoles;
 
     QList<EffectWindow*> m_elevatedWindows;
 };
 
 } // namespace
 
 #endif
diff --git a/effects/slide/slide.kcfg b/effects/slide/slide.kcfg
index be278a8b4..5bf3a16b8 100644
--- a/effects/slide/slide.kcfg
+++ b/effects/slide/slide.kcfg
@@ -1,22 +1,25 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
     http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
     <kcfgfile arg="true"/>
     <group name="Effect-Slide">
         <entry name="Duration" type="UInt">
             <default>0</default>
         </entry>
         <entry name="HorizontalGap" type="UInt">
             <default>45</default>
         </entry>
         <entry name="VerticalGap" type="UInt">
             <default>20</default>
         </entry>
         <entry name="SlideDocks" type="Bool">
             <default>true</default>
         </entry>
+        <entry name="SlideBackground" type="Bool">
+            <default>true</default>
+        </entry>
     </group>
 </kcfg>
diff --git a/effects/slide/slide_config.ui b/effects/slide/slide_config.ui
index 336600998..4c9cb31ed 100644
--- a/effects/slide/slide_config.ui
+++ b/effects/slide/slide_config.ui
@@ -1,126 +1,133 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>SlideEffectConfig</class>
  <widget class="QWidget" name="SlideEffectConfig">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>250</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <layout class="QFormLayout" name="layout_Duration">
      <item row="0" column="0">
       <widget class="QLabel" name="label_Duration">
        <property name="text">
         <string>Duration:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QSpinBox" name="kcfg_Duration">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="specialValueText">
         <string extracomment="Duration of the slide animation.">Default</string>
        </property>
        <property name="suffix">
         <string> milliseconds</string>
        </property>
        <property name="maximum">
         <number>9999</number>
        </property>
        <property name="singleStep">
         <number>10</number>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_Gaps">
      <property name="title">
       <string>Gap between desktops</string>
      </property>
      <layout class="QFormLayout" name="formLayout_2">
       <item row="0" column="0">
        <widget class="QLabel" name="label_HorizontalGap">
         <property name="text">
          <string>Horizontal:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QSpinBox" name="kcfg_HorizontalGap">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximum">
          <number>1000</number>
         </property>
         <property name="singleStep">
          <number>5</number>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_VerticalGap">
         <property name="text">
          <string>Vertical:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QSpinBox" name="kcfg_VerticalGap">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximum">
          <number>1000</number>
         </property>
         <property name="singleStep">
          <number>5</number>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="kcfg_SlideDocks">
      <property name="text">
       <string>Slide docks</string>
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QCheckBox" name="kcfg_SlideBackground">
+     <property name="text">
+      <string>Slide desktop background</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>