Modules

Define properly modules.

Modules should only use the queue to communicate information to the lkt_state.

The lkt_state should use the reg to get function pointers and other properties from the modules. This reg will include macros to get function pointers and call the function with the given arguments. The reg will notify when a function is not available, and won't segfault. By doing so:

• Some modules (player, repo) won't be necessary to launch lektord. The server can be launched even if some functionalities are not here.
• Simplify the modules information in the lektor.ini file.
• It will be possible to unload and load modules on the fly.
• Events from the lkt_state queue can be differed to when the module is loaded.

src/net/listen.c

@@ -50,12 +50,6 @@ struct lkt_client {
     int continuation;
 };
 
-void
-lkt_set_event_available(struct lkt_state *srv, enum lkt_event_type type)
-{
-    lkt_queue_make_available(&srv->queue, type);
-}
-
 static inline bool
 lkt_close_client(struct lkt_state *srv, size_t c)
 {
@@ -183,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->db, &srv->win, &srv->mpd_idle_events);
+            err = !command_next(srv);
         else if (STR_MATCH(cmd.name, "pause"))
-            err = !command_pause(srv->db, &srv->win, &srv->mpd_idle_events);
+            err = !command_pause(srv);
         else if (STR_MATCH(cmd.name, "previous"))
-            err = !command_previous(srv->db, &srv->win, &srv->mpd_idle_events);
+            err = !command_previous(srv);
         else if (STR_MATCH(cmd.name, "play"))
-            err = ! command_play(srv->db, &srv->win, cmd.args, &srv->mpd_idle_events);
+            err = ! command_play(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "playid"))
-            err = ! command_playid(srv->db, &srv->win, cmd.args, &srv->mpd_idle_events);
+            err = ! command_playid(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "stop"))
-            err = !command_stop(srv->db, &srv->win, &srv->mpd_idle_events);
+            err = !command_stop(srv);
         else if (STR_MATCH(cmd.name, "clear"))
-            err = !command_clear(srv->db, &srv->mpd_idle_events);
+            err = !command_clear(srv);
         else if (STR_MATCH(cmd.name, "crop"))
-            err = !command_crop(srv->db, &srv->mpd_idle_events);
+            err = !command_crop(srv);
         else if (STR_MATCH(cmd.name, "moveid"))
-            err = !command_move(srv->db, cmd.args, &srv->mpd_idle_events);
+            err = !command_move(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "shuffle"))
-            err = !command_shuffle(srv->db, &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);
@@ -223,37 +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->db, &srv->win, 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->db, &srv->win, 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->db, &srv->win, 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->db, &srv->win, 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->db, 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->db, 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->db, 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->db, 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->db, 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->db, 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->db, cmd.args, &srv->mpd_idle_events);
+            err = ! command_plt_import(srv, cmd.args);
         else if (STR_MATCH(cmd.name, "__dump"))
-            err = ! command_dump(srv->db, 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);
 
@@ -726,21 +716,62 @@ static inline void
 handle_queue_events(struct lkt_state *srv)
 {
     lkt_event evt;
-    char *string = malloc(BUFFER_MAX * sizeof(char));
-    if (!string)
-        return;
+    char *string = NULL;
 redo:
     evt = lkt_queue_handle(&srv->queue);
 
     switch (evt.type) {
     case lkt_event_play_pos:
+        if (NULL == (string = malloc(BUFFER_MAX * sizeof(char))))
+            return;
         safe_snprintf(string, BUFFER_MAX, "%ld", (size_t) evt.attr);
-        command_play(srv->db, &srv->win, &string, &srv->mpd_idle_events);
+        command_play(srv, &string);
+        free(string);
+        break;
+
+    case lkt_event_play_next:
+        command_next(srv);
+        break;
+
+    case lkt_event_play_prev:
+        command_previous(srv);
+        break;
+
+    case lkt_event_play_toggle:
+        switch ((size_t) evt.attr) {
+        case _LKT_PLAY_PAUSE:
+        case _LKT_PLAY_PLAY:
+        case _LKT_PLAY_TOGGLE:
+            database_queue_toggle_pause(srv->db);
+            break;
+        case _LKT_PLAY_STOP:
+            database_queue_stop(srv->db);
+            break;
+        }
+        break;
+
+    case lkt_event_prop_vol:
+        database_config_queue(srv->db, "volume", (size_t) evt.attr);
+        break;
+
+    case lkt_event_prop_dur:
+        database_config_queue(srv->db, "duration", (size_t) evt.attr);
+        break;
+
+    case lkt_event_prop_time:
+        database_config_queue(srv->db, "elapsed", (size_t) evt.attr);
+        break;
+
+    case lkt_event_skip_current:
+        if (NULL == (string = malloc(PATH_MAX * sizeof(char))))
+            return;
+        database_queue_skip_current(srv->db, string);
+        MOD_CALL(srv->window_mod, "load", string);
+        free(string);
         break;
 
     case lkt_event_null:
     default:
-        free(string);
         return;
     }
     goto redo;
@@ -766,7 +797,6 @@ lkt_listen(struct lkt_state *srv)
             break;
         if (handle_idle_events(srv) < 0)
             break;
-        srv->win.handle_events(&srv->win, srv->db, &srv->mpd_idle_events);
         handle_queue_events(srv);
     }
 }