msgpack-rpc: Add remote_ui module

The remote_ui module is an implementation of the UI layer, and it attaches UI
instances that redirect redraw notifications to connected clients.

src/nvim/msgpack_rpc/channel.c

@@ -10,6 +10,7 @@
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/vim.h"
 #include "nvim/msgpack_rpc/channel.h"
+#include "nvim/msgpack_rpc/remote_ui.h"
 #include "nvim/os/event.h"
 #include "nvim/os/rstream.h"
 #include "nvim/os/rstream_defs.h"
@@ -100,6 +101,17 @@ void channel_init(void)
   if (embedded_mode) {
     channel_from_stdio();
   }
+
+  if (abstract_ui) {
+    // Add handler for "attach_ui"
+    remote_ui_init();
+    String method = cstr_as_string("attach_ui");
+    MsgpackRpcRequestHandler handler = {.fn = remote_ui_attach, .defer = true};
+    msgpack_rpc_add_method_handler(method, handler);
+    method = cstr_as_string("detach_ui");
+    handler.fn = remote_ui_detach;
+    msgpack_rpc_add_method_handler(method, handler);
+  }
 }
 
 /// Teardown the module
@@ -645,6 +657,10 @@ static void on_stdio_close(Event e)
 
 static void free_channel(Channel *channel)
 {
+  if (abstract_ui) {
+    remote_ui_disconnect(channel->id);
+  }
+
   pmap_del(uint64_t)(channels, channel->id);
   msgpack_unpacker_free(channel->unpacker);
 

src/nvim/msgpack_rpc/remote_ui.c

@@ -0,0 +1,280 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nvim/vim.h"
+#include "nvim/ui.h"
+#include "nvim/memory.h"
+#include "nvim/map.h"
+#include "nvim/msgpack_rpc/remote_ui.h"
+#include "nvim/msgpack_rpc/channel.h"
+#include "nvim/api/private/defs.h"
+#include "nvim/api/private/helpers.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "msgpack_rpc/remote_ui.c.generated.h"
+#endif
+
+typedef struct {
+  uint64_t channel_id;
+  Array buffer;
+} UIData;
+
+static PMap(uint64_t) *connected_uis = NULL;
+
+void remote_ui_init(void)
+{
+  connected_uis = pmap_new(uint64_t)();
+}
+
+Object remote_ui_attach(uint64_t channel_id, uint64_t request_id, Array args,
+                        Error *error)
+{
+  if (pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(error, Exception, _("UI already attached for channel"));
+    return NIL;
+  }
+
+  if (args.size != 2 || args.items[0].type != kObjectTypeInteger
+      || args.items[1].type != kObjectTypeInteger
+      || args.items[0].data.integer <= 0 || args.items[1].data.integer <= 0) {
+    api_set_error(error, Validation,
+                  _("Arguments must be a pair of positive integers "
+                    "representing the remote screen width/height"));
+    return NIL;
+  }
+  UIData *data = xmalloc(sizeof(UIData));
+  data->channel_id = channel_id;
+  data->buffer = (Array)ARRAY_DICT_INIT;
+  UI *ui = xcalloc(1, sizeof(UI));
+  ui->width = (int)args.items[0].data.integer;
+  ui->height = (int)args.items[1].data.integer;
+  ui->data = data;
+  ui->resize = remote_ui_resize;
+  ui->clear = remote_ui_clear;
+  ui->eol_clear = remote_ui_eol_clear;
+  ui->cursor_goto = remote_ui_cursor_goto;
+  ui->cursor_on = remote_ui_cursor_on;
+  ui->cursor_off = remote_ui_cursor_off;
+  ui->mouse_on = remote_ui_mouse_on;
+  ui->mouse_off = remote_ui_mouse_off;
+  ui->insert_mode = remote_ui_insert_mode;
+  ui->normal_mode = remote_ui_normal_mode;
+  ui->set_scroll_region = remote_ui_set_scroll_region;
+  ui->scroll = remote_ui_scroll;
+  ui->highlight_set = remote_ui_highlight_set;
+  ui->put = remote_ui_put;
+  ui->bell = remote_ui_bell;
+  ui->visual_bell = remote_ui_visual_bell;
+  ui->flush = remote_ui_flush;
+  ui->suspend = remote_ui_suspend;
+  pmap_put(uint64_t)(connected_uis, channel_id, ui);
+  ui_attach(ui);
+
+  return NIL;
+}
+
+Object remote_ui_detach(uint64_t channel_id, uint64_t request_id, Array args,
+                        Error *error)
+{
+  if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(error, Exception, _("UI is not attached for channel"));
+  }
+  remote_ui_disconnect(channel_id);
+
+  return NIL;
+}
+
+void remote_ui_disconnect(uint64_t channel_id)
+{
+  UI *ui = pmap_get(uint64_t)(connected_uis, channel_id);
+  if (!ui) {
+    return;
+  }
+  UIData *data = ui->data;
+  // destroy pending screen updates
+  api_free_array(data->buffer);
+  pmap_del(uint64_t)(connected_uis, channel_id);
+  free(ui->data);
+  ui_detach(ui);
+  free(ui);
+}
+
+static void push_call(UI *ui, char *name, Array args)
+{
+  Array call = ARRAY_DICT_INIT;
+  UIData *data = ui->data;
+
+  // To optimize data transfer(especially for "put"), we bundle adjacent
+  // calls to same method together, so only add a new call entry if the last
+  // method call is different from "name"
+  if (kv_size(data->buffer)) {
+    call = kv_A(data->buffer, kv_size(data->buffer) - 1).data.array;
+  }
+
+  if (!kv_size(call) || strcmp(kv_A(call, 0).data.string.data, name)) {
+    call = (Array)ARRAY_DICT_INIT;
+    ADD(data->buffer, ARRAY_OBJ(call));
+    ADD(call, STRING_OBJ(cstr_to_string(name)));
+  }
+
+  ADD(call, ARRAY_OBJ(args));
+  kv_A(data->buffer, kv_size(data->buffer) - 1).data.array = call;
+}
+
+static void remote_ui_resize(UI *ui, int width, int height)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(width));
+  ADD(args, INTEGER_OBJ(height));
+  push_call(ui, "resize", args);
+}
+
+static void remote_ui_clear(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "clear", args);
+}
+
+static void remote_ui_eol_clear(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "eol_clear", args);
+}
+
+static void remote_ui_cursor_goto(UI *ui, int row, int col)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(row));
+  ADD(args, INTEGER_OBJ(col));
+  push_call(ui, "cursor_goto", args);
+}
+
+static void remote_ui_cursor_on(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "cursor_on", args);
+}
+
+static void remote_ui_cursor_off(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "cursor_off", args);
+}
+
+static void remote_ui_mouse_on(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "mouse_on", args);
+}
+
+static void remote_ui_mouse_off(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "mouse_off", args);
+}
+
+static void remote_ui_insert_mode(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "insert_mode", args);
+}
+
+static void remote_ui_normal_mode(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "normal_mode", args);
+}
+
+static void remote_ui_set_scroll_region(UI *ui, int top, int bot, int left,
+    int right)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(top));
+  ADD(args, INTEGER_OBJ(bot));
+  ADD(args, INTEGER_OBJ(left));
+  ADD(args, INTEGER_OBJ(right));
+  push_call(ui, "set_scroll_region", args);
+}
+
+static void remote_ui_scroll(UI *ui, int count)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(count));
+  push_call(ui, "scroll", args);
+}
+
+static void remote_ui_highlight_set(UI *ui, HlAttrs attrs)
+{
+  Array args = ARRAY_DICT_INIT;
+  Dictionary hl = ARRAY_DICT_INIT;
+
+  if (attrs.bold) {
+    PUT(hl, "bold", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.standout) {
+    PUT(hl, "standout", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.underline) {
+    PUT(hl, "underline", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.undercurl) {
+    PUT(hl, "undercurl", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.italic) {
+    PUT(hl, "italic", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.reverse) {
+    PUT(hl, "reverse", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.foreground != -1) {
+    PUT(hl, "foreground", INTEGER_OBJ(attrs.foreground));
+  }
+
+  if (attrs.background != -1) {
+    PUT(hl, "background", INTEGER_OBJ(attrs.background));
+  }
+
+  ADD(args, DICTIONARY_OBJ(hl));
+  push_call(ui, "highlight_set", args);
+}
+
+static void remote_ui_put(UI *ui, uint8_t *data, size_t size)
+{
+  Array args = ARRAY_DICT_INIT;
+  String str = {.data = xmemdupz(data, size), .size = size};
+  ADD(args, STRING_OBJ(str));
+  push_call(ui, "put", args);
+}
+
+static void remote_ui_bell(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "bell", args);
+}
+
+static void remote_ui_visual_bell(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "visual_bell", args);
+}
+
+static void remote_ui_flush(UI *ui)
+{
+  UIData *data = ui->data;
+  channel_send_event(data->channel_id, "redraw", data->buffer);
+  data->buffer = (Array)ARRAY_DICT_INIT;
+}
+
+static void remote_ui_suspend(UI *ui)
+{
+  UIData *data = ui->data;
+  remote_ui_disconnect(data->channel_id);
+}

src/nvim/msgpack_rpc/remote_ui.h

@@ -0,0 +1,9 @@
+#ifndef NVIM_MSGPACK_RPC_REMOTE_UI_H
+#define NVIM_MSGPACK_RPC_REMOTE_UI_H
+
+#include "nvim/ui.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "msgpack_rpc/remote_ui.h.generated.h"
+#endif
+#endif  // NVIM_MSGPACK_RPC_REMOTE_UI_H