Merge pull request #61 from akermu/update_libvterm

Update libvterm

8 files changed, 234 insertions, 191 deletions

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/.gitmodules
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 521ce54..06edb6a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,27 +1,8 @@
 cmake_minimum_required(VERSION 3.0.2)
+include(ExternalProject)
 
 project(emacs-libvterm C)
 
-# Look for the header file.
-find_path(LIBVTERM_INCLUDE_DIR NAMES
-  vterm.h
-  )
-
-if(NOT LIBVTERM_INCLUDE_DIR)
-  message(FATAL_ERROR "vterm.h not found")
-endif()
-
-find_library(LIBVTERM_LIBRARY NAMES
-  vterm
-  libvterm
-  )
-
-if(NOT LIBVTERM_LIBRARY)
-  message(FATAL_ERROR "libvterm not found")
-endif()
-
-include_directories(${LIBVTERM_INCLUDE_DIR})
-
 add_library(vterm-module MODULE vterm-module.c utf8.c elisp.c)
 set_target_properties(vterm-module PROPERTIES
   C_STANDARD 99
@@ -30,6 +11,45 @@ set_target_properties(vterm-module PROPERTIES
   LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}
   )
 
+# Look for the header file.
+option(USE_SYSTEM_LIBVTERM "Use system libvterm instead of the vendored version." OFF)
+
+if(USE_SYSTEM_LIBVTERM)
+  find_path(LIBVTERM_INCLUDE_DIR NAMES
+    vterm.h
+    )
+
+  if(NOT LIBVTERM_INCLUDE_DIR)
+    message(FATAL_ERROR "vterm.h not found")
+  endif()
+
+  find_library(LIBVTERM_LIBRARY NAMES
+    vterm
+    libvterm
+    )
+
+  if(NOT LIBVTERM_LIBRARY)
+    message(FATAL_ERROR "libvterm not found")
+  endif()
+else()
+  ExternalProject_add(libvterm
+    GIT_REPOSITORY https://github.com/neovim/libvterm.git
+    GIT_TAG a6293a0e033e7e86c74889b4527787993656883a
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND make "CFLAGS='-fPIC'"
+    BUILD_IN_SOURCE ON
+    INSTALL_COMMAND "")
+
+  ExternalProject_Get_property(libvterm SOURCE_DIR)
+
+  set(LIBVTERM_INCLUDE_DIR ${SOURCE_DIR}/include)
+  set(LIBVTERM_LIBRARY ${SOURCE_DIR}/.libs/libvterm.a)
+
+  add_dependencies(vterm-module libvterm)
+endif()
+
+include_directories(${LIBVTERM_INCLUDE_DIR})
+
 # Link with libvterm
 target_link_libraries(vterm-module ${LIBVTERM_LIBRARY})
 
diff --git a/README.md b/README.md
index 454d4ab..d7fb825 100644
--- a/README.md
+++ b/README.md
@@ -10,21 +10,7 @@ report a bug!
 
 # Installation
 
-First, you need to have `libvterm` installed in your system.
-
-**On Ubuntu / Debian:**
-
-```
-sudo apt-get install libvterm-dev
-```
-
-**On macOS:**
-
-```
-brew install libvterm
-```
-
-Then clone the repository:
+Clone the repository:
 
 ```
 git clone https://github.com/akermu/emacs-libvterm.git
@@ -79,7 +65,7 @@ Open a terminal in another window.
 
 Shell to run in a new vterm. Defaults to `$SHELL`.
 
-# Keybindings
+## Keybindings
 
 If you want a key to be send to the terminal bind it to `vterm--self-insert`,
 otherwise remove it from `vterm-mode-map`. By default vterm.el binds most of the
@@ -92,12 +78,19 @@ bound to `C-c C-c`.
 Set the `:foreground` and `:background` attributes of the following faces to a
 color you like:
 
-- vterm
-- vterm-color-black
-- vterm-color-red
-- vterm-color-green
-- vterm-color-yellow
-- vterm-color-blue
-- vterm-color-magenta
-- vterm-color-cyan
-- vterm-color-white
+- vterm-color-default-fg
+- vterm-color-default-bg
+- vterm-color-black-fg
+- vterm-color-black-bg
+- vterm-color-red-fg
+- vterm-color-green-bg
+- vterm-color-green-fg
+- vterm-color-yellow-bg
+- vterm-color-blue-fg
+- vterm-color-blue-bg
+- vterm-color-magenta-fg
+- vterm-color-magenta-bg
+- vterm-color-cyan-fg
+- vterm-color-cyan-bg
+- vterm-color-white-fg
+- vterm-color-white-bg
diff --git a/elisp.c b/elisp.c
index 69599ae..4de63e2 100644
--- a/elisp.c
+++ b/elisp.c
@@ -18,6 +18,10 @@ void provide(emacs_env *env, const char *feature) {
   env->funcall(env, Qprovide, 1, (emacs_value[]){Qfeat});
 }
 
+emacs_value symbol_value(emacs_env *env, emacs_value symbol) {
+  env->funcall(env, Fsymbol_value, 1, (emacs_value[]){symbol});
+}
+
 int string_bytes(emacs_env *env, emacs_value string) {
   ptrdiff_t size = 0;
   env->copy_string_contents(env, string, NULL, &size);
@@ -28,10 +32,14 @@ emacs_value string_length(emacs_env *env, emacs_value string) {
   return env->funcall(env, Flength, 1, (emacs_value[]){string});
 }
 
-emacs_value list(emacs_env *env, emacs_value *elements, ptrdiff_t len) {
+emacs_value list(emacs_env *env, emacs_value elements[], ptrdiff_t len) {
   return env->funcall(env, Flist, len, elements);
 }
 
+emacs_value append(emacs_env *env, emacs_value lists[], ptrdiff_t count) {
+  return env->funcall(env, Fappend, count, lists);
+}
+
 void put_text_property(emacs_env *env, emacs_value string, emacs_value property,
                        emacs_value value) {
   emacs_value start = env->make_integer(env, 0);
@@ -41,40 +49,6 @@ void put_text_property(emacs_env *env, emacs_value string, emacs_value property,
                (emacs_value[]){start, end, property, value, string});
 }
 
-void byte_to_hex(uint8_t byte, char *hex) { snprintf(hex, 3, "%.2X", byte); }
-
-emacs_value color_to_rgb_string(emacs_env *env, VTermColor color) {
-  char buffer[8];
-  buffer[0] = '#';
-  buffer[7] = '\0';
-  byte_to_hex(color.red, buffer + 1);
-  byte_to_hex(color.green, buffer + 3);
-  byte_to_hex(color.blue, buffer + 5);
-
-  return env->make_string(env, buffer, 7);
-};
-
-uint8_t hex_to_byte(char *hex) { return strtoul(hex, NULL, 16); }
-
-VTermColor rgb_string_to_color(emacs_env *env, emacs_value string) {
-  VTermColor color;
-  ptrdiff_t len = 8;
-  char buffer[len];
-  char hex[3];
-  env->copy_string_contents(env, string, buffer, &len);
-  hex[0] = buffer[1];
-  hex[1] = buffer[2];
-  color.red = hex_to_byte(hex);
-  hex[0] = buffer[3];
-  hex[1] = buffer[4];
-  color.green = hex_to_byte(hex);
-  hex[0] = buffer[5];
-  hex[1] = buffer[6];
-  color.blue = hex_to_byte(hex);
-
-  return color;
-};
-
 void erase_buffer(emacs_env *env) { env->funcall(env, Ferase_buffer, 0, NULL); }
 
 void insert(emacs_env *env, emacs_value string) {
diff --git a/elisp.h b/elisp.h
index 07fc6d5..8eef6ab 100644
--- a/elisp.h
+++ b/elisp.h
@@ -17,14 +17,21 @@ emacs_value Qunderline;
 emacs_value Qslant;
 emacs_value Qreverse;
 emacs_value Qstrike;
+emacs_value Qinherited;
 emacs_value Qface;
 emacs_value Qcursor_type;
+emacs_value Qvterm_color_default_fg;
+emacs_value Qvterm_color_default_bg;
+emacs_value Qvterm_color_palette_fg;
+emacs_value Qvterm_color_palette_bg;
 
 // Emacs functions
+emacs_value Fsymbol_value;
 emacs_value Flength;
 emacs_value Flist;
 emacs_value Ferase_buffer;
 emacs_value Finsert;
+emacs_value Fappend;
 emacs_value Fgoto_char;
 emacs_value Fforward_char;
 emacs_value Fforward_line;
@@ -45,15 +52,13 @@ emacs_value Fvterm_invalidate;
 // Utils
 void bind_function(emacs_env *env, const char *name, emacs_value Sfun);
 void provide(emacs_env *env, const char *feature);
+emacs_value symbol_value(emacs_env *env, emacs_value symbol);
 int string_bytes(emacs_env *env, emacs_value string);
 emacs_value string_length(emacs_env *env, emacs_value string);
-emacs_value list(emacs_env *env, emacs_value *elements, ptrdiff_t len);
+emacs_value list(emacs_env *env, emacs_value elements[], ptrdiff_t len);
+emacs_value append(emacs_env *env, emacs_value lists[], ptrdiff_t count);
 void put_text_property(emacs_env *env, emacs_value string, emacs_value property,
                        emacs_value value);
-void byte_to_hex(uint8_t byte, char *hex);
-emacs_value color_to_rgb_string(emacs_env *env, VTermColor color);
-uint8_t hex_to_byte(char *hex);
-VTermColor rgb_string_to_color(emacs_env *env, emacs_value string);
 void erase_buffer(emacs_env *env);
 void insert(emacs_env *env, emacs_value string);
 void goto_char(emacs_env *env, int pos);
diff --git a/vterm-module.c b/vterm-module.c
index 5f5196f..d257d49 100644
--- a/vterm-module.c
+++ b/vterm-module.c
@@ -5,6 +5,7 @@
 #include <limits.h>
 #include <string.h>
 #include <unistd.h>
+#include <stdio.h>
 #include <vterm.h>
 
 static int term_sb_push(int cols, const VTermScreenCell *cells, void *data) {
@@ -373,12 +374,8 @@ static VTermScreenCallbacks vterm_screen_callbacks = {
 
 static bool compare_cells(VTermScreenCell *a, VTermScreenCell *b) {
   bool equal = true;
-  equal = equal && (a->fg.red == b->fg.red);
-  equal = equal && (a->fg.green == b->fg.green);
-  equal = equal && (a->fg.blue == b->fg.blue);
-  equal = equal && (a->bg.red == b->bg.red);
-  equal = equal && (a->bg.green == b->bg.green);
-  equal = equal && (a->bg.blue == b->bg.blue);
+  equal = equal && vterm_color_is_equal(&a->fg, &b->fg);
+  equal = equal && vterm_color_is_equal(&a->bg, &b->bg);
   equal = equal && (a->attrs.bold == b->attrs.bold);
   equal = equal && (a->attrs.underline == b->attrs.underline);
   equal = equal && (a->attrs.italic == b->attrs.italic);
@@ -437,8 +434,6 @@ static emacs_value render_text(emacs_env *env, char *buffer, int len,
     text = env->make_string(env, buffer, len);
   }
 
-  emacs_value foreground = color_to_rgb_string(env, cell->fg);
-  emacs_value background = color_to_rgb_string(env, cell->bg);
   emacs_value bold = cell->attrs.bold ? Qbold : Qnormal;
   emacs_value underline = cell->attrs.underline ? Qt : Qnil;
   emacs_value italic = cell->attrs.italic ? Qitalic : Qnormal;
@@ -448,63 +443,66 @@ static emacs_value render_text(emacs_env *env, char *buffer, int len,
   // TODO: Blink, font, dwl, dhl is missing
   emacs_value properties =
       list(env,
-           (emacs_value[]){Qforeground, foreground, Qbackground, background,
-                           Qweight, bold, Qunderline, underline, Qslant, italic,
-                           Qreverse, reverse, Qstrike, strike},
-           14);
+           (emacs_value[]){Qweight, bold,
+                           Qunderline, underline,
+                           Qslant, italic,
+                           Qreverse, reverse,
+                           Qstrike, strike},
+           10);
+
+  properties = append(env, (emacs_value[]){cell_to_face(env, cell), properties}, 2);
 
   put_text_property(env, text, Qface, properties);
 
   return text;
 }
 
-static void term_setup_colors(Term *term, emacs_env *env) {
-  VTermColor fg, bg;
-  VTermState *state = vterm_obtain_state(term->vt);
+static emacs_value cell_to_face(emacs_env *env, const VTermScreenCell *cell) {
+  bool fg_is_face = VTERM_COLOR_IS_INDEXED(&cell->fg) || VTERM_COLOR_IS_DEFAULT_FG(&cell->fg) || VTERM_COLOR_IS_DEFAULT_BG(&cell->fg);
+  bool bg_is_face = VTERM_COLOR_IS_INDEXED(&cell->bg) || VTERM_COLOR_IS_DEFAULT_FG(&cell->bg) || VTERM_COLOR_IS_DEFAULT_BG(&cell->bg);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm));
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm));
-  vterm_state_set_default_colors(state, &fg, &bg);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_black));
-  vterm_state_set_palette_color(state, 0, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_black));
-  vterm_state_set_palette_color(state, 8, &bg);
+  emacs_value palette = symbol_value(env, Qvterm_color_palette_fg);
+  emacs_value fg = color_to_face(env, &cell->fg, palette);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_red));
-  vterm_state_set_palette_color(state, 1, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_red));
-  vterm_state_set_palette_color(state, 9, &bg);
+  palette = symbol_value(env, Qvterm_color_palette_bg);
+  emacs_value bg = color_to_face(env, &cell->bg, palette);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_green));
-  vterm_state_set_palette_color(state, 2, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_green));
-  vterm_state_set_palette_color(state, 10, &bg);
+  if (fg_is_face && bg_is_face) {
+    return list(env, (emacs_value[]){Qinherited, list(env, (emacs_value[]){fg, bg}, 2)}, 2);
+  } else if (fg_is_face && !bg_is_face) {
+    return list(env, (emacs_value[]){Qinherited, fg, Qbackground, bg}, 4);
+  } else if (!fg_is_face && bg_is_face) {
+    return list(env, (emacs_value[]){Qforeground, fg, Qinherited, bg}, 4);
+  } else {
+    return list(env, (emacs_value[]){Qforeground, fg, Qbackground, bg}, 4);
+  }
+}
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_yellow));
-  vterm_state_set_palette_color(state, 3, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_yellow));
-  vterm_state_set_palette_color(state, 11, &bg);
+static emacs_value color_to_face(emacs_env *env, const VTermColor *color, emacs_value palette) {
+  if (VTERM_COLOR_IS_DEFAULT_FG(color)) {
+    return Qvterm_color_default_fg;
+  }
+  if (VTERM_COLOR_IS_DEFAULT_BG(color)) {
+    return Qvterm_color_default_bg;
+  }
+  if (VTERM_COLOR_IS_INDEXED(color)) {
+    return env->vec_get(env, palette, color->indexed.idx);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_blue));
-  vterm_state_set_palette_color(state, 4, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_blue));
-  vterm_state_set_palette_color(state, 12, &bg);
+  }
+  if (VTERM_COLOR_IS_RGB(color)) {
+    char buffer[8];
+    snprintf(buffer, 8, "#%X%X%X", color->rgb.red, color->rgb.green, color->rgb.blue);
+    return env->make_string(env, buffer, 7);
+  }
+}
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_magenta));
-  vterm_state_set_palette_color(state, 5, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_magenta));
-  vterm_state_set_palette_color(state, 13, &bg);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_cyan));
-  vterm_state_set_palette_color(state, 6, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_cyan));
-  vterm_state_set_palette_color(state, 14, &bg);
+static void term_setup_colors(Term *term, emacs_env *env) {
+  VTermState *state = vterm_obtain_state(term->vt);
 
-  fg = rgb_string_to_color(env, get_hex_color_fg(env, Qterm_color_white));
-  vterm_state_set_palette_color(state, 7, &fg);
-  bg = rgb_string_to_color(env, get_hex_color_bg(env, Qterm_color_white));
-  vterm_state_set_palette_color(state, 15, &bg);
+  /* vterm_colo */
+  /* vterm_state_set_default_colors(state, &term->fg, &term->bg); */
 }
 
 static void term_flush_output(Term *term, emacs_env *env) {
@@ -723,14 +721,21 @@ int emacs_module_init(struct emacs_runtime *ert) {
   Qslant = env->make_global_ref(env, env->intern(env, ":slant"));
   Qreverse = env->make_global_ref(env, env->intern(env, ":inverse-video"));
   Qstrike = env->make_global_ref(env, env->intern(env, ":strike-through"));
+  Qinherited = env->make_global_ref(env, env->intern(env, ":inherit"));
   Qface = env->make_global_ref(env, env->intern(env, "font-lock-face"));
   Qcursor_type = env->make_global_ref(env, env->intern(env, "cursor-type"));
+  Qvterm_color_default_fg = env->make_global_ref(env, env->intern(env, "vterm-color-default-fg"));
+  Qvterm_color_default_bg = env->make_global_ref(env, env->intern(env, "vterm-color-default-bg"));
+  Qvterm_color_palette_fg = env->make_global_ref(env, env->intern(env, "vterm-color-palette-fg"));
+  Qvterm_color_palette_bg = env->make_global_ref(env, env->intern(env, "vterm-color-palette-bg"));
 
   // Functions
+  Fsymbol_value = env->make_global_ref(env, env->intern(env, "symbol-value"));
   Flength = env->make_global_ref(env, env->intern(env, "length"));
   Flist = env->make_global_ref(env, env->intern(env, "list"));
   Ferase_buffer = env->make_global_ref(env, env->intern(env, "erase-buffer"));
   Finsert = env->make_global_ref(env, env->intern(env, "insert"));
+  Fappend = env->make_global_ref(env, env->intern(env, "append"));
   Fgoto_char = env->make_global_ref(env, env->intern(env, "goto-char"));
   Fput_text_property =
       env->make_global_ref(env, env->intern(env, "put-text-property"));
@@ -759,24 +764,6 @@ int emacs_module_init(struct emacs_runtime *ert) {
   Fvterm_invalidate =
       env->make_global_ref(env, env->intern(env, "vterm--invalidate"));
 
-  // Faces
-  Qterm = env->make_global_ref(env, env->intern(env, "vterm"));
-  Qterm_color_black =
-      env->make_global_ref(env, env->intern(env, "vterm-color-black"));
-  Qterm_color_red =
-      env->make_global_ref(env, env->intern(env, "vterm-color-red"));
-  Qterm_color_green =
-      env->make_global_ref(env, env->intern(env, "vterm-color-green"));
-  Qterm_color_yellow =
-      env->make_global_ref(env, env->intern(env, "vterm-color-yellow"));
-  Qterm_color_blue =
-      env->make_global_ref(env, env->intern(env, "vterm-color-blue"));
-  Qterm_color_magenta =
-      env->make_global_ref(env, env->intern(env, "vterm-color-magenta"));
-  Qterm_color_cyan =
-      env->make_global_ref(env, env->intern(env, "vterm-color-cyan"));
-  Qterm_color_white =
-      env->make_global_ref(env, env->intern(env, "vterm-color-white"));
 
   // Exported functions
   emacs_value fun;
@@ -802,5 +789,6 @@ int emacs_module_init(struct emacs_runtime *ert) {
   bind_function(env, "vterm--set-size", fun);
 
   provide(env, "vterm-module");
+
   return 0;
 }
diff --git a/vterm-module.h b/vterm-module.h
index bd05dc4..a9a9301 100644
--- a/vterm-module.h
+++ b/vterm-module.h
@@ -54,26 +54,16 @@ typedef struct Term {
   int width, height;
 } Term;
 
-// Faces
-emacs_value Qterm;
-emacs_value Qterm_color_black;
-emacs_value Qterm_color_red;
-emacs_value Qterm_color_green;
-emacs_value Qterm_color_yellow;
-emacs_value Qterm_color_blue;
-emacs_value Qterm_color_magenta;
-emacs_value Qterm_color_cyan;
-emacs_value Qterm_color_white;
-
 static bool compare_cells(VTermScreenCell *a, VTermScreenCell *b);
 static bool is_key(unsigned char *key, size_t len, char *key_description);
 static emacs_value render_text(emacs_env *env, char *string, int len,
                                VTermScreenCell *cell);
+static emacs_value cell_to_face(emacs_env *env, const VTermScreenCell *cell);
+static emacs_value color_to_face(emacs_env *env, const VTermColor *color, emacs_value palette);
 
 static int term_settermprop(VTermProp prop, VTermValue *val, void *user_data);
 
 static void term_redraw(Term *term, emacs_env *env);
-static void term_setup_colors(Term *term, emacs_env *env);
 static void term_flush_output(Term *term, emacs_env *env);
 static void term_process_key(Term *term, unsigned char *key, size_t len,
                              VTermModifier modifier);
diff --git a/vterm.el b/vterm.el
index 2641d76..2c41d50 100644
--- a/vterm.el
+++ b/vterm.el
@@ -81,52 +81,132 @@ for different shell. "
   :type 'hook
   :group 'vterm)
 
+(defface vterm-color-default-fg
+  '((t :foreground "white"))
+  "Foreground of the console."
+  :group 'vterm)
+
+(defface vterm-color-default-bg
+  '((t :background "black"))
+  "Background of the console."
+  :group 'vterm)
 
-(defface vterm
-  '((t :inherit default))
-  "Default face to use in Term mode."
+(defface vterm-color-black-fg
+  '((t :foreground "black"))
+  "Face used to render black color code."
   :group 'vterm)
 
-(defface vterm-color-black
-  '((t :foreground "black" :background "black"))
+(defface vterm-color-black-bg
+  '((t :background "black"))
   "Face used to render black color code."
   :group 'vterm)
 
-(defface vterm-color-red
-  '((t :foreground "red3" :background "red3"))
+(defface vterm-color-red-fg
+  '((t :foreground "red3"))
+  "Face used to render red color code."
+  :group 'vterm)
+
+(defface vterm-color-red-bg
+  '((t :background "red3"))
   "Face used to render red color code."
   :group 'vterm)
 
-(defface vterm-color-green
-  '((t :foreground "green3" :background "green3"))
+(defface vterm-color-green-fg
+  '((t :foreground "green3"))
   "Face used to render green color code."
   :group 'vterm)
 
-(defface vterm-color-yellow
-  '((t :foreground "yellow3" :background "yellow3"))
+(defface vterm-color-green-bg
+  '((t :background "green3"))
+  "Face used to render green color code."
+  :group 'vterm)
+
+(defface vterm-color-yellow-fg
+  '((t :foreground "yellow3"))
   "Face used to render yellow color code."
   :group 'vterm)
 
-(defface vterm-color-blue
-  '((t :foreground "blue2" :background "blue2"))
+(defface vterm-color-yellow-bg
+  '((t :background "yellow3"))
+  "Face used to render yellow color code."
+  :group 'vterm)
+
+(defface vterm-color-blue-fg
+  '((t :foreground "blue2"))
   "Face used to render blue color code."
   :group 'vterm)
 
-(defface vterm-color-magenta
-  '((t :foreground "magenta3" :background "magenta3"))
+(defface vterm-color-blue-bg
+  '((t :background "blue2"))
+  "Face used to render yellow color code."
+  :group 'vterm)
+
+(defface vterm-color-magenta-fg
+  '((t :foreground "magenta3"))
   "Face used to render magenta color code."
   :group 'vterm)
 
-(defface vterm-color-cyan
-  '((t :foreground "cyan3" :background "cyan3"))
+(defface vterm-color-magenta-bg
+  '((t :foreground "magenta3"))
+  "Face used to render magenta color code."
+  :group 'vterm)
+
+(defface vterm-color-cyan-fg
+  '((t :foreground "cyan3"))
+  "Face used to render cyan color code."
+  :group 'vterm)
+
+(defface vterm-color-cyan-bg
+  '((t :background "cyan3"))
   "Face used to render cyan color code."
   :group 'vterm)
 
-(defface vterm-color-white
-  '((t :foreground "white" :background "white"))
+(defface vterm-color-white-fg
+  '((t :foreground "white"))
+  "Face used to render white color code."
+  :group 'vterm)
+
+(defface vterm-color-white-bg
+  '((t :background "white"))
   "Face used to render white color code."
   :group 'vterm)
 
+(defvar vterm-color-palette-fg [vterm-color-black-fg
+                                vterm-color-red-fg
+                                vterm-color-green-fg
+                                vterm-color-yellow-fg
+                                vterm-color-blue-fg
+                                vterm-color-magenta-fg
+                                vterm-color-cyan-fg
+                                vterm-color-white-fg
+                                vterm-color-black-fg
+                                vterm-color-red-fg
+                                vterm-color-green-fg
+                                vterm-color-yellow-fg
+                                vterm-color-blue-fg
+                                vterm-color-magenta-fg
+                                vterm-color-cyan-fg
+                                vterm-color-white-fg]
+  "Color palette for the foreground.")
+
+(defvar vterm-color-palette-bg [vterm-color-black-bg
+                                vterm-color-red-bg
+                                vterm-color-green-bg
+                                vterm-color-yellow-bg
+                                vterm-color-blue-bg
+                                vterm-color-magenta-bg
+                                vterm-color-cyan-bg
+                                vterm-color-white-bg
+                                vterm-color-black-bg
+                                vterm-color-red-bg
+                                vterm-color-green-bg
+                                vterm-color-yellow-bg
+                                vterm-color-blue-bg
+                                vterm-color-magenta-bg
+                                vterm-color-cyan-bg
+                                vterm-color-white-bg]
+  "Color palette for the background.")
+
 (defvar vterm--term nil
   "Pointer to Term.")
 (make-variable-buffer-local 'vterm--term)
@@ -306,13 +386,6 @@ Feeds the size change to the virtual terminal."
           (set-process-window-size vterm--process height width)
           (vterm--set-size vterm--term height width))))))
 
-(defun vterm--face-color-hex (face attr)
-  "Return the color of the FACE's ATTR as a hex string."
-  (if (< emacs-major-version 26)
-      (apply #'color-rgb-to-hex (color-name-to-rgb (face-attribute face attr nil 'default)))
-    (apply #'color-rgb-to-hex (append (color-name-to-rgb (face-attribute face attr nil 'default)) '(2)))))
-
-
 (defun vterm--delete-lines (line-num count &optional delete-whole-line)
   "Delete COUNT lines from LINE-NUM.