msgwin.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <string.h>
#include <wchar.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "msgwin.h"
#include "color/lib.h"
#include "module_data.h"
#include "msgcont.h"
#include "msgwin_wdata.h"
#include "mutt_curses.h"
#include "mutt_window.h"

void measure(struct MwCharArray *chars, const char *str, const struct AttrColor *ac_color)
{
  if (!str || !*str)
    return;
 
  mbstate_t mbstate = { 0 };
  struct MwChar mwc = { 0 };
 
  size_t str_len = mutt_str_len(str);
 
  while (*str && (str_len > 0))
  {
    wchar_t wc = L'\0';
    size_t consumed = mbrtowc(&wc, str, str_len, &mbstate);
    if (consumed == 0)
      break;
 
    if (consumed == ICONV_ILLEGAL_SEQ)
    {
      memset(&mbstate, 0, sizeof(mbstate));
      wc = ReplacementChar;
      consumed = 1;
    }
    else if (consumed == ICONV_BUF_TOO_SMALL)
    {
      wc = ReplacementChar;
      consumed = str_len;
    }
 
    int wchar_width = wcwidth(wc);
    if (wchar_width < 0)
      wchar_width = 1;
 
    if (wc == 0xfe0f) // Emoji variation
    {
      int size = ARRAY_SIZE(chars);
      if (size > 0)
      {
        struct MwChar *es_prev = ARRAY_GET(chars, size - 1);
        if (es_prev->width == 1)
          es_prev->width = 2;
      }
    }
 
    mwc = (struct MwChar) { wchar_width, consumed, ac_color };
    ARRAY_ADD(chars, mwc);
 
    str += consumed;
    str_len -= consumed;
  }
}

static int msgwin_recalc(struct MuttWindow *win)
{
  win->actions |= WA_REPAINT;
  mutt_debug(LL_DEBUG5, "recalc done, request WA_REPAINT\n");
  return 0;
}

int msgwin_calc_rows(struct MsgWinWindowData *wdata, int cols, const char *str)
{
  if (!wdata)
    return 0;
 
  for (int i = 0; i < MSGWIN_MAX_ROWS; i++)
  {
    ARRAY_FREE(&wdata->rows[i]);
  }
 
  if (!str || !*str)
    return 0;
 
  int width = 0;  
  int offset = 0; 
  int row = 0;    
  bool new_row = false;
 
  struct MwChunk *chunk = NULL;
  struct MwChar *mwc = NULL;
  ARRAY_FOREACH(mwc, &wdata->chars)
  {
    const bool nl = (mwc->bytes == 1) && (str[offset] == '\n');
    if (nl)
    {
      new_row = true;
      offset += mwc->bytes;
      continue;
    }
 
    if (((width + mwc->width) > cols) || new_row)
    {
      // ROW IS FULL
      new_row = false;
 
      row++;
      if (row >= MSGWIN_MAX_ROWS)
      {
        // NO MORE ROOM
        break;
      }
 
      // Start a new row
      struct MwChunk tmp = { offset, mwc->bytes, mwc->width, mwc->ac_color };
 
      mutt_debug(LL_DEBUG5, "row = %d\n", row);
      ARRAY_ADD(&wdata->rows[row], tmp);
      chunk = ARRAY_LAST(&wdata->rows[row]);
 
      width = 0;
    }
    else if (!chunk || (mwc->ac_color != chunk->ac_color))
    {
      // CHANGE OF COLOUR
      struct MwChunk tmp = { offset, mwc->bytes, mwc->width, mwc->ac_color };
      ARRAY_ADD(&wdata->rows[row], tmp);
      chunk = ARRAY_LAST(&wdata->rows[row]);
    }
    else
    {
      // MORE OF THE SAME
      chunk->bytes += mwc->bytes;
      chunk->width += mwc->width;
    }
 
    offset += mwc->bytes;
    width += mwc->width;
  }
 
  mutt_debug(LL_DEBUG5, "msgwin_calc_rows() => %d\n", row + 1);
  return row + 1;
}

static int msgwin_repaint(struct MuttWindow *win)
{
  struct MsgWinWindowData *wdata = win->wdata;
 
  const char *str = buf_string(wdata->text);
  const int max_rows = MIN(MSGWIN_MAX_ROWS, win->state.rows);
  for (int i = 0; i < max_rows; i++)
  {
    mutt_window_move(win, i, 0);
    if (ARRAY_EMPTY(&wdata->rows[i]))
    {
      mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
      mutt_window_clrtoeol(win);
      break;
    }
 
    struct MwChunk *chunk = NULL;
    ARRAY_FOREACH(chunk, &wdata->rows[i])
    {
      mutt_curses_set_color(chunk->ac_color);
      mutt_window_addnstr(win, str + chunk->offset, chunk->bytes);
    }
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    mutt_window_clrtoeol(win);
  }
 
  mutt_window_get_coords(win, &wdata->row, &wdata->col);
 
  mutt_debug(LL_DEBUG5, "msgwin repaint done\n");
  return 0;
}

static bool msgwin_recursor(struct MuttWindow *win)
{
  struct MsgWinWindowData *wdata = win->wdata;
 
  mutt_window_move(win, wdata->row, wdata->col);
  mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
 
  mutt_debug(LL_DEBUG5, "msgwin recursor done\n");
  return true;
}

void msgwin_set_rows(struct MuttWindow *win, short rows)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return;
 
  rows = CLAMP(rows, 1, MSGWIN_MAX_ROWS);
 
  if (rows != win->req_rows)
  {
    win->req_rows = rows;
 
    msgcont_recalc_rows();
 
    mutt_window_reflow(NULL);
  }
}

static int msgwin_window_observer(struct NotifyCallback *nc)
{
  if (nc->event_type != NT_WINDOW)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
  struct EventWindow *ev_w = nc->event_data;
  if (ev_w->win != win)
    return 0;
 
  if (nc->event_subtype == NT_WINDOW_STATE)
  {
    if (ev_w->flags & WN_HIDDEN)
    {
      msgwin_clear_text(win);
    }
 
    if (ev_w->flags & (WN_NARROWER | WN_WIDER))
    {
      struct MsgWinWindowData *wdata = win->wdata;
      msgwin_set_rows(win, msgwin_calc_rows(wdata, win->state.cols,
                                            buf_string(wdata->text)));
      win->actions |= WA_RECALC;
    }
    else
    {
      win->actions |= WA_REPAINT;
    }
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    notify_observer_remove(win->notify, msgwin_window_observer, win);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
  return 0;
}

struct MuttWindow *msgwin_new(bool interactive)
{
  struct MuttWindow *win = mutt_window_new(WT_MESSAGE, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_FIXED,
                                           MUTT_WIN_SIZE_UNLIMITED, 1);
 
  struct MsgWinWindowData *wdata = msgwin_wdata_new();
 
  win->wdata = wdata;
  win->wdata_free = msgwin_wdata_free;
  win->recalc = msgwin_recalc;
  win->repaint = msgwin_repaint;
 
  if (interactive)
    win->recursor = msgwin_recursor;
 
  // Copy the container's dimensions
  struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  if (mod_data && mod_data->message_container)
    win->state = mod_data->message_container->state;
 
  notify_observer_add(win->notify, NT_WINDOW, msgwin_window_observer, win);
 
  return win;
}

const char *msgwin_get_text(struct MuttWindow *win)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return NULL;
 
  struct MsgWinWindowData *wdata = win->wdata;
 
  return buf_string(wdata->text);
}

void msgwin_add_text(struct MuttWindow *win, const char *text, const struct AttrColor *ac_color)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return;
 
  struct MsgWinWindowData *wdata = win->wdata;
 
  if (text)
  {
    buf_addstr(wdata->text, text);
    measure(&wdata->chars, text, ac_color);
    mutt_debug(LL_DEBUG5, "MW ADD: %zu, %s\n", buf_len(wdata->text),
               buf_string(wdata->text));
  }
  else
  {
    int rows = msgwin_calc_rows(wdata, win->state.cols, buf_string(wdata->text));
    msgwin_set_rows(win, rows);
    win->actions |= WA_RECALC;
  }
}

void msgwin_add_text_n(struct MuttWindow *win, const char *text, int bytes,
                       const struct AttrColor *ac_color)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return;
 
  struct MsgWinWindowData *wdata = win->wdata;
 
  if (text)
  {
    // Track the length of the text so far
    const size_t len = buf_len(wdata->text);
    buf_addstr_n(wdata->text, text, bytes);
    // and only measure the newly added text
    measure(&wdata->chars, wdata->text->data + len, ac_color);
    mutt_debug(LL_DEBUG5, "MW ADD: %zu, %s\n", buf_len(wdata->text),
               buf_string(wdata->text));
  }
  else
  {
    int rows = msgwin_calc_rows(wdata, win->state.cols, buf_string(wdata->text));
    msgwin_set_rows(win, rows);
    win->actions |= WA_RECALC;
  }
}

void msgwin_set_text(struct MuttWindow *win, const char *text, enum ColorId color)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return;
 
  const bool hidden = !win->state.visible;
 
  struct MsgWinWindowData *wdata = win->wdata;
 
  // If the text is unchanged: nothing to do, except reveal the window if it
  // was hidden so the user actually sees it.
  if (mutt_str_equal(buf_string(wdata->text), text) && !hidden)
    return;
 
  buf_strcpy(wdata->text, text);
  ARRAY_FREE(&wdata->chars);
  if (wdata->text)
  {
    const struct AttrColor *ac_normal = simple_color_get(MT_COLOR_NORMAL);
    const struct AttrColor *ac_color = simple_color_get(color);
    const struct AttrColor *ac_merge = merged_color_overlay(ac_normal, ac_color);
 
    measure(&wdata->chars, buf_string(wdata->text), ac_merge);
  }
 
  mutt_debug(LL_DEBUG5, "MW SET: %zu, %s\n", buf_len(wdata->text),
             buf_string(wdata->text));
 
  // If the window was hidden, reveal it and reflow so the message is seen.
  if (!win->state.visible)
  {
    window_set_visible(win, true);
    int rows = msgwin_calc_rows(wdata, win->state.cols, buf_string(wdata->text));
    win->req_rows = CLAMP(rows, 1, MSGWIN_MAX_ROWS);
    msgcont_recalc_rows();
    win->actions |= WA_RECALC;
    window_redraw(NULL);
    return;
  }
 
  int rows = msgwin_calc_rows(wdata, win->state.cols, buf_string(wdata->text));
  msgwin_set_rows(win, rows);
  win->actions |= WA_RECALC;
}

void msgwin_clear_text(struct MuttWindow *win)
{
  if (!win)
    win = msgcont_get_msgwin();
  if (!win)
    return;
 
  struct MsgWinWindowData *wdata = win->wdata;
 
  // Force-clear even if the window was hidden (msgwin_set_text would skip it).
  if (!buf_is_empty(wdata->text))
  {
    buf_reset(wdata->text);
    ARRAY_FREE(&wdata->chars);
    for (int i = 0; i < MSGWIN_MAX_ROWS; i++)
    {
      ARRAY_FREE(&wdata->rows[i]);
    }
 
    if (win->state.visible)
    {
      int rows = msgwin_calc_rows(wdata, win->state.cols, buf_string(wdata->text));
      msgwin_set_rows(win, rows);
      win->actions |= WA_RECALC;
    }
  }
 
  // If the Message Window isn't alone in the stack, hide it again so the
  // Window beneath us regains the space.
  if (win->state.visible && (msgcont_num_windows() > 1))
  {
    window_set_visible(win, false);
    msgcont_recalc_rows();
    window_redraw(NULL);
  }
}

struct MuttWindow *msgwin_get_window(void)
{
  return msgcont_get_msgwin();
}

bool msgwin_has_text(void)
{
  struct MuttWindow *win = msgcont_get_msgwin();
  if (!win || !win->wdata)
    return false;
 
  const struct MsgWinWindowData *wdata = win->wdata;
  return !buf_is_empty(wdata->text);
}