diff --git a/inc/lektor/commands.h b/inc/lektor/commands.h
index 37d6378f22af87e88a165eb33cdda9cc5545a315..34201ae7f36b9bc65a53827a0e52e73b532cdb1d 100644
--- a/inc/lektor/commands.h
+++ b/inc/lektor/commands.h
@@ -18,35 +18,35 @@ bool command_currentsong(struct lkt_state *srv, size_t c);
 bool command_status     (struct lkt_state *srv, size_t c);
 
 /* Controlling playback */
-bool command_next    (struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_pause   (struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_previous(struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_play    (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_stop    (struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
+bool command_next    (struct lkt_state *srv);
+bool command_pause   (struct lkt_state *srv);
+bool command_previous(struct lkt_state *srv);
+bool command_play    (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_stop    (struct lkt_state *srv);
 
-bool command_set_pos(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr, int index);
+bool command_set_pos(struct lkt_state *srv, int index);
 
 /* The queue */
-bool command_add    (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr, int priority);
-bool command_addid  (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_delid  (struct lkt_state *srv, char *id,                         mpd_idle_flag *watch_mask_ptr);
-bool command_clear  (struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_crop   (struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_move   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX],                      mpd_idle_flag *watch_mask_ptr);
-bool command_shuffle(struct lkt_state *srv,                                   mpd_idle_flag *watch_mask_ptr);
-bool command_playid (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_dump   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
+bool command_add    (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], int priority);
+bool command_addid  (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_delid  (struct lkt_state *srv, char *id);
+bool command_clear  (struct lkt_state *srv);
+bool command_crop   (struct lkt_state *srv);
+bool command_move   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_shuffle(struct lkt_state *srv);
+bool command_playid (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_dump   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
 
 bool command_queue_list(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX]);
 
 /* The playlists */
-bool command_plt_create(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_remove(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_clear (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_rename(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_export(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_import(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
-bool command_plt_add   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr);
+bool command_plt_create(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_remove(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_clear (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_rename(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_export(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_import(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_add   (struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX]);
 
 /* The help */
 bool command_help(struct lkt_state *srv, size_t c);
diff --git a/src/commands.c b/src/commands.c
index 6540ac09182b007f7e20798f12327910a453d43f..5a6c19b8efb5e31728e9b5bdbeaed1e40f229a49 100644
--- a/src/commands.c
+++ b/src/commands.c
@@ -162,9 +162,9 @@ command_status(struct lkt_state *srv, size_t c)
 }
 
 bool
-command_next(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_next(struct lkt_state *srv)
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
     if (!database_queue_next(srv->db, filepath))
         return false;
@@ -172,18 +172,18 @@ command_next(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
 }
 
 bool
-command_pause(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_pause(struct lkt_state *srv)
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     if (!database_queue_toggle_pause(srv->db))
         return false;
     return ! MOD_CALL(srv->window_mod, "toggle", 1);
 }
 
 bool
-command_previous(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_previous(struct lkt_state *srv)
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
     if (!database_queue_prev(srv->db, filepath))
         return false;
@@ -202,9 +202,8 @@ __play_that_file(struct lkt_state *win, int pos)
 }
 
 bool
-command_play(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_play(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char *endptr, err;
     long pos = 1;
 
@@ -218,21 +217,21 @@ command_play(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_f
     database_queue_stop(srv->db);
     RETURN_UNLESS(MOD_CALL(srv->window_mod, "new", srv->queue, srv->db),
                   "Can't create window", false);
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return __play_that_file(srv, pos);
 }
 
 bool
-command_dump(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_dump(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args[0], "Invalid argument", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_queue_dump(srv->db, args[0]);
 }
 
 bool
-command_playid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_playid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char *endptr, err;
     int pos = 0;
     long id;
@@ -244,6 +243,7 @@ command_playid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle
 
     /* Do the work. */
     database_queue_stop(srv->db);
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     RETURN_IF(MOD_CALL(srv->window_mod, "new", &srv->queue, srv->db),
               "Can't create window", false);
     database_queue_seekid(srv->db, (int) id, &pos);
@@ -252,24 +252,23 @@ command_playid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle
 
 
 bool
-command_stop(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_stop(struct lkt_state *srv)
 {
     RETURN_UNLESS(database_queue_stop(srv->db), "DB error", false);
     MOD_CALL(srv->window_mod, "close", 1);
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX],
-            mpd_idle_flag *watch_mask_ptr, int priority)
+command_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], int priority)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
     struct lkt_uri uri;
     int ret;        /* To be modified according to the command (insert or add) later (TODO) */
     RETURN_UNLESS(lkt_uri_from(&uri, args[0]), "Failed to parse query", false);
     ret = database_queue_add_uri(srv->db, &uri, priority);
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     lkt_uri_free(&uri);
     if (!ret)
         LOG_ERROR("COMMAND", "Failed to add with priority %d in queue", priority);
@@ -277,8 +276,7 @@ command_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX],
 }
 
 bool
-command_addid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX],
-              mpd_idle_flag *watch_mask_ptr)
+command_addid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args, "Invalid argument", false);
     errno = 0;
@@ -286,26 +284,26 @@ command_addid(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX],
     struct lkt_uri uri = { .type = uri_id };
     for (i = 0; (uri.id = strtol(args[i], NULL, 0)) && ! errno; ++i)
         errno |= database_queue_add_id(srv->db, uri.id, 1);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return ! errno;
 }
 
 inline bool
-command_clear(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_clear(struct lkt_state *srv)
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_queue_clear(srv->db);
 }
 
 inline bool
-command_crop(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_crop(struct lkt_state *srv)
 {
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_queue_crop(srv->db);
 }
 
 bool
-command_delid(struct lkt_state *srv, char *id_str, mpd_idle_flag *watch_mask_ptr)
+command_delid(struct lkt_state *srv, char *id_str)
 {
     long id;
     char *endptr = NULL, err = 0, filepath[PATH_MAX];
@@ -330,18 +328,17 @@ command_delid(struct lkt_state *srv, char *id_str, mpd_idle_flag *watch_mask_ptr
         }
     }
 
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_queue_del_id(srv->db, id);
 }
 
 bool
-command_move(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_move(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     long from, to;
     char *endptr, err;
 
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
 
     /* First argument: from */
     STRTOL(from, args[0], endptr, err);
@@ -351,6 +348,7 @@ command_move(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_f
     STRTOL(to, args[1], endptr, err);
     RETURN_IF(err, "STRTOL failed", false);
 
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_queue_move(srv->db, from, to);
 }
 
@@ -568,17 +566,17 @@ command_set_playback_option(struct lkt_state *srv, size_t c, enum lkt_playback_o
 }
 
 bool
-command_set_pos(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr, int index)
+command_set_pos(struct lkt_state *srv, int index)
 {
     char filepath[PATH_MAX];
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     RETURN_UNLESS(database_queue_set_current_index(srv->db, index), "Failed to set position in queue", false);
     RETURN_UNLESS(database_queue_get_current_file(srv->db, filepath), "Failed to get filename", false);
     return ! MOD_CALL(srv->window_mod, "load_file", filepath);
 }
 
 bool
-command_plt_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
 
@@ -605,73 +603,73 @@ end_plt_add_uri:
     }
 
     if (ret)
-        *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+        srv->mpd_idle_events |= MPD_IDLE_PLAYER;
 
     return ret;
 }
 
 bool
-command_plt_remove(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_remove(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     char *endptr, err;
     long pos;
 
     if (args[1] == NULL) {
-        *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+        srv->mpd_idle_events |= MPD_IDLE_PLAYLIST;
         return database_plt_remove(srv->db, args[0]);
     }
 
     STRTOL(pos, args[1], endptr, err);
     RETURN_IF(err, "STRTOL failed", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return database_plt_remove_pos(srv->db, args[0], pos);
 }
 
 bool
-command_plt_clear(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_clear(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     RETURN_UNLESS(database_plt_clear(srv->db, args[0]), "Failed to clear playlist", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_plt_rename(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_rename(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_plt_rename(srv->db, args[0], args[1]), "Failed to rename playlist", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_plt_export(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_export(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(srv->db, args[0], args[1]), "Failed to attach database", false);
     RETURN_UNLESS(database_plt_export(srv->db, args[0]), "Failed to export playlist", false);
     RETURN_UNLESS(database_detach(srv->db, args[0]), "Failed to detach database", false);
     LOG_INFO("COMMAND", "Exported playlist %s with path '%s'", args[0], args[1]);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_plt_import(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_import(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(srv->db, args[0], args[1]), "Failed to attach database", false);
     RETURN_UNLESS(database_plt_import(srv->db, args[0]), "Failed to import playlist", false);
     RETURN_UNLESS(database_detach(srv->db, args[0]), "Failed to detach playlist", false);
     LOG_INFO("COMMAND", "Imported playlist %s with path '%s'", args[0], args[1]);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_plt_add_uri(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
+command_plt_add_uri(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     struct lkt_uri uri;
@@ -679,15 +677,15 @@ command_plt_add_uri(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], mpd
     bool ret = database_plt_add_uri(srv->db, args[0], &uri);
     lkt_uri_free(&uri);
     RETURN_UNLESS(ret, "Failed to add uri to plt", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
 bool
-command_shuffle(struct lkt_state *srv, mpd_idle_flag *watch_mask_ptr)
+command_shuffle(struct lkt_state *srv)
 {
     RETURN_UNLESS(database_queue_shuffle(srv->db), "Failed to shuffle", false);
-    *watch_mask_ptr |= MPD_IDLE_PLAYER;
+    srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     return true;
 }
 
diff --git a/src/net/listen.c b/src/net/listen.c
index 761ca87e171ff81e3ca5ad2989cd824575837b98..18183cbbda2482dfd4dafdbb7f2c7298a5e9389e 100644
--- a/src/net/listen.c
+++ b/src/net/listen.c
@@ -177,25 +177,25 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
             err = 0;
 
         else if (STR_MATCH(cmd.name, "next"))
-            err = !command_next(srv, &srv->mpd_idle_events);
+            err = !command_next(srv);
         else if (STR_MATCH(cmd.name, "pause"))
-            err = !command_pause(srv, &srv->mpd_idle_events);
+            err = !command_pause(srv);
         else if (STR_MATCH(cmd.name, "previous"))
-            err = !command_previous(srv, &srv->mpd_idle_events);
+            err = !command_previous(srv);
         else if (STR_MATCH(cmd.name, "play"))
-            err = ! command_play(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_play(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "playid"))
-            err = ! command_playid(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_playid(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "stop"))
-            err = !command_stop(srv, &srv->mpd_idle_events);
+            err = !command_stop(srv);
         else if (STR_MATCH(cmd.name, "clear"))
-            err = !command_clear(srv, &srv->mpd_idle_events);
+            err = !command_clear(srv);
         else if (STR_MATCH(cmd.name, "crop"))
-            err = !command_crop(srv, &srv->mpd_idle_events);
+            err = !command_crop(srv);
         else if (STR_MATCH(cmd.name, "moveid"))
-            err = !command_move(srv, cmd.args, &srv->mpd_idle_events);
+            err = !command_move(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "shuffle"))
-            err = !command_shuffle(srv, &srv->mpd_idle_events);
+            err = !command_shuffle(srv);
 
         else if (STR_MATCH(cmd.name, "playlist") || STR_MATCH(cmd.name, "playlistinfo"))
             err = !command_queue_list(srv, c, cmd.args);
@@ -217,33 +217,33 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
             err = !command_help(srv, c);
 
         else if (STR_MATCH(cmd.name, "__insert"))
-            err = ! command_add(srv, cmd.args, &srv->mpd_idle_events, 5);
+            err = ! command_add(srv, cmd.args, 5);
         else if (STR_MATCH(cmd.name, "searchadd")   ||
                  STR_MATCH(cmd.name, "findadd")     ||
                  STR_MATCH(cmd.name, "add"))
-            err = ! command_add(srv, cmd.args, &srv->mpd_idle_events, 1);
+            err = ! command_add(srv, cmd.args, 1);
         else if (STR_MATCH(cmd.name, "addid"))
-            err = ! command_addid(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_addid(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "deleteid"))
             err = ! (cmd.args[0] != NULL &&
-                     command_delid(srv, cmd.args[0], &srv->mpd_idle_events));
+                     command_delid(srv, cmd.args[0]));
 
         else if (STR_MATCH(cmd.name, "playlistclear"))
-            err = ! command_plt_clear(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_clear(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "rename"))
-            err = ! command_plt_rename(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_rename(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "playlistdelete"))
-            err = ! command_plt_remove(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_remove(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "playlistadd"))
-            err = ! command_plt_add(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_add(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "rm") && cmd.args[0] != NULL && cmd.args[1] == NULL)
-            err = ! command_plt_remove(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_remove(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "save"))
-            err = ! command_plt_export(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_export(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "__import"))
-            err = ! command_plt_import(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_import(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "__dump"))
-            err = ! command_dump(srv, cmd.args, &srv->mpd_idle_events);
+            err = ! command_dump(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "listplaylist"))
             err = ! command_find(srv, c, cmd.args, cmd.cont, database_search_playlist_init);
 
@@ -725,16 +725,16 @@ redo:
         if (NULL == (string = malloc(BUFFER_MAX * sizeof(char))))
             return;
         safe_snprintf(string, BUFFER_MAX, "%ld", (size_t) evt.attr);
-        command_play(srv, &string, &srv->mpd_idle_events);
+        command_play(srv, &string);
         free(string);
         break;
 
     case lkt_event_play_next:
-        command_next(srv, &srv->mpd_idle_events);
+        command_next(srv);
         break;
 
     case lkt_event_play_prev:
-        command_previous(srv, &srv->mpd_idle_events);
+        command_previous(srv);
         break;
 
     case lkt_event_play_toggle: