window.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 "gui/lib.h"
#include "lib.h"
#include "color/lib.h"
#include "complete/lib.h"
#include "history/lib.h"
#include "key/lib.h"
#include "functions.h"
#include "module_data.h"
#include "muttlib.h"
#include "state.h"
#include "wdata.h"

static const struct Mapping EditorHelp[] = {
  // clang-format off
  { N_("Help"),        OP_HELP },
  { N_("Complete"),    OP_EDITOR_COMPLETE },
  { N_("Hist Up"),     OP_EDITOR_HISTORY_UP },
  { N_("Hist Down"),   OP_EDITOR_HISTORY_DOWN },
  { N_("Hist Search"), OP_EDITOR_HISTORY_SEARCH },
  { N_("Begin Line"),  OP_EDITOR_BOL },
  { N_("End Line"),    OP_EDITOR_EOL },
  { N_("Kill Line"),   OP_EDITOR_KILL_LINE },
  { N_("Kill Word"),   OP_EDITOR_KILL_WORD },
  { NULL, 0 },
  // clang-format on
};

static int my_addwch(struct MuttWindow *win, wchar_t wc)
{
  int n = wcwidth(wc);
  if (IsWPrint(wc) && (n > 0))
    return mutt_addwch(win, wc);
  if (!(wc & ~0x7f))
    return mutt_window_printf(win, "^%c", ((int) wc + 0x40) & 0x7f);
  if (!(wc & ~0xffff))
    return mutt_window_printf(win, "\\u%04x", (int) wc);
  return mutt_window_printf(win, "\\u%08x", (int) wc);
}

bool self_insert(struct EnterWindowData *wdata, int ch)
{
  if (!wdata)
    return true;
 
  wdata->tabs = 0;
  wchar_t wc = 0;
 
  /* quietly ignore all other function keys */
  if (ch & ~0xff)
    return false;
 
  /* gather the bytes into a wide character */
  {
    char c = ch;
    size_t k = mbrtowc(&wc, &c, 1, wdata->mbstate);
    if (k == ICONV_BUF_TOO_SMALL)
    {
      return false;
    }
    else if ((k != 0) && (k != 1))
    {
      memset(wdata->mbstate, 0, sizeof(*wdata->mbstate));
      return false;
    }
  }
 
  if (wdata->first && (wdata->flags & MUTT_COMP_CLEAR))
  {
    wdata->first = false;
    if (IsWPrint(wc)) /* why? */
    {
      wdata->state->curpos = 0;
      wdata->state->lastchar = 0;
    }
  }
 
  if ((wc == '\r') || (wc == '\n'))
  {
    /* Convert from wide characters */
    buf_mb_wcstombs(wdata->buffer, wdata->state->wbuf, wdata->state->lastchar);
    if (!wdata->pass)
      mutt_hist_add(wdata->hclass, buf_string(wdata->buffer), true);
 
    if (wdata->cdata)
    {
      struct FileCompletionData *cdata = wdata->cdata;
      if (cdata->multiple)
      {
        char **tfiles = NULL;
        *cdata->numfiles = 1;
        tfiles = MUTT_MEM_CALLOC(*cdata->numfiles, char *);
        expand_path(wdata->buffer, false);
        tfiles[0] = buf_strdup(wdata->buffer);
        *cdata->files = tfiles;
      }
    }
    return true;
  }
  else if (wc && ((wc < ' ') || IsWPrint(wc))) /* why? */
  {
    enter_state_resize(wdata->state, wdata->state->lastchar + 1);
    memmove(wdata->state->wbuf + wdata->state->curpos + 1,
            wdata->state->wbuf + wdata->state->curpos,
            (wdata->state->lastchar - wdata->state->curpos) * sizeof(wchar_t));
    wdata->state->wbuf[wdata->state->curpos++] = wc;
    wdata->state->lastchar++;
  }
  else
  {
    mutt_flushinp();
    mutt_beep(false);
  }
 
  return false;
}

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

static int enter_repaint(struct MuttWindow *win)
{
  if (!mutt_window_is_visible(win))
    return 0;
 
  struct EnterWindowData *wdata = win->wdata;
 
  mutt_window_clearline(win, 0);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_PROMPT);
  mutt_window_addstr(win, wdata->prompt);
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  int prompt_length = 0;
  mutt_window_get_coords(win, NULL, &prompt_length);
 
  int width = win->state.cols - prompt_length - 1;
  if (width < 1)
    width = 1;
 
  if (!wdata->pass)
  {
    if (wdata->redraw == ENTER_REDRAW_INIT)
    {
      /* Go to end of line */
      wdata->state->curpos = wdata->state->lastchar;
      wdata->state->begin = mutt_mb_width_ceiling(
          wdata->state->wbuf, wdata->state->lastchar,
          mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->lastchar) - width + 1);
    }
    if ((wdata->state->curpos < wdata->state->begin) ||
        (mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
                          wdata->state->curpos - wdata->state->begin) >= width))
    {
      wdata->state->begin = mutt_mb_width_ceiling(
          wdata->state->wbuf, wdata->state->lastchar,
          mutt_mb_wcswidth(wdata->state->wbuf, wdata->state->curpos) - (width / 2));
    }
    mutt_window_move(win, 0, prompt_length);
    int w = 0;
    for (size_t i = wdata->state->begin; i < wdata->state->lastchar; i++)
    {
      w += mutt_mb_wcwidth(wdata->state->wbuf[i]);
      if (w > width)
        break;
      my_addwch(win, wdata->state->wbuf[i]);
    }
    mutt_window_clrtoeol(win);
    mutt_window_move(win, 0,
                     prompt_length +
                         mutt_mb_wcswidth(wdata->state->wbuf + wdata->state->begin,
                                          wdata->state->curpos - wdata->state->begin));
  }
 
  mutt_window_get_coords(win, &wdata->row, &wdata->col);
  mutt_debug(LL_DEBUG5, "repaint done\n");
 
  return 0;
}

static bool enter_recursor(struct MuttWindow *win)
{
  struct EnterWindowData *wdata = win->wdata;
  mutt_window_move(win, wdata->row, wdata->col);
  mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
  return true;
}

static int enter_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)
  {
    win->actions |= WA_REPAINT;
    mutt_debug(LL_DEBUG5, "window state done, request WA_REPAINT\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    notify_observer_remove(win->notify, enter_window_observer, win);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

int mw_get_field_notify(const char *prompt, struct Buffer *buf, CompletionFlags complete,
                        enum HistoryClass hclass, const struct CompleteOps *comp_api,
                        void *cdata, get_field_callback_t callback, void *cb_data,
                        const struct MenuDefinition *md, function_dispatcher_t fn_disp)
{
  struct EditorModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EDITOR);
  ASSERT(mod_data);
 
  struct MuttWindow *win = mutt_window_new(WT_CUSTOM, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_FIXED,
                                           MUTT_WIN_SIZE_UNLIMITED, 1);
 
  GetChFlags flags = GETCH_NO_COUNTER | GETCH_NO_FEEDBACK;
  if (complete & MUTT_COMP_UNBUFFERED)
    flags |= GETCH_IGNORE_MACRO;
 
  struct Buffer *cbuf = NULL;
  if (callback)
    cbuf = buf_pool_get();
 
  if (!md)
    md = mod_data->md_editor;
 
  int rc = 0;
 
  struct EnterState *es = enter_state_new();
 
  win->help_data = EditorHelp;
  win->help_md = mod_data->md_editor;
 
  msgcont_push_window(win);
  struct MuttWindow *old_focus = window_set_focus(win);
 
  mbstate_t mbstate = { 0 };
  // clang-format off
  struct EnterWindowData wdata = { buf, complete, es, hclass, comp_api, cdata, prompt, ENTER_REDRAW_NONE, (complete & MUTT_COMP_PASS), true, NULL, 0, &mbstate, 0, false, NULL, 0, 0 };
  // clang-format on
 
  win->wdata = &wdata;
  win->wdata_free = NULL; // No need, we hold the data
  win->recalc = enter_recalc;
  win->repaint = enter_repaint;
  win->recursor = enter_recursor;
 
  notify_observer_add(win->notify, NT_WINDOW, enter_window_observer, win);
 
  window_redraw(win);
 
  if (es->wbuf[0] == L'\0')
  {
    /* Initialise wbuf from buf */
    wdata.state->wbuflen = 0;
    wdata.state->lastchar = mutt_mb_mbstowcs(&wdata.state->wbuf, &wdata.state->wbuflen,
                                             0, buf_string(wdata.buffer));
    wdata.redraw = ENTER_REDRAW_INIT;
  }
  else
  {
    wdata.redraw = ENTER_REDRAW_LINE;
    wdata.first = false;
  }
 
  do
  {
    memset(&mbstate, 0, sizeof(mbstate));
 
    do
    {
      if (wdata.redraw != ENTER_REDRAW_NONE)
        win->actions |= WA_REPAINT;
 
      mutt_curses_set_cursor(MUTT_CURSOR_INVISIBLE);
      window_redraw(NULL);
      mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
      struct KeyEvent event = km_dokey(md, flags);
      if ((event.op == OP_TIMEOUT) || (event.op == OP_REPAINT))
      {
        continue;
      }
 
      if (event.op == OP_ABORT)
      {
        rc = -1;
        goto bye;
      }
 
      if (event.op == OP_NULL)
      {
        if (complete & MUTT_COMP_PASS)
          mutt_debug(LL_DEBUG5, "Got char *\n");
        else
          mutt_debug(LL_DEBUG5, "Got char %c (0x%02x)\n", event.ch, event.ch);
 
        if (self_insert(&wdata, event.ch))
        {
          rc = 0;
          goto bye;
        }
        win->actions |= WA_REPAINT;
        goto notify;
      }
      else
      {
        mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(event.op),
                   event.op);
      }
 
      wdata.first = false;
      if ((event.op != OP_EDITOR_COMPLETE) && (event.op != OP_EDITOR_COMPLETE_QUERY))
        wdata.tabs = 0;
 
      wdata.redraw = ENTER_REDRAW_LINE;
 
      int rc_disp = FR_UNKNOWN;
      if (fn_disp)
      {
        rc_disp = fn_disp(cb_data, &event);
        if (rc_disp == FR_SUCCESS)
          rc_disp = FR_CONTINUE;
      }
 
      if (rc_disp == FR_UNKNOWN)
        rc_disp = enter_function_dispatcher(win, &event);
 
      switch (rc_disp)
      {
        case FR_NO_ACTION:
        {
          if (self_insert(&wdata, event.ch))
          {
            rc = 0;
            goto bye;
          }
          break;
        }
        case FR_CONTINUE: // repaint
          rc = 1;
          goto bye;
 
        case FR_DONE:
          wdata.done = true;
          rc = 0;
          break;
 
        case FR_SUCCESS:
          rc = 0;
          break;
 
        case FR_UNKNOWN:
        case FR_ERROR:
        default:
          mutt_beep(false);
      }
 
    notify:
      if (callback)
      {
        buf_mb_wcstombs(cbuf, wdata.state->wbuf, wdata.state->lastchar);
        callback(buf_string(cbuf), cb_data);
      }
 
    } while (!wdata.done);
 
  bye:
    mutt_hist_reset_state(wdata.hclass);
    FREE(&wdata.tempbuf);
  } while (rc == 1);
 
  completion_data_free(&wdata.cd);
  msgcont_pop_window();
  window_set_focus(old_focus);
  mutt_window_free(&win);
 
  if (rc == 0)
    buf_fix_dptr(buf);
  else
    buf_reset(buf);
 
  buf_pool_release(&cbuf);
 
  enter_state_free(&es);
 
  return rc;
}

int mw_get_field(const char *prompt, struct Buffer *buf, CompletionFlags complete,
                 enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
{
  return mw_get_field_notify(prompt, buf, complete, hclass, comp_api, cdata,
                             NULL, NULL, NULL, NULL);
}