diff --git a/autotests/tabbox/mock_tabboxhandler.h b/autotests/tabbox/mock_tabboxhandler.h
index 841f189d4..38a209d62 100644
--- a/autotests/tabbox/mock_tabboxhandler.h
+++ b/autotests/tabbox/mock_tabboxhandler.h
@@ -1,113 +1,110 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 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_MOCK_TABBOX_HANDLER_H
 #define KWIN_MOCK_TABBOX_HANDLER_H
 
 #include "../../tabbox/tabboxhandler.h"
 namespace KWin
 {
 class MockTabBoxHandler : public TabBox::TabBoxHandler
 {
     Q_OBJECT
 public:
     MockTabBoxHandler(QObject *parent = nullptr);
     ~MockTabBoxHandler() override;
     void activateAndClose() override {
     }
     QWeakPointer< TabBox::TabBoxClient > activeClient() const override;
     void setActiveClient(const QWeakPointer<TabBox::TabBoxClient> &client);
     int activeScreen() const override {
         return 0;
     }
     QWeakPointer< TabBox::TabBoxClient > clientToAddToList(TabBox::TabBoxClient *client, int desktop) const override;
     int currentDesktop() const override {
         return 1;
     }
     QWeakPointer< TabBox::TabBoxClient > desktopClient() const override {
         return QWeakPointer<TabBox::TabBoxClient>();
     }
     QString desktopName(int desktop) const override {
         Q_UNUSED(desktop)
         return "desktop 1";
     }
     QString desktopName(TabBox::TabBoxClient *client) const override {
         Q_UNUSED(client)
         return "desktop";
     }
     void elevateClient(TabBox::TabBoxClient *c, QWindow *tabbox, bool elevate) const override {
         Q_UNUSED(c)
         Q_UNUSED(tabbox)
         Q_UNUSED(elevate)
     }
     void shadeClient(TabBox::TabBoxClient *c, bool b) const override {
         Q_UNUSED(c)
         Q_UNUSED(b)
     }
     virtual void hideOutline() {
     }
     QWeakPointer< TabBox::TabBoxClient > nextClientFocusChain(TabBox::TabBoxClient *client) const override;
     QWeakPointer<TabBox::TabBoxClient> firstClientFocusChain() const override;
     bool isInFocusChain (TabBox::TabBoxClient* client) const override;
     int nextDesktopFocusChain(int desktop) const override {
         Q_UNUSED(desktop)
         return 1;
     }
     int numberOfDesktops() const override {
         return 1;
     }
-    virtual QVector< xcb_window_t > outlineWindowIds() const {
-        return QVector<xcb_window_t>();
-    }
     bool isKWinCompositing() const override {
         return false;
     }
     void raiseClient(TabBox::TabBoxClient *c) const override {
         Q_UNUSED(c)
     }
     void restack(TabBox::TabBoxClient *c, TabBox::TabBoxClient *under) override {
         Q_UNUSED(c)
         Q_UNUSED(under)
     }
     virtual void showOutline(const QRect &outline) {
         Q_UNUSED(outline)
     }
     TabBox::TabBoxClientList stackingOrder() const override {
         return TabBox::TabBoxClientList();
     }
     void grabbedKeyEvent(QKeyEvent *event) const override;
 
     void highlightWindows(TabBox::TabBoxClient *window = nullptr, QWindow *controller = nullptr) override {
         Q_UNUSED(window)
         Q_UNUSED(controller)
     }
 
     bool noModifierGrab() const override {
         return false;
     }
 
     // mock methods
     QWeakPointer<TabBox::TabBoxClient> createMockWindow(const QString &caption, WId id);
     void closeWindow(TabBox::TabBoxClient *client);
 private:
     QList< QSharedPointer<TabBox::TabBoxClient> > m_windows;
     QWeakPointer<TabBox::TabBoxClient> m_activeClient;
 };
 } // namespace KWin
 #endif
diff --git a/tabbox/tabboxhandler.cpp b/tabbox/tabboxhandler.cpp
index 9b251ecdc..0485e31d1 100644
--- a/tabbox/tabboxhandler.cpp
+++ b/tabbox/tabboxhandler.cpp
@@ -1,656 +1,655 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 
 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/>.
 *********************************************************************/
 
 // own
 #include "tabboxhandler.h"
 #include <config-kwin.h>
 #include <kwinglobals.h>
 #include "xcbutils.h"
 // tabbox
 #include "clientmodel.h"
 #include "desktopmodel.h"
 #include "tabboxconfig.h"
 #include "thumbnailitem.h"
 #include "scripting/scripting.h"
 #include "switcheritem.h"
 #include "tabbox_logging.h"
 // Qt
 #include <QKeyEvent>
 #include <QModelIndex>
 #include <QStandardPaths>
 #include <QTimer>
 #include <QQmlContext>
 #include <QQmlComponent>
 #include <QQmlEngine>
 #include <QQuickItem>
 #include <QQuickWindow>
-#include <X11/Xlib.h>
 #include <qpa/qwindowsysteminterface.h>
 // KDE
 #include <KLocalizedString>
 #include <KProcess>
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 
 namespace KWin
 {
 namespace TabBox
 {
 
 class TabBoxHandlerPrivate
 {
 public:
     TabBoxHandlerPrivate(TabBoxHandler *q);
 
     ~TabBoxHandlerPrivate();
 
     /**
      * Updates the current highlight window state
      */
     void updateHighlightWindows();
     /**
      * Ends window highlighting
      */
     void endHighlightWindows(bool abort = false);
 
     void show();
     QQuickWindow *window() const;
     SwitcherItem *switcherItem() const;
 
     ClientModel* clientModel() const;
     DesktopModel* desktopModel() const;
 
     TabBoxHandler *q; // public pointer
     // members
     TabBoxConfig config;
     QScopedPointer<QQmlContext> m_qmlContext;
     QScopedPointer<QQmlComponent> m_qmlComponent;
     QObject *m_mainItem;
     QMap<QString, QObject*> m_clientTabBoxes;
     QMap<QString, QObject*> m_desktopTabBoxes;
     ClientModel* m_clientModel;
     DesktopModel* m_desktopModel;
     QModelIndex index;
     /**
      * Indicates if the tabbox is shown.
      */
     bool isShown;
     TabBoxClient *lastRaisedClient, *lastRaisedClientSucc;
     int wheelAngleDelta = 0;
 
 private:
     QObject *createSwitcherItem(bool desktopMode);
 };
 
 TabBoxHandlerPrivate::TabBoxHandlerPrivate(TabBoxHandler *q)
     : m_qmlContext()
     , m_qmlComponent()
     , m_mainItem(nullptr)
 {
     this->q = q;
     isShown = false;
     lastRaisedClient = nullptr;
     lastRaisedClientSucc = nullptr;
     config = TabBoxConfig();
     m_clientModel = new ClientModel(q);
     m_desktopModel = new DesktopModel(q);
 }
 
 TabBoxHandlerPrivate::~TabBoxHandlerPrivate()
 {
     for (auto it = m_clientTabBoxes.constBegin(); it != m_clientTabBoxes.constEnd(); ++it) {
         delete it.value();
     }
     for (auto it = m_desktopTabBoxes.constBegin(); it != m_desktopTabBoxes.constEnd(); ++it) {
         delete it.value();
     }
 }
 
 QQuickWindow *TabBoxHandlerPrivate::window() const
 {
     if (!m_mainItem) {
         return nullptr;
     }
     if (QQuickWindow *w = qobject_cast<QQuickWindow*>(m_mainItem)) {
         return w;
     }
     return m_mainItem->findChild<QQuickWindow*>();
 }
 
 #ifndef KWIN_UNIT_TEST
 SwitcherItem *TabBoxHandlerPrivate::switcherItem() const
 {
     if (!m_mainItem) {
         return nullptr;
     }
     if (SwitcherItem *i = qobject_cast<SwitcherItem*>(m_mainItem)) {
         return i;
     } else if (QQuickWindow *w = qobject_cast<QQuickWindow*>(m_mainItem)) {
         return w->contentItem()->findChild<SwitcherItem*>();
     }
     return m_mainItem->findChild<SwitcherItem*>();
 }
 #endif
 
 ClientModel* TabBoxHandlerPrivate::clientModel() const
 {
     return m_clientModel;
 }
 
 DesktopModel* TabBoxHandlerPrivate::desktopModel() const
 {
     return m_desktopModel;
 }
 
 void TabBoxHandlerPrivate::updateHighlightWindows()
 {
     if (!isShown || config.tabBoxMode() != TabBoxConfig::ClientTabBox)
         return;
 
     TabBoxClient *currentClient = q->client(index);
     QWindow *w = window();
 
     if (q->isKWinCompositing()) {
         if (lastRaisedClient)
             q->elevateClient(lastRaisedClient, w, false);
         lastRaisedClient = currentClient;
         if (currentClient)
             q->elevateClient(currentClient, w, true);
     } else {
         if (lastRaisedClient) {
             q->shadeClient(lastRaisedClient, true);
             if (lastRaisedClientSucc)
                 q->restack(lastRaisedClient, lastRaisedClientSucc);
             // TODO lastRaisedClient->setMinimized( lastRaisedClientWasMinimized );
         }
 
         lastRaisedClient = currentClient;
         if (lastRaisedClient) {
             q->shadeClient(lastRaisedClient, false);
             // TODO if ( (lastRaisedClientWasMinimized = lastRaisedClient->isMinimized()) )
             //         lastRaisedClient->setMinimized( false );
             TabBoxClientList order = q->stackingOrder();
             int succIdx = order.count() + 1;
             for (int i=0; i<order.count(); ++i) {
                 if (order.at(i).data() == lastRaisedClient) {
                     succIdx = i + 1;
                     break;
                 }
             }
             lastRaisedClientSucc = (succIdx < order.count()) ? order.at(succIdx).data() : nullptr;
             q->raiseClient(lastRaisedClient);
         }
     }
 
     if (config.isShowTabBox() && w) {
         q->highlightWindows(currentClient, w);
     } else {
         q->highlightWindows(currentClient);
     }
 }
 
 void TabBoxHandlerPrivate::endHighlightWindows(bool abort)
 {
     TabBoxClient *currentClient = q->client(index);
     if (config.isHighlightWindows() && q->isKWinCompositing()) {
         foreach (const QWeakPointer<TabBoxClient> &clientPointer, q->stackingOrder()) {
             if (QSharedPointer<TabBoxClient> client = clientPointer.toStrongRef())
             if (client != currentClient) // to not mess up with wanted ShadeActive/ShadeHover state
                 q->shadeClient(client.data(), true);
         }
     }
     QWindow *w = window();
     if (currentClient)
         q->elevateClient(currentClient, w, false);
     if (abort && lastRaisedClient && lastRaisedClientSucc)
         q->restack(lastRaisedClient, lastRaisedClientSucc);
     lastRaisedClient = nullptr;
     lastRaisedClientSucc = nullptr;
     // highlight windows
     q->highlightWindows();
 }
 
 #ifndef KWIN_UNIT_TEST
 QObject *TabBoxHandlerPrivate::createSwitcherItem(bool desktopMode)
 {
     // first try look'n'feel package
     QString file = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                           QStringLiteral("plasma/look-and-feel/%1/contents/%2")
                                               .arg(config.layoutName())
                                               .arg(desktopMode ? QStringLiteral("desktopswitcher/DesktopSwitcher.qml") : QStringLiteral("windowswitcher/WindowSwitcher.qml")));
     if (file.isNull()) {
         const QString folderName = QLatin1String(KWIN_NAME) + (desktopMode ? QLatin1String("/desktoptabbox/") : QLatin1String("/tabbox/"));
         auto findSwitcher = [this, desktopMode, folderName] {
             const QString type = desktopMode ? QStringLiteral("KWin/DesktopSwitcher") : QStringLiteral("KWin/WindowSwitcher");
             auto offers = KPackage::PackageLoader::self()->findPackages(type,  folderName,
                 [this] (const KPluginMetaData &data) {
                     return data.pluginId().compare(config.layoutName(), Qt::CaseInsensitive) == 0;
                 }
             );
             if (offers.isEmpty()) {
                 // load default
                 offers = KPackage::PackageLoader::self()->findPackages(type,  folderName,
                     [] (const KPluginMetaData &data) {
                         return data.pluginId().compare(QStringLiteral("informative"), Qt::CaseInsensitive) == 0;
                     }
                 );
                 if (offers.isEmpty()) {
                     qCDebug(KWIN_TABBOX) << "could not find default window switcher layout";
                     return KPluginMetaData();
                 }
             }
             return offers.first();
         };
         auto service = findSwitcher();
         if (!service.isValid()) {
             return nullptr;
         }
         if (service.value(QStringLiteral("X-Plasma-API")) != QLatin1String("declarativeappletscript")) {
             qCDebug(KWIN_TABBOX) << "Window Switcher Layout is no declarativeappletscript";
             return nullptr;
         }
         auto findScriptFile = [service, folderName] {
             const QString pluginName = service.pluginId();
             const QString scriptName = service.value(QStringLiteral("X-Plasma-MainScript"));
             return QStandardPaths::locate(QStandardPaths::GenericDataLocation, folderName + pluginName + QLatin1String("/contents/") + scriptName);
         };
         file = findScriptFile();
     }
     if (file.isNull()) {
         qCDebug(KWIN_TABBOX) << "Could not find QML file for window switcher";
         return nullptr;
     }
     m_qmlComponent->loadUrl(QUrl::fromLocalFile(file));
     if (m_qmlComponent->isError()) {
         qCDebug(KWIN_TABBOX) << "Component failed to load: " << m_qmlComponent->errors();
         QStringList args;
         args << QStringLiteral("--passivepopup") << i18n("The Window Switcher installation is broken, resources are missing.\n"
                                             "Contact your distribution about this.") << QStringLiteral("20");
         KProcess::startDetached(QStringLiteral("kdialog"), args);
     } else {
         QObject *object = m_qmlComponent->create(m_qmlContext.data());
         if (desktopMode) {
             m_desktopTabBoxes.insert(config.layoutName(), object);
         } else {
             m_clientTabBoxes.insert(config.layoutName(), object);
         }
         return object;
     }
     return nullptr;
 }
 #endif
 
 void TabBoxHandlerPrivate::show()
 {
 #ifndef KWIN_UNIT_TEST
     if (m_qmlContext.isNull()) {
         qmlRegisterType<SwitcherItem>("org.kde.kwin", 2, 0, "Switcher");
         m_qmlContext.reset(new QQmlContext(Scripting::self()->qmlEngine()));
     }
     if (m_qmlComponent.isNull()) {
         m_qmlComponent.reset(new QQmlComponent(Scripting::self()->qmlEngine()));
     }
     const bool desktopMode = (config.tabBoxMode() == TabBoxConfig::DesktopTabBox);
     auto findMainItem = [this](const QMap<QString, QObject *> &tabBoxes) -> QObject* {
         auto it = tabBoxes.constFind(config.layoutName());
         if (it != tabBoxes.constEnd()) {
             return it.value();
         }
         return nullptr;
     };
     m_mainItem = nullptr;
     m_mainItem = desktopMode ? findMainItem(m_desktopTabBoxes) : findMainItem(m_clientTabBoxes);
     if (!m_mainItem) {
         m_mainItem = createSwitcherItem(desktopMode);
         if (!m_mainItem) {
             return;
         }
     }
     if (SwitcherItem *item = switcherItem()) {
         // In case the model isn't yet set (see below), index will be reset and therefore we
         // need to save the current index row (https://bugs.kde.org/show_bug.cgi?id=333511).
         int indexRow = index.row();
         if (!item->model()) {
             QAbstractItemModel *model = nullptr;
             if (desktopMode) {
                 model = desktopModel();
             } else {
                 model = clientModel();
             }
             item->setModel(model);
         }
         item->setAllDesktops(config.clientDesktopMode() == TabBoxConfig::AllDesktopsClients);
         item->setCurrentIndex(indexRow);
         item->setNoModifierGrab(q->noModifierGrab());
         // everything is prepared, so let's make the whole thing visible
         item->setVisible(true);
     }
     if (QWindow *w = window()) {
         wheelAngleDelta = 0;
         w->installEventFilter(q);
         // pretend to activate the window to enable accessibility notifications
         QWindowSystemInterface::handleWindowActivated(w, Qt::TabFocusReason);
     }
 #endif
 }
 
 /***********************************************
 * TabBoxHandler
 ***********************************************/
 
 TabBoxHandler::TabBoxHandler(QObject *parent)
     : QObject(parent)
 {
     KWin::TabBox::tabBox = this;
     d = new TabBoxHandlerPrivate(this);
 }
 
 TabBoxHandler::~TabBoxHandler()
 {
     delete d;
 }
 
 const KWin::TabBox::TabBoxConfig& TabBoxHandler::config() const
 {
     return d->config;
 }
 
 void TabBoxHandler::setConfig(const TabBoxConfig& config)
 {
     d->config = config;
     emit configChanged();
 }
 
 void TabBoxHandler::show()
 {
     d->isShown = true;
     d->lastRaisedClient = nullptr;
     d->lastRaisedClientSucc = nullptr;
     if (d->config.isShowTabBox()) {
         d->show();
     }
     if (d->config.isHighlightWindows()) {
         if (kwinApp()->x11Connection()) {
             Xcb::sync();
         }
         // TODO this should be
         // QMetaObject::invokeMethod(this, "initHighlightWindows", Qt::QueuedConnection);
         // but we somehow need to cross > 1 event cycle (likely because of queued invocation in the effects)
         // to ensure the EffectWindow is present when updateHighlightWindows, thus elevating the window/tabbox
         QTimer::singleShot(1, this, SLOT(initHighlightWindows()));
     }
 }
 
 void TabBoxHandler::initHighlightWindows()
 {
     if (isKWinCompositing()) {
         foreach (const QWeakPointer<TabBoxClient> &clientPointer, stackingOrder()) {
         if (QSharedPointer<TabBoxClient> client = clientPointer.toStrongRef())
             shadeClient(client.data(), false);
         }
     }
     d->updateHighlightWindows();
 }
 
 void TabBoxHandler::hide(bool abort)
 {
     d->isShown = false;
     if (d->config.isHighlightWindows()) {
         d->endHighlightWindows(abort);
     }
 #ifndef KWIN_UNIT_TEST
     if (SwitcherItem *item = d->switcherItem()) {
         item->setVisible(false);
     }
 #endif
     if (QQuickWindow *w = d->window()) {
         w->hide();
         w->destroy();
     }
     d->m_mainItem = nullptr;
 }
 
 QModelIndex TabBoxHandler::nextPrev(bool forward) const
 {
     QModelIndex ret;
     QAbstractItemModel* model;
     switch(d->config.tabBoxMode()) {
     case TabBoxConfig::ClientTabBox:
         model = d->clientModel();
         break;
     case TabBoxConfig::DesktopTabBox:
         model = d->desktopModel();
         break;
     default:
         Q_UNREACHABLE();
     }
     if (forward) {
         int column = d->index.column() + 1;
         int row = d->index.row();
         if (column == model->columnCount()) {
             column = 0;
             row++;
             if (row == model->rowCount())
                 row = 0;
         }
         ret = model->index(row, column);
         if (!ret.isValid())
             ret = model->index(0, 0);
     } else {
         int column = d->index.column() - 1;
         int row = d->index.row();
         if (column < 0) {
             column = model->columnCount() - 1;
             row--;
             if (row < 0)
                 row = model->rowCount() - 1;
         }
         ret = model->index(row, column);
         if (!ret.isValid()) {
             row = model->rowCount() - 1;
             for (int i = model->columnCount() - 1; i >= 0; i--) {
                 ret = model->index(row, i);
                 if (ret.isValid())
                     break;
             }
         }
     }
     if (ret.isValid())
         return ret;
     else
         return d->index;
 }
 
 QModelIndex TabBoxHandler::desktopIndex(int desktop) const
 {
     if (d->config.tabBoxMode() != TabBoxConfig::DesktopTabBox)
         return QModelIndex();
     return d->desktopModel()->desktopIndex(desktop);
 }
 
 QList< int > TabBoxHandler::desktopList() const
 {
     if (d->config.tabBoxMode() != TabBoxConfig::DesktopTabBox)
         return QList< int >();
     return d->desktopModel()->desktopList();
 }
 
 int TabBoxHandler::desktop(const QModelIndex& index) const
 {
     if (!index.isValid() || (d->config.tabBoxMode() != TabBoxConfig::DesktopTabBox))
         return -1;
     QVariant ret = d->desktopModel()->data(index, DesktopModel::DesktopRole);
     if (ret.isValid())
         return ret.toInt();
     else
         return -1;
 }
 
 void TabBoxHandler::setCurrentIndex(const QModelIndex& index)
 {
     if (d->index == index) {
         return;
     }
     if (!index.isValid()) {
         return;
     }
     d->index = index;
     if (d->config.tabBoxMode() == TabBoxConfig::ClientTabBox) {
         if (d->config.isHighlightWindows()) {
             d->updateHighlightWindows();
         }
     }
     emit selectedIndexChanged();
 }
 
 const QModelIndex& TabBoxHandler::currentIndex() const
 {
     return d->index;
 }
 
 void TabBoxHandler::grabbedKeyEvent(QKeyEvent* event) const
 {
     if (!d->m_mainItem || !d->window()) {
         return;
     }
     QCoreApplication::sendEvent(d->window(), event);
 }
 
 bool TabBoxHandler::containsPos(const QPoint& pos) const
 {
     if (!d->m_mainItem) {
         return false;
     }
     QWindow *w = d->window();
     if (w) {
         return w->geometry().contains(pos);
     }
     return false;
 }
 
 QModelIndex TabBoxHandler::index(QWeakPointer<KWin::TabBox::TabBoxClient> client) const
 {
     return d->clientModel()->index(client);
 }
 
 TabBoxClientList TabBoxHandler::clientList() const
 {
     if (d->config.tabBoxMode() != TabBoxConfig::ClientTabBox)
         return TabBoxClientList();
     return d->clientModel()->clientList();
 }
 
 TabBoxClient* TabBoxHandler::client(const QModelIndex& index) const
 {
     if ((!index.isValid()) ||
             (d->config.tabBoxMode() != TabBoxConfig::ClientTabBox))
         return nullptr;
     TabBoxClient* c = static_cast< TabBoxClient* >(
                           d->clientModel()->data(index, ClientModel::ClientRole).value<void *>());
     return c;
 }
 
 void TabBoxHandler::createModel(bool partialReset)
 {
     switch(d->config.tabBoxMode()) {
     case TabBoxConfig::ClientTabBox: {
         d->clientModel()->createClientList(partialReset);
         // TODO: C++11 use lambda function
         bool lastRaised = false;
         bool lastRaisedSucc = false;
         foreach (const QWeakPointer<TabBoxClient> &clientPointer, stackingOrder()) {
             QSharedPointer<TabBoxClient> client = clientPointer.toStrongRef();
             if (!client) {
                 continue;
             }
             if (client.data() == d->lastRaisedClient) {
                 lastRaised = true;
             }
             if (client.data() == d->lastRaisedClientSucc) {
                 lastRaisedSucc = true;
             }
         }
         if (d->lastRaisedClient && !lastRaised)
             d->lastRaisedClient = nullptr;
         if (d->lastRaisedClientSucc && !lastRaisedSucc)
             d->lastRaisedClientSucc = nullptr;
         break;
     }
     case TabBoxConfig::DesktopTabBox:
         d->desktopModel()->createDesktopList();
         break;
     }
 }
 
 QModelIndex TabBoxHandler::first() const
 {
     QAbstractItemModel* model;
     switch(d->config.tabBoxMode()) {
     case TabBoxConfig::ClientTabBox:
         model = d->clientModel();
         break;
     case TabBoxConfig::DesktopTabBox:
         model = d->desktopModel();
         break;
     default:
         Q_UNREACHABLE();
     }
     return model->index(0, 0);
 }
 
 bool TabBoxHandler::eventFilter(QObject *watched, QEvent *e)
 {
     if (e->type() == QEvent::Wheel && watched == d->window()) {
         QWheelEvent *event = static_cast<QWheelEvent*>(e);
         // On x11 the delta for vertical scrolling might also be on X for whatever reason
         const int delta = qAbs(event->angleDelta().x()) > qAbs(event->angleDelta().y()) ? event->angleDelta().x() : event->angleDelta().y();
         d->wheelAngleDelta += delta;
         while (d->wheelAngleDelta <= -120) {
             d->wheelAngleDelta += 120;
             const QModelIndex index = nextPrev(true);
             if (index.isValid()) {
                 setCurrentIndex(index);
             }
         }
         while (d->wheelAngleDelta >= 120) {
             d->wheelAngleDelta -= 120;
             const QModelIndex index = nextPrev(false);
             if (index.isValid()) {
                 setCurrentIndex(index);
             }
         }
         return true;
     }
     // pass on
     return QObject::eventFilter(watched, e);
 }
 
 TabBoxHandler* tabBox = nullptr;
 
 TabBoxClient::TabBoxClient()
 {
 }
 
 TabBoxClient::~TabBoxClient()
 {
 }
 
 } // namespace TabBox
 } // namespace KWin
diff --git a/tabbox/tabboxhandler.h b/tabbox/tabboxhandler.h
index 89bc4a0f3..9a953ac2d 100644
--- a/tabbox/tabboxhandler.h
+++ b/tabbox/tabboxhandler.h
@@ -1,409 +1,406 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 
 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 TABBOXHANDLER_H
 #define TABBOXHANDLER_H
 
 #include "tabboxconfig.h"
 
 #include <QModelIndex>
 #include <QPixmap>
 #include <QString>
-#include <X11/Xlib.h>
-#include <fixx11h.h>
-#include <xcb/xcb.h>
 
 /**
  * @file
  * This file contains the classes which hide KWin core from tabbox.
  * It defines the pure virtual classes TabBoxHandler and TabBoxClient.
  * The classes have to be implemented in KWin Core.
  *
  * @author Martin Gräßlin <mgraesslin@kde.org>
  * @since 4.4
  */
 
 class QKeyEvent;
 
 namespace KWin
 {
 /**
  * The TabBox is a model based view for displaying a list while switching windows or desktops.
  * This functionality is mostly referred to as Alt+Tab. TabBox itself does not provide support for
  * switching windows or desktops. This has to be done outside of TabBox inside an independent controller.
  *
  * The main entrance point to TabBox is the class TabBoxHandler, which has to be subclassed and implemented.
  * The class TabBoxClient, which represents a window client inside TabBox, has to be implemented as well.
  *
  * The behavior of the TabBox is defined by the TabBoxConfig and has to be set in the TabBoxHandler.
  * If the TabBox should be used to switch desktops as well as clients it is sufficient to just provide
  * different TabBoxConfig objects instead of creating an own handler for each mode.
  *
  * In order to use the TabBox the TabBoxConfig has to be set. This defines if the model for desktops or for
  * clients will be used. The model has to be initialized by calling TabBoxHandler::createModel(), as the
  * model is undefined when the TabBox is not active. The TabBox is activated by TabBoxHandler::show().
  * Depending on the current set TabBoxConfig it is possible that the
  * highlight windows effect activated and that the view is not displayed at all. As already mentioned
  * the TabBox does not handle any updating of the selected item. This has to be done by invoking
  * TabBoxHandler::setCurrentIndex(). Nevertheless the TabBoxHandler provides methods to query for the
  * model index or the next or previous item, for a cursor position or for a given item (that is
  * TabBoxClient or desktop). By invoking TabBoxHandler::hide() the view, the
  * optional highlight windows effect are removed. The model is invalidated immediately. So if it is
  * necessary to retrieve the last selected item this has to be done before calling the hide method.
  *
  * The layout of the TabBox View and the items is completely customizable. Therefore TabBox provides
  * a widget LayoutConfig which includes a live preview (in kcmkwin/kwintabbox). The layout of items
  * can be defined by an xml document. That way the user is able to define own custom layouts. The view
  * itself is made up of two widgets: one to show the complete list and one to show only the selected
  * item. This way it is possible to have a view which shows for example a list containing only small
  * icons and nevertheless show the title of the currently selected client.
  */
 namespace TabBox
 {
 class DesktopModel;
 class ClientModel;
 class TabBoxConfig;
 class TabBoxClient;
 class TabBoxHandlerPrivate;
 typedef QList< QWeakPointer< TabBoxClient > > TabBoxClientList;
 
 /**
  * This class is a wrapper around KWin Workspace. It is used for accessing the
  * required core methods from inside TabBox and has to be implemented in KWin core.
  *
  * @author Martin Gräßlin <mgraesslin@kde.org>
  * @since 4.4
  */
 class TabBoxHandler : public QObject
 {
     Q_OBJECT
 public:
     TabBoxHandler(QObject *parent);
     ~TabBoxHandler() override;
 
     /**
      * @return The id of the active screen
      */
     virtual int activeScreen() const = 0;
     /**
      * @return The current active TabBoxClient or NULL
      * if there is no active client.
      */
     virtual QWeakPointer<TabBoxClient> activeClient() const = 0;
     /**
      * @param client The client which is starting point to find the next client
      * @return The next TabBoxClient in focus chain
      */
     virtual QWeakPointer<TabBoxClient> nextClientFocusChain(TabBoxClient* client) const = 0;
     /**
      * This method is used by the ClientModel to find an entrance into the focus chain in case
      * there is no active Client.
      *
      * @return The first Client of the focus chain
      * @since 4.9.1
      */
     virtual QWeakPointer<TabBoxClient> firstClientFocusChain() const = 0;
     /**
      * Checks whether the given @p client is part of the focus chain at all.
      * This is useful to figure out whether the currently active Client can be used
      * as a starting point to construct the recently used list.
      *
      * In case the @p client is not in the focus chain it is recommended to use the
      * Client returned by firstClientFocusChain.
      *
      * The method accepts a @c null Client and in that case @c false is returned.
      * @param client The Client to check whether it is in the Focus Chain
      * @return @c true in case the Client is part of the focus chain, @c false otherwise.
      * @since 4.9.2
      */
     virtual bool isInFocusChain(TabBoxClient* client) const = 0;
     /**
      * @param client The client whose desktop name should be retrieved
      * @return The desktop name of the given TabBoxClient. If the client is
      * on all desktops the name of current desktop will be returned.
      */
     virtual QString desktopName(TabBoxClient* client) const = 0;
     /**
      * @param desktop The desktop whose name should be retrieved
      * @return The desktop name of given desktop
      */
     virtual QString desktopName(int desktop) const = 0;
     /**
      * @return The number of current desktop
      */
     virtual int currentDesktop() const = 0;
     /**
      * @return The number of virtual desktops
      */
     virtual int numberOfDesktops() const = 0;
     /**
      * @param desktop The desktop which is the starting point to find the next desktop
      * @return The next desktop in the current focus chain.
      */
     virtual int nextDesktopFocusChain(int desktop) const = 0;
 
     /**
      * whether KWin is currently compositing and it's related features (elevating) can be used
      */
     virtual bool isKWinCompositing() const = 0;
 
     /**
      * De-/Elevate a client using the compositor (if enabled)
      */
     virtual void elevateClient(TabBoxClient* c, QWindow *tabbox, bool elevate) const = 0;
 
     /**
      * Raise a client (w/o activating it)
      */
     virtual void raiseClient(TabBoxClient* c) const = 0;
 
     /**
      * @param c The client to be restacked
      * @param under The client the other one will be placed below
      */
     virtual void restack(TabBoxClient *c, TabBoxClient *under) = 0;
 
     /**
      * Toggle between ShadeHover and ShadeNormal - not shaded windows are unaffected
      * @param c The client to be shaded
      * @param b Whether to un- or shade
      */
     virtual void shadeClient(TabBoxClient *c, bool b) const = 0;
 
     virtual void highlightWindows(TabBoxClient *window = nullptr, QWindow *controller = nullptr) = 0;
 
     /**
      * @return The current stacking order of TabBoxClients
      */
     virtual TabBoxClientList stackingOrder() const = 0;
     /**
      * Determines if given client will be added to the list:
      * <UL>
      * <LI>Depends on desktop</LI>
      * <LI>if the client wants to have tab focus.</LI>
      * <LI>The client won't be added if it has modal dialogs</LI>
      * <LI>In that case the modal dialog will be returned if it isn't already
      * included</LI>
      * <LI>Won't be added if it isn't on active screen when using separate
      * screen focus</LI>
      * </UL>
      * @param client The client to be checked for inclusion
      * @param desktop The desktop the client should be on. This is irrelevant if allDesktops is set
      * @param allDesktops Add clients from all desktops or only from current
      * @return The client to be included in the list or NULL if it isn't to be included
      */
     virtual QWeakPointer<TabBoxClient> clientToAddToList(TabBoxClient* client, int desktop) const = 0;
     /**
      * @return The first desktop window in the stacking order.
      */
     virtual QWeakPointer<TabBoxClient> desktopClient() const = 0;
     /**
      * Activates the currently selected client and closes the TabBox.
      */
     virtual void activateAndClose() = 0;
 
     /**
      * @return The currently used TabBoxConfig
      */
     const TabBoxConfig& config() const;
     /**
      * Call this method when you want to change the currently used TabBoxConfig.
      * It fires the signal configChanged.
      * @param config Updates the currently used TabBoxConfig to config
      */
     void setConfig(const TabBoxConfig& config);
 
     /**
      * Call this method to show the TabBoxView. Depending on current
      * configuration this method might not do anything.
      * If highlight windows effect is to be used it will be activated.
      * Highlight windows and outline are not shown if
      * TabBoxConfig::TabBoxMode is TabBoxConfig::DesktopTabBox.
      * @see TabBoxConfig::isShowTabBox
      * @see TabBoxConfig::isHighlightWindows
      */
     void show();
     /**
      * Hides the TabBoxView if shown.
      * Deactivates highlight windows effect if active.
      * @see show
      */
     void hide(bool abort = false);
 
     /**
      * Sets the current model index in the view and updates
      * highlight windows if active.
      * @param index The current Model index
      */
     void setCurrentIndex(const QModelIndex& index);
     /**
      * @returns the current index
      */
     const QModelIndex &currentIndex() const;
 
     /**
      * Retrieves the next or previous item of the current item.
      * @param forward next or previous item
      * @return The next or previous item. If there is no matching item
      * the current item will be returned.
      */
     QModelIndex nextPrev(bool forward) const;
 
     /**
      * Initializes the model based on the current config.
      * This method has to be invoked before showing the TabBox.
      * It can also be invoked when clients are added or removed.
      * In that case partialReset has to be true.
      *
      * @param partialReset Keep the currently selected item or regenerate everything
      */
     void createModel(bool partialReset = false);
 
     /**
      * @param desktop The desktop whose index should be retrieved
      * @return The model index of given desktop. If TabBoxMode is not
      * TabBoxConfig::DesktopTabBox an invalid model index will be returned.
      */
     QModelIndex desktopIndex(int desktop) const;
     /**
      * @return The current list of desktops.
      * If TabBoxMode is not TabBoxConfig::DesktopTabBox an empty list will
      * be returned.
      * @see DesktopModel::desktopList
      */
     QList< int > desktopList() const;
     /**
      * @return The desktop for given model index. If the index is not valid
      * or TabBoxMode is not TabBoxConfig::DesktopTabBox -1 will be returned.
      * @see DesktopModel::desktopIndex
      */
     int desktop(const QModelIndex& index) const;
 
     /**
      * Handles additional grabbed key events by the TabBox controller.
      * @param event The key event which has been grabbed
      */
     virtual void grabbedKeyEvent(QKeyEvent* event) const;
     /**
      * @param pos The position to be tested in global coordinates
      * @return True if the view contains the point, otherwise false.
      */
     bool containsPos(const QPoint& pos) const;
     /**
      * @param client The TabBoxClient whose index should be returned
      * @return Returns the ModelIndex of given TabBoxClient or an invalid ModelIndex
      * if the model does not contain the given TabBoxClient.
      * @see ClientModel::index
      */
     QModelIndex index(QWeakPointer<TabBoxClient> client) const;
     /**
      * @return Returns the current list of TabBoxClients.
      * If TabBoxMode is not TabBoxConfig::ClientTabBox an empty list will
      * be returned.
      * @see ClientModel::clientList
      */
     TabBoxClientList clientList() const;
     /**
      * @param index The index of the client to be returned
      * @return Returns the TabBoxClient at given model index. If
      * the index is invalid, does not point to a Client or the list
      * is empty, NULL will be returned.
      */
     TabBoxClient* client(const QModelIndex& index) const;
     /**
      * @return The first model index. That is the model index at position 0, 0.
      * It is valid, as desktop has at least one desktop and if there are no
      * clients an empty item is created.
      */
     QModelIndex first() const;
 
     bool eventFilter(QObject *watcher, QEvent *event) override;
 
     /**
      * @returns whether the TabBox operates in a no modifier grab mode.
      * In this mode a click on an item should directly accept and close the tabbox.
      */
     virtual bool noModifierGrab() const = 0;
 
 Q_SIGNALS:
     /**
      * This signal is fired when the TabBoxConfig changes
      * @see setConfig
      */
     void configChanged();
     void selectedIndexChanged();
 
 private Q_SLOTS:
     void initHighlightWindows();
 
 private:
     friend class TabBoxHandlerPrivate;
     TabBoxHandlerPrivate* d;
 };
 
 /**
  * This class is a wrapper around a KWin Client. It is used for accessing the
  * required client methods from inside TabBox and has to be implemented in KWin core.
  *
  * @author Martin Gräßlin <mgraesslin@kde.org>
  * @since 4.4
  */
 class TabBoxClient
 {
 public:
     TabBoxClient();
     virtual ~TabBoxClient();
 
     /**
      * @return The caption of the client
      */
     virtual QString caption() const = 0;
     /**
      * @param size Requested size of the icon
      * @return The icon of the client
      */
     virtual QIcon icon() const = 0;
     /**
      * @return The window Id of the client
      */
     virtual WId window() const = 0;
     /**
      * @return Minimized state of the client
      */
     virtual bool isMinimized() const = 0;
     virtual int x() const = 0;
     virtual int y() const = 0;
     virtual int width() const = 0;
     virtual int height() const = 0;
     virtual bool isCloseable() const = 0;
     virtual void close() = 0;
     virtual bool isFirstInTabBox() const = 0;
     virtual QUuid internalId() const = 0;
 };
 
 /**
  * Pointer to the global TabBoxHandler object.
  */
 extern TabBoxHandler* tabBox;
 
 } // namespace TabBox
 } // namespace KWin
 
 #endif // TABBOXHANDLER_H