diff --git a/plugins/platforms/drm/screens_drm.cpp b/plugins/platforms/drm/screens_drm.cpp
index 5ab27cdb4..8714bf0b1 100644
--- a/plugins/platforms/drm/screens_drm.cpp
+++ b/plugins/platforms/drm/screens_drm.cpp
@@ -1,107 +1,107 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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/>.
 *********************************************************************/
 #include "screens_drm.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 
 namespace KWin
 {
 
 DrmScreens::DrmScreens(DrmBackend *backend, QObject *parent)
     : Screens(parent)
     , m_backend(backend)
 {
     connect(backend, &DrmBackend::screensQueried, this, &DrmScreens::updateCount);
     connect(backend, &DrmBackend::screensQueried, this, &DrmScreens::changed);
 }
 
 DrmScreens::~DrmScreens() = default;
 
 void DrmScreens::init()
 {
-    KWin::Screens::init();
     updateCount();
+    KWin::Screens::init();
     emit changed();
 }
 
 QRect DrmScreens::geometry(int screen) const
 {
     const auto outputs = m_backend->outputs();
     if (screen >= outputs.size()) {
         return QRect();
     }
     return outputs.at(screen)->geometry();
 }
 
 QSize DrmScreens::size(int screen) const
 {
     const auto outputs = m_backend->outputs();
     if (screen >= outputs.size()) {
         return QSize();
     }
     return outputs.at(screen)->size();
 }
 
 void DrmScreens::updateCount()
 {
     setCount(m_backend->outputs().size());
 }
 
 int DrmScreens::number(const QPoint &pos) const
 {
     int bestScreen = 0;
     int minDistance = INT_MAX;
     const auto outputs = m_backend->outputs();
     for (int i = 0; i < outputs.size(); ++i) {
         const QRect &geo = outputs.at(i)->geometry();
         if (geo.contains(pos)) {
             return i;
         }
         int distance = QPoint(geo.topLeft() - pos).manhattanLength();
         distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength());
         if (distance < minDistance) {
             minDistance = distance;
             bestScreen = i;
         }
     }
     return bestScreen;
 }
 
 QString DrmScreens::name(int screen) const
 {
     const auto outputs = m_backend->outputs();
     if (screen >= outputs.size()) {
         return Screens::name(screen);
     }
     return outputs.at(screen)->name();
 }
 
 float DrmScreens::refreshRate(int screen) const
 {
     const auto outputs = m_backend->outputs();
     if (screen >= outputs.size()) {
         return Screens::refreshRate(screen);
     }
     return outputs.at(screen)->currentRefreshRate() / 1000.0f;
 }
 
 }
diff --git a/plugins/platforms/virtual/screens_virtual.cpp b/plugins/platforms/virtual/screens_virtual.cpp
index 531c9c4e9..7cd2fdfb9 100644
--- a/plugins/platforms/virtual/screens_virtual.cpp
+++ b/plugins/platforms/virtual/screens_virtual.cpp
@@ -1,98 +1,98 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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/>.
 *********************************************************************/
 #include "screens_virtual.h"
 #include "virtual_backend.h"
 
 namespace KWin
 {
 
 VirtualScreens::VirtualScreens(VirtualBackend *backend, QObject *parent)
     : Screens(parent)
     , m_backend(backend)
 {
 }
 
 VirtualScreens::~VirtualScreens() = default;
 
 void VirtualScreens::init()
 {
+    updateCount();
     KWin::Screens::init();
     connect(m_backend, &VirtualBackend::sizeChanged,
             this, &VirtualScreens::startChangedTimer);
     connect(m_backend, &VirtualBackend::outputGeometriesChanged, this,
         [this] (const QVector<QRect> &geometries) {
             const int oldCount = m_geometries.count();
             m_geometries = geometries;
             if (oldCount != m_geometries.count()) {
                 setCount(m_geometries.count());
             } else {
                 emit changed();
             }
         }
     );
-    updateCount();
     emit changed();
 }
 
 QRect VirtualScreens::geometry(int screen) const
 {
     if (screen >= m_geometries.count()) {
         return QRect();
     }
     return m_geometries.at(screen);
 }
 
 QSize VirtualScreens::size(int screen) const
 {
     return geometry(screen).size();
 }
 
 void VirtualScreens::updateCount()
 {
     m_geometries.clear();
     const QSize size = m_backend->size();
     for (int i = 0; i < m_backend->outputCount(); ++i) {
         m_geometries.append(QRect(size.width() * i, 0, size.width(), size.height()));
     }
     setCount(m_backend->outputCount());
 }
 
 int VirtualScreens::number(const QPoint &pos) const
 {
     int bestScreen = 0;
     int minDistance = INT_MAX;
     for (int i = 0; i < m_geometries.count(); ++i) {
         const QRect &geo = m_geometries.at(i);
         if (geo.contains(pos)) {
             return i;
         }
         int distance = QPoint(geo.topLeft() - pos).manhattanLength();
         distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength());
         if (distance < minDistance) {
             minDistance = distance;
             bestScreen = i;
         }
     }
     return bestScreen;
 }
 
 }
diff --git a/screens.cpp b/screens.cpp
index 3ffb22d6e..a08245ee0 100644
--- a/screens.cpp
+++ b/screens.cpp
@@ -1,243 +1,243 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 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/>.
 *********************************************************************/
 #include "screens.h"
 #include <abstract_client.h>
 #include <client.h>
 #include "cursor.h"
 #include "utils.h"
 #include "settings.h"
 #include <workspace.h>
 #include <config-kwin.h>
 #include "platform.h"
 #include "wayland_server.h"
 #ifdef KWIN_UNIT_TEST
 #include <mock_screens.h>
 #endif
 
 namespace KWin
 {
 
 Screens *Screens::s_self = nullptr;
 Screens *Screens::create(QObject *parent)
 {
     Q_ASSERT(!s_self);
 #ifdef KWIN_UNIT_TEST
     s_self = new MockScreens(parent);
 #else
     s_self = kwinApp()->platform()->createScreens(parent);
 #endif
     Q_ASSERT(s_self);
     s_self->init();
     return s_self;
 }
 
 Screens::Screens(QObject *parent)
     : QObject(parent)
     , m_count(0)
     , m_current(0)
     , m_currentFollowsMouse(false)
     , m_changedTimer(new QTimer(this))
 {
 }
 
 Screens::~Screens()
 {
     s_self = NULL;
 }
 
 void Screens::init()
 {
     m_changedTimer->setSingleShot(true);
     m_changedTimer->setInterval(100);
     connect(m_changedTimer, SIGNAL(timeout()), SLOT(updateCount()));
     connect(m_changedTimer, SIGNAL(timeout()), SIGNAL(changed()));
     connect(this, &Screens::countChanged, this, &Screens::changed, Qt::QueuedConnection);
     connect(this, &Screens::changed, this, &Screens::updateSize);
     connect(this, &Screens::sizeChanged, this, &Screens::geometryChanged);
 
     Settings settings;
     settings.setDefaults();
     m_currentFollowsMouse = settings.activeMouseScreen();
 }
 
 QString Screens::name(int screen) const
 {
     Q_UNUSED(screen)
     qCWarning(KWIN_CORE, "%s::name(int screen) is a stub, please reimplement it!", metaObject()->className());
     return QLatin1String("DUMMY");
 }
 
 float Screens::refreshRate(int screen) const
 {
     Q_UNUSED(screen)
     qCWarning(KWIN_CORE, "%s::refreshRate(int screen) is a stub, please reimplement it!", metaObject()->className());
     return 60.0f;
 }
 
 void Screens::reconfigure()
 {
     if (!m_config) {
         return;
     }
     Settings settings(m_config);
     settings.read();
     setCurrentFollowsMouse(settings.activeMouseScreen());
 }
 
 void Screens::updateSize()
 {
     QRect bounding;
     for (int i = 0; i < count(); ++i) {
         bounding = bounding.united(geometry(i));
     }
     if (m_boundingSize != bounding.size()) {
         m_boundingSize = bounding.size();
         emit sizeChanged();
     }
 }
 
 void Screens::setCount(int count)
 {
     if (m_count == count) {
         return;
     }
     const int previous = m_count;
     m_count = count;
     emit countChanged(previous, count);
 }
 
 void Screens::setCurrent(int current)
 {
     if (m_current == current) {
         return;
     }
     m_current = current;
     emit currentChanged();
 }
 
 void Screens::setCurrent(const QPoint &pos)
 {
     setCurrent(number(pos));
 }
 
 void Screens::setCurrent(const AbstractClient *c)
 {
     if (!c->isActive()) {
         return;
     }
     if (!c->isOnScreen(m_current)) {
         setCurrent(c->screen());
     }
 }
 
 void Screens::setCurrentFollowsMouse(bool follows)
 {
     if (m_currentFollowsMouse == follows) {
         return;
     }
     m_currentFollowsMouse = follows;
 }
 
 int Screens::current() const
 {
     if (m_currentFollowsMouse) {
         return number(Cursor::pos());
     }
     AbstractClient *client = Workspace::self()->activeClient();
     if (client && !client->isOnScreen(m_current)) {
         return client->screen();
     }
     return m_current;
 }
 
 int Screens::intersecting(const QRect &r) const
 {
     int cnt = 0;
     for (int i = 0; i < count(); ++i) {
         if (geometry(i).intersects(r)) {
             ++cnt;
         }
     }
     return cnt;
 }
 
 BasicScreens::BasicScreens(Platform *backend, QObject *parent)
     : Screens(parent)
     , m_backend(backend)
 {
 }
 
 BasicScreens::~BasicScreens() = default;
 
 void BasicScreens::init()
 {
+    updateCount();
     KWin::Screens::init();
 #ifndef KWIN_UNIT_TEST
     connect(m_backend, &Platform::screenSizeChanged,
             this, &BasicScreens::startChangedTimer);
 #endif
-    updateCount();
     emit changed();
 }
 
 QRect BasicScreens::geometry(int screen) const
 {
     if (screen < m_geometries.count()) {
         return m_geometries.at(screen);
     }
     return QRect();
 }
 
 QSize BasicScreens::size(int screen) const
 {
     if (screen < m_geometries.count()) {
         return m_geometries.at(screen).size();
     }
     return QSize();
 }
 
 void BasicScreens::updateCount()
 {
     m_geometries = m_backend->screenGeometries();
     setCount(m_geometries.count());
 }
 
 int BasicScreens::number(const QPoint &pos) const
 {
     int bestScreen = 0;
     int minDistance = INT_MAX;
     for (int i = 0; i < m_geometries.count(); ++i) {
         const QRect &geo = m_geometries.at(i);
         if (geo.contains(pos)) {
             return i;
         }
         int distance = QPoint(geo.topLeft() - pos).manhattanLength();
         distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength());
         if (distance < minDistance) {
             minDistance = distance;
             bestScreen = i;
         }
     }
     return bestScreen;
 }
 
 } // namespace