diff --git a/src/client/plasmavirtualdesktop.cpp b/src/client/plasmavirtualdesktop.cpp
index 816b143..3121660 100644
--- a/src/client/plasmavirtualdesktop.cpp
+++ b/src/client/plasmavirtualdesktop.cpp
@@ -1,352 +1,363 @@
 /****************************************************************************
 Copyright 2018  Marco Martin <notmart@gmail.com>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
 #include "plasmavirtualdesktop.h"
 #include "event_queue.h"
 #include "wayland_pointer_p.h"
 
 #include <QMap>
 #include <QDebug>
 
 #include <wayland-plasma-virtual-desktop-client-protocol.h>
 
 namespace KWayland
 {
 namespace Client
 {
 
 class Q_DECL_HIDDEN PlasmaVirtualDesktopManagement::Private
 {
 public:
     Private(PlasmaVirtualDesktopManagement *q);
 
     void setup(org_kde_plasma_virtual_desktop_management *arg);
 
     WaylandPointer<org_kde_plasma_virtual_desktop_management, org_kde_plasma_virtual_desktop_management_destroy> plasmavirtualdesktopmanagement;
     EventQueue *queue = nullptr;
 
-    //is a map to have desktops() return a list always with the same order
-    QMap<QString, PlasmaVirtualDesktop *> desktops;
-    QList<PlasmaVirtualDesktop *> desktopsOrder;
+    QList<PlasmaVirtualDesktop *> desktops;
+
+    inline QList<PlasmaVirtualDesktop*>::const_iterator constFindDesktop(const QString &id);
+    inline QList<PlasmaVirtualDesktop*>::iterator findDesktop(const QString &id);
 
 private:
     static void addedCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management, const char *id, uint32_t position);
     static void removedCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management, const char *id);
     static void doneCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management);
 
     PlasmaVirtualDesktopManagement *q;
 
     static const org_kde_plasma_virtual_desktop_management_listener s_listener;
 };
 
+inline QList<PlasmaVirtualDesktop*>::const_iterator PlasmaVirtualDesktopManagement::Private::constFindDesktop(const QString &id)
+{
+    return std::find_if( desktops.constBegin(),
+                         desktops.constEnd(),
+                         [id]( const PlasmaVirtualDesktop *desk ){ return desk->id() == id; } );
+}
+
+inline QList<PlasmaVirtualDesktop*>::iterator PlasmaVirtualDesktopManagement::Private::findDesktop(const QString &id)
+{
+    return std::find_if( desktops.begin(),
+                         desktops.end(),
+                         [id]( const PlasmaVirtualDesktop *desk ){ return desk->id() == id; } );
+}
+
 const org_kde_plasma_virtual_desktop_management_listener PlasmaVirtualDesktopManagement::Private::s_listener = {
     addedCallback,
     removedCallback,
     doneCallback
 };
 
 void PlasmaVirtualDesktopManagement::Private::addedCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management, const char *id, uint32_t position)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktopManagement::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktopmanagement == org_kde_plasma_virtual_desktop_management);
     const QString stringId = QString::fromUtf8(id);
     PlasmaVirtualDesktop *vd = p->q->getVirtualDesktop(stringId);
     Q_ASSERT(vd);
 
-    p->desktopsOrder.insert(position, vd);
+    p->desktops.insert(position, vd);
     //TODO: emit a lot of desktopMoved?
 
     emit p->q->desktopAdded(stringId, position);
 }
 
 void PlasmaVirtualDesktopManagement::Private::removedCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management, const char *id)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktopManagement::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktopmanagement == org_kde_plasma_virtual_desktop_management);
     const QString stringId = QString::fromUtf8(id);
     PlasmaVirtualDesktop *vd = p->q->getVirtualDesktop(stringId);
-    p->desktops.remove(stringId);
-    p->desktopsOrder.removeAll(vd);
     //TODO: emit a lot of desktopMoved?
     Q_ASSERT(vd);
+    auto i = p->findDesktop(stringId);
+    p->desktops.erase(i);
     vd->release();
     vd->destroy();
     vd->deleteLater();
     emit p->q->desktopRemoved(stringId);
 }
 
 void PlasmaVirtualDesktopManagement::Private::doneCallback(void *data, org_kde_plasma_virtual_desktop_management *org_kde_plasma_virtual_desktop_management)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktopManagement::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktopmanagement == org_kde_plasma_virtual_desktop_management);
     emit p->q->done();
 }
 
 PlasmaVirtualDesktopManagement::PlasmaVirtualDesktopManagement(QObject *parent)
     : QObject(parent)
     , d(new Private(this))
 {
 }
 
 PlasmaVirtualDesktopManagement::Private::Private(PlasmaVirtualDesktopManagement *q)
     : q(q)
 {}
 
 void PlasmaVirtualDesktopManagement::Private::setup(org_kde_plasma_virtual_desktop_management *arg)
 {
     Q_ASSERT(arg);
     Q_ASSERT(!plasmavirtualdesktopmanagement);
     plasmavirtualdesktopmanagement.setup(arg);
     org_kde_plasma_virtual_desktop_management_add_listener(plasmavirtualdesktopmanagement, &s_listener, this);
 }
 
 PlasmaVirtualDesktopManagement::~PlasmaVirtualDesktopManagement()
 {
     release();
 }
 
 void PlasmaVirtualDesktopManagement::setup(org_kde_plasma_virtual_desktop_management *plasmavirtualdesktopmanagement)
 {
     d->setup(plasmavirtualdesktopmanagement);
 }
 
 void PlasmaVirtualDesktopManagement::release()
 {
     d->plasmavirtualdesktopmanagement.release();
 }
 
 void PlasmaVirtualDesktopManagement::destroy()
 {
     d->plasmavirtualdesktopmanagement.destroy();
 }
 
 PlasmaVirtualDesktopManagement::operator org_kde_plasma_virtual_desktop_management*() {
     return d->plasmavirtualdesktopmanagement;
 }
 
 PlasmaVirtualDesktopManagement::operator org_kde_plasma_virtual_desktop_management*() const {
     return d->plasmavirtualdesktopmanagement;
 }
 
 bool PlasmaVirtualDesktopManagement::isValid() const
 {
     return d->plasmavirtualdesktopmanagement.isValid();
 }
 
 void PlasmaVirtualDesktopManagement::setEventQueue(EventQueue *queue)
 {
     d->queue = queue;
 }
 
 EventQueue *PlasmaVirtualDesktopManagement::eventQueue()
 {
     return d->queue;
 }
 
 PlasmaVirtualDesktop *PlasmaVirtualDesktopManagement::getVirtualDesktop(const QString &id)
 {
     Q_ASSERT(isValid());
-    auto i = d->desktops.constFind(id);
+
+    auto i = d->constFindDesktop(id);
     if (i != d->desktops.constEnd()) {
         return *i;
     }
 
     auto w = org_kde_plasma_virtual_desktop_management_get_virtual_desktop(d->plasmavirtualdesktopmanagement, id.toUtf8());
 
     if (!w) {
         return nullptr;
     }
 
     if (d->queue) {
         d->queue->addProxy(w);
     }
 
     auto desktop = new PlasmaVirtualDesktop(this);
     desktop->setup(w);
-    d->desktops[id] = desktop;
-    connect(desktop, &QObject::destroyed, this,
-        [this, id] {
-            d->desktops.remove(id);
-        }
-    );
+
     return desktop;
 }
 
 QList <PlasmaVirtualDesktop *> PlasmaVirtualDesktopManagement::desktops() const
 {
-    return d->desktopsOrder;
+    return d->desktops;
 }
 
 class Q_DECL_HIDDEN PlasmaVirtualDesktop::Private
 {
 public:
     Private(PlasmaVirtualDesktop *q);
 
     void setup(org_kde_plasma_virtual_desktop *arg);
 
     WaylandPointer<org_kde_plasma_virtual_desktop, org_kde_plasma_virtual_desktop_destroy> plasmavirtualdesktop;
 
     QString id;
     QString name;
     bool active = false;
 
 private:
     PlasmaVirtualDesktop *q;
 
 private:
     static void idCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop, const char * id);
     static void nameCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop, const char * name);
 
     static void activatedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop);
     static void deactivatedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop);
     static void doneCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop);
     static void removedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop);
 
     static const org_kde_plasma_virtual_desktop_listener s_listener;
 };
 
 const org_kde_plasma_virtual_desktop_listener PlasmaVirtualDesktop::Private::s_listener = {
     idCallback,
     nameCallback,
     activatedCallback,
     deactivatedCallback,
     doneCallback,
     removedCallback
 };
 
 void PlasmaVirtualDesktop::Private::idCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop, const char * id)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     p->id = QString::fromUtf8(id);
 }
 
 void PlasmaVirtualDesktop::Private::nameCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop, const char * name)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     p->name = QString::fromUtf8(name);
 }
 
 void PlasmaVirtualDesktop::Private::activatedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     p->active = true;
     emit p->q->activated();
 }
 
 void PlasmaVirtualDesktop::Private::deactivatedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     p->active = false;
     emit p->q->deactivated();
 }
 
 void PlasmaVirtualDesktop::Private::doneCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     emit p->q->done();
 }
 
 void PlasmaVirtualDesktop::Private::removedCallback(void *data, org_kde_plasma_virtual_desktop *org_kde_plasma_virtual_desktop)
 {
     auto p = reinterpret_cast<PlasmaVirtualDesktop::Private*>(data);
     Q_ASSERT(p->plasmavirtualdesktop == org_kde_plasma_virtual_desktop);
     emit p->q->removed();
 }
 
 PlasmaVirtualDesktop::Private::Private(PlasmaVirtualDesktop *q)
     : q(q)
 {
 }
 
 PlasmaVirtualDesktop::PlasmaVirtualDesktop(QObject *parent)
     : QObject(parent)
     , d(new Private(this))
 {
 }
 
 void PlasmaVirtualDesktop::Private::setup(org_kde_plasma_virtual_desktop *arg)
 {
     Q_ASSERT(arg);
     Q_ASSERT(!plasmavirtualdesktop);
     plasmavirtualdesktop.setup(arg);
     org_kde_plasma_virtual_desktop_add_listener(plasmavirtualdesktop, &s_listener, this);
 }
 
 PlasmaVirtualDesktop::~PlasmaVirtualDesktop()
 {
     release();
 }
 
 void PlasmaVirtualDesktop::setup(org_kde_plasma_virtual_desktop *plasmavirtualdesktop)
 {
     d->setup(plasmavirtualdesktop);
 }
 
 void PlasmaVirtualDesktop::release()
 {
     d->plasmavirtualdesktop.release();
 }
 
 void PlasmaVirtualDesktop::destroy()
 {
     d->plasmavirtualdesktop.destroy();
 }
 
 PlasmaVirtualDesktop::operator org_kde_plasma_virtual_desktop*() {
     return d->plasmavirtualdesktop;
 }
 
 PlasmaVirtualDesktop::operator org_kde_plasma_virtual_desktop*() const {
     return d->plasmavirtualdesktop;
 }
 
 bool PlasmaVirtualDesktop::isValid() const
 {
     return d->plasmavirtualdesktop.isValid();
 }
 
 void PlasmaVirtualDesktop::requestActivate()
 {
     Q_ASSERT(isValid());
     org_kde_plasma_virtual_desktop_request_activate(d->plasmavirtualdesktop);
 }
 
 QString PlasmaVirtualDesktop::id() const
 {
     return d->id;
 }
 
 QString PlasmaVirtualDesktop::name() const
 {
     return d->name;
 }
 
 bool PlasmaVirtualDesktop::active() const
 {
     return d->active;
 }
 
 }
 }
 
diff --git a/src/server/plasmavirtualdesktop_interface.cpp b/src/server/plasmavirtualdesktop_interface.cpp
index 3354d15..b88b680 100644
--- a/src/server/plasmavirtualdesktop_interface.cpp
+++ b/src/server/plasmavirtualdesktop_interface.cpp
@@ -1,379 +1,396 @@
 /****************************************************************************
 Copyright 2018  Marco Martin <notmart@gmail.com>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) version 3, or any
 later version accepted by the membership of KDE e.V. (or its
 successor approved by the membership of KDE e.V.), which shall
 act as a proxy defined in Section 6 of version 3 of the license.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
 #include "plasmavirtualdesktop_interface.h"
 #include "display.h"
 #include "global_p.h"
 #include "resource_p.h"
 
 #include <QDebug>
 #include <QTimer>
 
 #include <wayland-server.h>
 #include <wayland-plasma-virtual-desktop-server-protocol.h>
 
 namespace KWayland
 {
 namespace Server
 {
 
 class Q_DECL_HIDDEN PlasmaVirtualDesktopInterface::Private
 {
 public:
     Private(PlasmaVirtualDesktopInterface *q, PlasmaVirtualDesktopManagementInterface *c);
     ~Private();
     void createResource(wl_resource *parent, quint32 serial);
 
     PlasmaVirtualDesktopInterface *q;
     PlasmaVirtualDesktopManagementInterface *vdm;
 
     QVector<wl_resource*> resources;
     QString id;
     QString name;
     bool active = false;
 
 private:
     static void unbind(wl_resource *resource);
     static void requestActivateCallback(wl_client *client, wl_resource *resource);
 
     static Private *cast(wl_resource *resource) {
         return reinterpret_cast<Private*>(wl_resource_get_user_data(resource));
     }
 
     wl_listener listener;
     static const struct org_kde_plasma_virtual_desktop_interface s_interface;
 };
 
 
 class Q_DECL_HIDDEN PlasmaVirtualDesktopManagementInterface::Private : public Global::Private
 {
 public:
     Private(PlasmaVirtualDesktopManagementInterface *q, Display *d);
 
     QVector<wl_resource*> resources;
-    QMap<QString, PlasmaVirtualDesktopInterface*> desktops;
-    QList<PlasmaVirtualDesktopInterface*> desktopsOrder;
+    QList<PlasmaVirtualDesktopInterface*> desktops;
     quint32 rows = 0;
     quint32 columns = 0;
 
+    inline QList<PlasmaVirtualDesktopInterface*>::const_iterator constFindDesktop(const QString &id);
+    inline QList<PlasmaVirtualDesktopInterface*>::iterator findDesktop(const QString &id);
 private:
     void bind(wl_client *client, uint32_t version, uint32_t id) override;
 
     static void unbind(wl_resource *resource);
     static Private *cast(wl_resource *r) {
         return reinterpret_cast<Private*>(wl_resource_get_user_data(r));
     }
 
     static void getVirtualDesktopCallback(wl_client *client, wl_resource *resource, uint32_t serial, const char *id);
     static void releaseCallback(wl_client *client, wl_resource *resource);
 
     PlasmaVirtualDesktopManagementInterface *q;
 
     static const struct org_kde_plasma_virtual_desktop_management_interface s_interface;
     static const quint32 s_version;
 };
 
 const quint32 PlasmaVirtualDesktopManagementInterface::Private::s_version = 1;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 const struct org_kde_plasma_virtual_desktop_management_interface PlasmaVirtualDesktopManagementInterface::Private::s_interface = {
     getVirtualDesktopCallback,
     releaseCallback
 };
 #endif
 
+inline QList<PlasmaVirtualDesktopInterface*>::const_iterator PlasmaVirtualDesktopManagementInterface::Private::constFindDesktop(const QString &id)
+{
+    return std::find_if( desktops.constBegin(),
+                         desktops.constEnd(),
+                         [id]( const PlasmaVirtualDesktopInterface *desk ){ return desk->id() == id; } );
+}
+
+inline QList<PlasmaVirtualDesktopInterface*>::iterator PlasmaVirtualDesktopManagementInterface::Private::findDesktop(const QString &id)
+{
+    return std::find_if( desktops.begin(),
+                         desktops.end(),
+                         [id]( const PlasmaVirtualDesktopInterface *desk ){ return desk->id() == id; } );
+}
+
 void PlasmaVirtualDesktopManagementInterface::Private::getVirtualDesktopCallback(wl_client *client, wl_resource *resource, uint32_t serial, const char *id)
 {
     Q_UNUSED(client)
     auto s = cast(resource);
 
-    auto i = s->desktops.constFind(QString::fromUtf8(id));
+    auto i = s->constFindDesktop(QString::fromUtf8(id));
     if (i == s->desktops.constEnd()) {
         return;
     }
 
     (*i)->d->createResource(resource, serial);
 }
 
 void PlasmaVirtualDesktopManagementInterface::Private::releaseCallback(wl_client *client, wl_resource *resource)
 {
     Q_UNUSED(client)
     wl_resource_destroy(resource);
 }
 
 PlasmaVirtualDesktopManagementInterface::Private::Private(PlasmaVirtualDesktopManagementInterface *q, Display *d)
     : Global::Private(d, &org_kde_plasma_virtual_desktop_management_interface, s_version)
     , q(q)
 {
 }
 
 void PlasmaVirtualDesktopManagementInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
 {
     auto c = display->getConnection(client);
     wl_resource *resource = c->createResource(&org_kde_plasma_virtual_desktop_management_interface, qMin(version, s_version), id);
 
     if (!resource) {
         wl_client_post_no_memory(client);
         return;
     }
     resources << resource;
 
     wl_resource_set_implementation(resource, &s_interface, this, unbind);
 
     quint32 i = 0;
     for (auto it = desktops.constBegin(); it != desktops.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_management_send_desktop_added(resource, (*it)->id().toUtf8().constData(), i++);
     }
 }
 
 void PlasmaVirtualDesktopManagementInterface::Private::unbind(wl_resource *resource)
 {
     auto dm = reinterpret_cast<Private*>(wl_resource_get_user_data(resource));
     dm->resources.removeAll(resource);
 }
 
 PlasmaVirtualDesktopManagementInterface::PlasmaVirtualDesktopManagementInterface(Display *display, QObject *parent)
     : Global(new Private(this, display), parent)
 {
 }
 
 PlasmaVirtualDesktopManagementInterface::~PlasmaVirtualDesktopManagementInterface()
 {}
 
 PlasmaVirtualDesktopManagementInterface::Private *PlasmaVirtualDesktopManagementInterface::d_func() const
 {
     return reinterpret_cast<Private*>(d.data());
 }
 
 PlasmaVirtualDesktopInterface *PlasmaVirtualDesktopManagementInterface::desktop(const QString &id)
 {
     Q_D();
-    
-    auto i = d->desktops.constFind(id);
+    auto i = d->constFindDesktop(id);
     if (i != d->desktops.constEnd()) {
         return *i;
     }
     return nullptr;
 }
 
 PlasmaVirtualDesktopInterface *PlasmaVirtualDesktopManagementInterface::createDesktop(const QString &id)
 {
     Q_D();
-    
-    auto i = d->desktops.constFind(id);
+    auto i = d->constFindDesktop(id);
     if (i != d->desktops.constEnd()) {
         return *i;
     }
 
     PlasmaVirtualDesktopInterface *desktop = new PlasmaVirtualDesktopInterface(this);
     desktop->d->id = id;
     for (auto it = desktop->d->resources.constBegin(); it != desktop->d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_send_id(*it, id.toUtf8().constData());
     }
 
     //activate the first desktop TODO: to be done here?
     if (d->desktops.isEmpty()) {
         desktop->d->active = true;
     }
 
-    d->desktops[id] = desktop;
-    d->desktopsOrder << desktop;
+    d->desktops << desktop;
     connect(desktop, &QObject::destroyed, this,
         [this, id] {
             Q_D();
-            d->desktops.remove(id);
+            auto i = d->findDesktop(id);
+            if (i != d->desktops.end()) {
+                for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
+                    org_kde_plasma_virtual_desktop_management_send_desktop_removed(*it, id.toUtf8().constData());
+                }
+                d->desktops.erase(i);
+            }
             //TODO: activate another desktop?
         }
     );
 
     for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
-        org_kde_plasma_virtual_desktop_management_send_desktop_added(*it, id.toUtf8().constData(), d->desktopsOrder.length()-1);
+        org_kde_plasma_virtual_desktop_management_send_desktop_added(*it, id.toUtf8().constData(), d->desktops.length()-1);
     }
 
     return desktop;
 }
 
 void PlasmaVirtualDesktopManagementInterface::removeDesktop(const QString &id)
 {
     Q_D();
-    
-    auto deskIt = d->desktops.constFind(id);
-    if (deskIt == d->desktops.constEnd()) {
+    auto deskIt = d->findDesktop(id);
+    if (deskIt == d->desktops.end()) {
         return;
     }
 
     for (auto it = (*deskIt)->d->resources.constBegin(); it != (*deskIt)->d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_send_removed(*it);
     }
 
     for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_management_send_desktop_removed(*it, id.toUtf8().constData());
     }
 
-    d->desktopsOrder.removeAll(*deskIt);
+    d->desktops.erase(deskIt);
     (*deskIt)->deleteLater();
 }
 
 QList <PlasmaVirtualDesktopInterface *> PlasmaVirtualDesktopManagementInterface::desktops() const
 {
     Q_D();
-    return d->desktopsOrder;
+    return d->desktops;
 }
 
 void PlasmaVirtualDesktopManagementInterface::sendDone()
 {
     Q_D();
     for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_management_send_done(*it);
     }
 }
 
 void PlasmaVirtualDesktopManagementInterface::setActiveDesktop(const QString &id)
 {
     Q_D();
     for (auto it = d->desktops.constBegin(); it != d->desktops.constEnd(); ++it) {
         auto desktop = *it;
         if (desktop->id() == id) {
             desktop->d->active = true;
             for (auto it = desktop->d->resources.constBegin(); it != desktop->d->resources.constEnd(); ++it) {
                 org_kde_plasma_virtual_desktop_send_activated(*it);
             }
         } else {
             if (desktop->d->active) {
                 desktop->d->active = false;
                 for (auto it = desktop->d->resources.constBegin(); it != desktop->d->resources.constEnd(); ++it) {
                     org_kde_plasma_virtual_desktop_send_deactivated(*it);
                 }
             }
         }
     }
 }
 
 
 
 //// PlasmaVirtualDesktopInterface
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 const struct org_kde_plasma_virtual_desktop_interface PlasmaVirtualDesktopInterface::Private::s_interface = {
     requestActivateCallback
 };
 #endif
 
 void PlasmaVirtualDesktopInterface::Private::requestActivateCallback(wl_client *client, wl_resource *resource)
 {
     Q_UNUSED(client)
     auto s = cast(resource);
     emit s->q->activateRequested();
 }
 
 PlasmaVirtualDesktopInterface::Private::Private(PlasmaVirtualDesktopInterface *q, PlasmaVirtualDesktopManagementInterface *c)
     : q(q),
       vdm(c)
 {
 }
 
 PlasmaVirtualDesktopInterface::Private::~Private()
 {
    // need to copy, as destroy goes through the destroy listener and modifies the list as we iterate
     const auto c = resources;
     for (const auto &r : c) {
         auto client = wl_resource_get_client(r);
         org_kde_plasma_virtual_desktop_send_removed(r);
         wl_resource_destroy(r);
         wl_client_flush(client);
     }
 }
 
 void PlasmaVirtualDesktopInterface::Private::unbind(wl_resource *resource)
 {
     Private *p = reinterpret_cast<Private*>(wl_resource_get_user_data(resource));
     p->resources.removeAll(resource);
     if (p->resources.isEmpty()) {
         p->q->deleteLater();
     }
 }
 
 void PlasmaVirtualDesktopInterface::Private::createResource(wl_resource *parent, quint32 serial)
 {
     ClientConnection *c = vdm->display()->getConnection(wl_resource_get_client(parent));
     wl_resource *resource = c->createResource(&org_kde_plasma_virtual_desktop_interface, wl_resource_get_version(parent), serial);
     if (!resource) {
         return;
     }
     wl_resource_set_implementation(resource, &s_interface, this, unbind);
     resources << resource;
 
     org_kde_plasma_virtual_desktop_send_id(resource, id.toUtf8().constData());
     if (!name.isEmpty()) {
         org_kde_plasma_virtual_desktop_send_name(resource, name.toUtf8().constData());
     }
 
     if (active) {
         org_kde_plasma_virtual_desktop_send_activated(resource);
     }
 
     c->flush();
 }
 
 PlasmaVirtualDesktopInterface::PlasmaVirtualDesktopInterface(PlasmaVirtualDesktopManagementInterface *parent)
     : QObject(parent),
       d(new Private(this, parent))
 {
 }
 
 PlasmaVirtualDesktopInterface::~PlasmaVirtualDesktopInterface()
 {}
 
 QString PlasmaVirtualDesktopInterface::id() const
 {
     return d->id;
 }
 
 void PlasmaVirtualDesktopInterface::setName(const QString &name)
 {
     if (d->name == name) {
         return;
     }
 
     d->name = name;
     for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_send_name(*it, name.toUtf8().constData());
     }
 }
 
 QString PlasmaVirtualDesktopInterface::name() const
 {
     return d->name;
 }
 
 bool PlasmaVirtualDesktopInterface::active() const
 {
     return d->active;
 }
 
 void PlasmaVirtualDesktopInterface::sendDone()
 {
     for (auto it = d->resources.constBegin(); it != d->resources.constEnd(); ++it) {
         org_kde_plasma_virtual_desktop_send_done(*it);
     }
 }
 
 }
 }