2 files changed, 152 insertions, 24 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 2c2e8a024f..66c4454f7b 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -1430,6 +1430,18 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id,
 ///                 - "eol": right after eol character (default)
 ///                 - "overlay": display over the specified column, without
 ///                              shifting the underlying text.
+///               - virt_text_hide : hide the virtual text when the background
+///                                  text is selected or hidden due to
+///                                  horizontal scroll 'nowrap'
+///               - hl_mode : control how highlights are combined with the
+///                           highlights of the text. Currently only affects
+///                           virt_text highlights, but might affect `hl_group`
+///                           in later versions.
+///                 - "replace": only show the virt_text color. This is the
+///                              default
+///                 - "combine": combine with background text color
+///                 - "blend": blend with background text color.
+///
 ///               - ephemeral : for use with |nvim_set_decoration_provider|
 ///                   callbacks. The mark will only be used for the current
 ///                   redraw cycle, and not be permantently stored in the
@@ -1477,11 +1489,10 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
   bool ephemeral = false;
 
   uint64_t id = 0;
-  int line2 = -1, hl_id = 0;
-  DecorPriority priority = DECOR_PRIORITY_BASE;
+  int line2 = -1;
+  Decoration decor = DECORATION_INIT;
   colnr_T col2 = -1;
-  VirtText virt_text = KV_INITIAL_VALUE;
-  VirtTextPos virt_text_pos = kVTEndOfLine;
+
   bool right_gravity = true;
   bool end_right_gravity = false;
   bool end_gravity_set = false;
@@ -1528,12 +1539,12 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
       switch (v->type) {
         case kObjectTypeString:
           hl_group = v->data.string;
-          hl_id = syn_check_group(
+          decor.hl_id = syn_check_group(
               (char_u *)(hl_group.data),
               (int)hl_group.size);
           break;
         case kObjectTypeInteger:
-          hl_id = (int)v->data.integer;
+          decor.hl_id = (int)v->data.integer;
           break;
         default:
           api_set_error(err, kErrorTypeValidation,
@@ -1546,7 +1557,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
                       "virt_text is not an Array");
         goto error;
       }
-      virt_text = parse_virt_text(v->data.array, err);
+      decor.virt_text = parse_virt_text(v->data.array, err);
       if (ERROR_SET(err)) {
         goto error;
       }
@@ -1558,9 +1569,33 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
       }
       String str = v->data.string;
       if (strequal("eol", str.data)) {
-        virt_text_pos = kVTEndOfLine;
+        decor.virt_text_pos = kVTEndOfLine;
       } else if (strequal("overlay", str.data)) {
-        virt_text_pos = kVTOverlay;
+        decor.virt_text_pos = kVTOverlay;
+      } else {
+        api_set_error(err, kErrorTypeValidation,
+                      "virt_text_pos: invalid value");
+        goto error;
+      }
+    } else if (strequal("virt_text_hide", k.data)) {
+      decor.virt_text_hide = api_object_to_bool(*v,
+                                                "virt_text_hide", false, err);
+      if (ERROR_SET(err)) {
+        goto error;
+      }
+    } else if (strequal("hl_mode", k.data)) {
+      if (v->type != kObjectTypeString) {
+        api_set_error(err, kErrorTypeValidation,
+                      "hl_mode is not a String");
+        goto error;
+      }
+      String str = v->data.string;
+      if (strequal("replace", str.data)) {
+        decor.hl_mode = kHlModeReplace;
+      } else if (strequal("combine", str.data)) {
+        decor.hl_mode = kHlModeCombine;
+      } else if (strequal("blend", str.data)) {
+        decor.hl_mode = kHlModeBlend;
       } else {
         api_set_error(err, kErrorTypeValidation,
                       "virt_text_pos: invalid value");
@@ -1583,7 +1618,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
                       "priority is not a valid value");
         goto error;
       }
-      priority = (DecorPriority)v->data.integer;
+      decor.priority = (DecorPriority)v->data.integer;
     } else if (strequal("right_gravity", k.data)) {
       if (v->type != kObjectTypeBoolean) {
         api_set_error(err, kErrorTypeValidation,
@@ -1631,23 +1666,23 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
     col2 = 0;
   }
 
-  Decoration *decor = NULL, tmp = { 0 };
+  Decoration *d = NULL;
 
-  if (kv_size(virt_text) || priority != DECOR_PRIORITY_BASE) {
+  if (ephemeral) {
+    d = &decor;
+  } else if (kv_size(decor.virt_text)
+             || decor.priority != DECOR_PRIORITY_BASE) {
     // TODO(bfredl): this is a bit sketchy. eventually we should
     // have predefined decorations for both marks/ephemerals
-    decor = ephemeral ? &tmp : xcalloc(1, sizeof(*decor));
-    decor->hl_id = hl_id;
-    decor->virt_text = virt_text;
-    decor->priority = priority;
-    decor->virt_text_pos = virt_text_pos;
-  } else if (hl_id) {
-    decor = decor_hl(hl_id);
+    d = xcalloc(1, sizeof(*d));
+    *d = decor;
+  } else if (decor.hl_id) {
+    d = decor_hl(decor.hl_id);
   }
 
   // TODO(bfredl): synergize these two branches even more
   if (ephemeral && decor_state.buf == buf) {
-    decor_add_ephemeral((int)line, (int)col, line2, col2, decor, 0);
+    decor_add_ephemeral((int)line, (int)col, line2, col2, &decor, 0);
   } else {
     if (ephemeral) {
       api_set_error(err, kErrorTypeException, "not yet implemented");
@@ -1655,14 +1690,14 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
     }
 
     id = extmark_set(buf, (uint64_t)ns_id, id, (int)line, (colnr_T)col,
-                     line2, col2, decor, right_gravity,
+                     line2, col2, d, right_gravity,
                      end_right_gravity, kExtmarkNoUndo);
   }
 
   return (Integer)id;
 
 error:
-  clear_virttext(&virt_text);
+  clear_virttext(&decor.virt_text);
   return 0;
 }
 
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 586123aac1..6358f35d0a 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -39,6 +39,7 @@
 #include "nvim/eval/typval.h"
 #include "nvim/eval/userfunc.h"
 #include "nvim/fileio.h"
+#include "nvim/move.h"
 #include "nvim/ops.h"
 #include "nvim/option.h"
 #include "nvim/state.h"
@@ -241,8 +242,7 @@ void nvim_set_hl(Integer ns_id, String name, Dictionary val, Error *err)
 ///
 /// @param ns_id the namespace to activate
 /// @param[out] err Error details, if any
-void nvim_set_hl_ns(Integer ns_id, Error *err)
-  FUNC_API_SINCE(7)
+void nvim__set_hl_ns(Integer ns_id, Error *err)
   FUNC_API_FAST
 {
   if (ns_id >= 0) {
@@ -1246,6 +1246,99 @@ fail:
   return 0;
 }
 
+/// Open a terminal instance in a buffer
+///
+/// By default (and currently the only option) the terminal will not be
+/// connected to an external process. Instead, input send on the channel
+/// will be echoed directly by the terminal. This is useful to disply
+/// ANSI terminal sequences returned as part of a rpc message, or similar.
+///
+/// Note: to directly initiate the terminal using the right size, display the
+/// buffer in a configured window before calling this. For instance, for a
+/// floating display, first create an empty buffer using |nvim_create_buf()|,
+/// then display it using |nvim_open_win()|, and then  call this function.
+/// Then |nvim_chan_send()| cal be called immediately to process sequences
+/// in a virtual terminal having the intended size.
+///
+/// @param buffer the buffer to use (expected to be empty)
+/// @param opts   Optional parameters. Reserved for future use.
+/// @param[out] err Error details, if any
+Integer nvim_open_term(Buffer buffer, Dictionary opts, Error *err)
+  FUNC_API_SINCE(7)
+{
+  buf_T *buf = find_buffer_by_handle(buffer, err);
+  if (!buf) {
+    return 0;
+  }
+
+  if (opts.size > 0) {
+    api_set_error(err, kErrorTypeValidation, "opts dict isn't empty");
+    return 0;
+  }
+
+  TerminalOptions topts;
+  Channel *chan = channel_alloc(kChannelStreamInternal);
+  topts.data = chan;
+  // NB: overriden in terminal_check_size if a window is already
+  // displaying the buffer
+  topts.width = (uint16_t)MAX(curwin->w_width_inner - win_col_off(curwin), 0);
+  topts.height = (uint16_t)curwin->w_height_inner;
+  topts.write_cb = term_write;
+  topts.resize_cb = term_resize;
+  topts.close_cb = term_close;
+  Terminal *term = terminal_open(buf, topts);
+  terminal_check_size(term);
+  chan->term = term;
+  channel_incref(chan);
+  return (Integer)chan->id;
+}
+
+static void term_write(char *buf, size_t size, void *data)
+{
+  // TODO(bfredl): lua callback
+}
+
+static void term_resize(uint16_t width, uint16_t height, void *data)
+{
+  // TODO(bfredl): lua callback
+}
+
+static void term_close(void *data)
+{
+  Channel *chan = data;
+  terminal_destroy(chan->term);
+  chan->term = NULL;
+  channel_decref(chan);
+}
+
+
+/// Send data to channel `id`. For a job, it writes it to the
+/// stdin of the process. For the stdio channel |channel-stdio|,
+/// it writes to Nvim's stdout.  For an internal terminal instance
+/// (|nvim_open_term()|) it writes directly to terimal output.
+/// See |channel-bytes| for more information.
+///
+/// This function writes raw data, not RPC messages.  If the channel
+/// was created with `rpc=true` then the channel expects RPC
+/// messages, use |vim.rpcnotify()| and |vim.rpcrequest()| instead.
+///
+/// @param chan id of the channel
+/// @param data data to write. 8-bit clean: can contain NUL bytes.
+/// @param[out] err Error details, if any
+void nvim_chan_send(Integer chan, String data, Error *err)
+  FUNC_API_SINCE(7) FUNC_API_REMOTE_ONLY FUNC_API_LUA_ONLY
+{
+  const char *error = NULL;
+  if (!data.size) {
+    return;
+  }
+
+  channel_send((uint64_t)chan, data.data, data.size, &error);
+  if (error) {
+    api_set_error(err, kErrorTypeValidation, "%s", error);
+  }
+}
+
 /// Open a new window.
 ///
 /// Currently this is used to open floating and external windows.