preview.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "private.h"
#include "mutt/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "color/lib.h"
#include "key/lib.h"
 
// Maxixum body size in bytes to show in preview.
const long MAX_PREVIEW_BODY_SIZE = 1024 * 1024 * 5;

struct PreviewWindowData
{
  struct Email *email;    
  int scroll_offset;      
  struct MuttWindow *win; 
  struct MuttWindow *bar; 
  bool more_content;      
  int content_lines;      
};

typedef int (*preview_function_t)(struct PreviewWindowData *wdata,
                                  const struct KeyEvent *event);

struct PreviewFunction
{
  int op;                      
  preview_function_t function; 
};

static void preview_wdata_free(struct MuttWindow *win, void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}

static struct PreviewWindowData *preview_wdata_new(void)
{
  struct PreviewWindowData *wdata = mutt_mem_calloc(1, sizeof(struct PreviewWindowData));
 
  return wdata;
}

static void draw_preview(struct MuttWindow *win, struct PreviewWindowData *wdata)
{
  struct Email *e = wdata->email;
 
  // Reset preview window and status bar.
  mutt_window_clear(win);
  sbar_set_title(wdata->bar, _("-- Preview"));
 
  // Check for valid content type and disposition
  if ((e->body->disposition != DISP_INLINE) || (e->body->type != TYPE_TEXT))
  {
    mutt_error(_("Only inline attachments with content-type text/* can be previewed"));
    return;
  }
 
  // Ensure file isn't to too large.
  long file_size = mutt_file_get_size(e->body->filename);
  if (file_size > MAX_PREVIEW_BODY_SIZE)
  {
    mutt_error(_("Email too large to preview"));
    return;
  }
 
  FILE *fp = mutt_file_fopen(e->body->filename, "r");
  if (!fp)
  {
    mutt_perror("%s", e->body->filename);
    return;
  }
 
  wdata->more_content = false;
 
  int content_lines = 0; // number of (wrapped) content lines
  int row = 0;           // window row to print
  char *line = NULL;
  size_t line_len = 0;
  while ((line = mutt_file_read_line(line, &line_len, fp, NULL, MUTT_RL_NONE)))
  {
    size_t pos = 0;
    bool text_left = true;
    while (text_left)
    {
      /* Text wrapping loop
       *
       * Note: We need to do the text wrapping also for text outside the visible
       *       area to ensure the scrolling works correctly.
       */
 
      content_lines++;
 
      mutt_str_expand_tabs(&line, &line_len, 8);
 
      // Check how much of the string fits into the window width.
      size_t width = 0;
      size_t bytes = mutt_wstr_trunc(&line[pos], line_len - pos, win->state.cols, &width);
 
      // If it doesn't fill the full width we're done wrapping.
      if ((win->state.cols - width) > 0)
        text_left = false;
 
      // Only move the cursor and print if this line is currently visible.
      if ((content_lines >= wdata->scroll_offset) && (row < win->state.rows))
      {
        int rc = mutt_window_move(win, row, 0);
        if (rc == ERR)
          mutt_warning(_("Failed to move cursor!"));
 
        mutt_paddstr(win, win->state.cols, &line[pos]);
 
        row++;
      }
 
      // Advance position in string.
      pos += bytes;
    }
  }
 
  FREE(&line);
  mutt_file_fclose(&fp);
 
  // Store content_lines for boundary checking
  wdata->content_lines = content_lines;
 
  // Clamp scroll_offset to prevent empty pages
  // Maximum valid offset is when we can still show at least one line of content
  if (content_lines > 0)
  {
    int max_offset = MAX(0, content_lines - win->state.rows);
    if (wdata->scroll_offset > max_offset)
      wdata->scroll_offset = max_offset;
  }
 
  // Show the scroll percentage in the status bar
  if ((content_lines != 0) && (content_lines > win->state.rows))
  {
    char title[256] = { 0 };
    double percent = 100.0;
    if ((wdata->scroll_offset + row) < content_lines)
      percent = 100.0 / content_lines * (wdata->scroll_offset + row);
 
    // TODO: having the percentage right-aligned would be nice
    snprintf(title, sizeof(title), _("-- Preview (%.0f%%)"), percent);
    sbar_set_title(wdata->bar, title);
 
    if (content_lines > (wdata->scroll_offset + row))
      wdata->more_content = true;
  }
}

static int preview_color_observer(struct NotifyCallback *nc)
{
  if (nc->event_type != NT_COLOR)
    return 0;
  if (!nc->global_data || !nc->event_data)
    return -1;
 
  struct EventColor *ev_c = nc->event_data;
  struct MuttWindow *win = nc->global_data;
 
  enum ColorId cid = ev_c->cid;
 
  switch (cid)
  {
    case MT_COLOR_BOLD:
    case MT_COLOR_NORMAL:
    case MT_COLOR_STATUS:
    case MT_COLOR_MAX: // Sent on `uncolor *`
      mutt_debug(LL_DEBUG5, "color done, request WA_REPAINT\n");
      win->actions |= WA_REPAINT;
      break;
 
    default:
      break;
  }
  return 0;
}

static int preview_email_observer(struct NotifyCallback *nc)
{
  if (nc->event_type != NT_EMAIL)
    return 0;
  if (!nc->global_data)
    return -1;
 
  struct MuttWindow *win = nc->global_data;
 
  win->actions |= WA_RECALC;
  mutt_debug(LL_DEBUG5, "email done, request WA_RECALC\n");
  return 0;
}

static int preview_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_RECALC;
    mutt_debug(LL_DEBUG5, "window state done, request WA_RECALC\n");
  }
  else if (nc->event_subtype == NT_WINDOW_DELETE)
  {
    struct PreviewWindowData *wdata = win->wdata;
 
    mutt_color_observer_remove(preview_color_observer, win);
    notify_observer_remove(win->notify, preview_window_observer, win);
    notify_observer_remove(wdata->email->notify, preview_email_observer, win);
    mutt_debug(LL_DEBUG5, "window delete done\n");
  }
 
  return 0;
}

static int preview_repaint(struct MuttWindow *win)
{
  struct PreviewWindowData *wdata = win->wdata;
  draw_preview(win, wdata);
 
  mutt_debug(LL_DEBUG5, "repaint done\n");
  return 0;
}

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

struct MuttWindow *preview_window_new(struct Email *e, struct MuttWindow *bar)
{
  struct MuttWindow *win = mutt_window_new(WT_CUSTOM, MUTT_WIN_ORIENT_VERTICAL,
                                           MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                           MUTT_WIN_SIZE_UNLIMITED);
 
  mutt_color_observer_add(preview_color_observer, win);
  notify_observer_add(win->notify, NT_WINDOW, preview_window_observer, win);
  notify_observer_add(e->notify, NT_ALL, preview_email_observer, win);
 
  struct PreviewWindowData *wdata = preview_wdata_new();
  wdata->email = e;
  wdata->scroll_offset = 0;
  wdata->win = win;
  wdata->bar = bar;
 
  win->wdata = wdata;
  win->wdata_free = preview_wdata_free;
  win->recalc = preview_recalc;
  win->repaint = preview_repaint;
 
  return win;
}

static int preview_page_up(struct PreviewWindowData *wdata, const struct KeyEvent *event)
{
  if (wdata->scroll_offset <= 0)
  {
    if (event->count == 0)
      mutt_message(_("Top of message is shown"));
    return FR_NO_ACTION;
  }
 
  const int count = MAX(event->count, 1);
  const int page = MAX(wdata->win->state.rows - 1, 1);
  wdata->scroll_offset -= count * page;
  if (wdata->scroll_offset < 0)
    wdata->scroll_offset = 0;
  draw_preview(wdata->win, wdata);
 
  return FR_SUCCESS;
}

static int preview_page_down(struct PreviewWindowData *wdata, const struct KeyEvent *event)
{
  if (!wdata->more_content)
  {
    if (event->count == 0)
      mutt_message(_("Bottom of message is shown"));
    return FR_NO_ACTION;
  }
 
  const int count = MAX(event->count, 1);
  const int page = MAX(wdata->win->state.rows - 1, 1);
  wdata->scroll_offset += count * page;
  draw_preview(wdata->win, wdata);
 
  return FR_SUCCESS;
}

static const struct PreviewFunction PreviewFunctions[] = {
  // clang-format off
  { OP_PREVIEW_PAGE_DOWN, preview_page_down },
  { OP_PREVIEW_PAGE_UP,   preview_page_up   },
  { 0, NULL },
  // clang-format on
};

int preview_function_dispatcher(struct MuttWindow *win, const struct KeyEvent *event)
{
  if (!event || !win || !win->wdata)
    return FR_UNKNOWN;
 
  const int op = event->op;
  int rc = FR_UNKNOWN;
  for (size_t i = 0; PreviewFunctions[i].op != OP_NULL; i++)
  {
    const struct PreviewFunction *fn = &PreviewFunctions[i];
    if (fn->op == op)
    {
      struct PreviewWindowData *wdata = win->wdata;
      rc = fn->function(wdata, event);
      break;
    }
  }
 
  if (rc == FR_UNKNOWN) // Not our function
    return rc;
 
  const char *result = dispatcher_get_retval_name(rc);
  mutt_debug(LL_DEBUG1, "Handled %s (%d) -> %s\n", opcodes_get_name(op), op, NONULL(result));
 
  dispatcher_flush_on_error(rc);
  return rc;
}