mutt_window.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdarg.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mutt_window.h"
#include "curs_lib.h"
#include "globals.h"
#include "module_data.h"
#include "mutt_curses.h"
#include "reflow.h"
#ifdef USE_DEBUG_WINDOW
#include "debug/lib.h"
#endif

static const struct Mapping WindowNames[] = {
  // clang-format off
  { "WT_ALL_DIALOGS",     WT_ALL_DIALOGS },
  { "WT_CONTAINER",       WT_CONTAINER },
  { "WT_CUSTOM",          WT_CUSTOM },
  { "WT_DLG_ALIAS",       WT_DLG_ALIAS },
  { "WT_DLG_ATTACH",      WT_DLG_ATTACH },
  { "WT_DLG_AUTOCRYPT",   WT_DLG_AUTOCRYPT },
  { "WT_DLG_BROWSER",     WT_DLG_BROWSER },
  { "WT_DLG_CERTIFICATE", WT_DLG_CERTIFICATE },
  { "WT_DLG_COMPOSE",     WT_DLG_COMPOSE },
  { "WT_DLG_GPGME",       WT_DLG_GPGME },
  { "WT_DLG_HISTORY",     WT_DLG_HISTORY },
  { "WT_DLG_INDEX",       WT_DLG_INDEX },
  { "WT_DLG_LIST",        WT_DLG_LIST },
  { "WT_DLG_PAGER",       WT_DLG_PAGER },
  { "WT_DLG_PATTERN",     WT_DLG_PATTERN },
  { "WT_DLG_PGP",         WT_DLG_PGP },
  { "WT_DLG_POSTPONE",    WT_DLG_POSTPONE },
  { "WT_DLG_QUERY",       WT_DLG_QUERY },
  { "WT_DLG_SMIME",       WT_DLG_SMIME },
  { "WT_HELP_BAR",        WT_HELP_BAR },
  { "WT_INDEX",           WT_INDEX },
  { "WT_MENU",            WT_MENU },
  { "WT_MESSAGE",         WT_MESSAGE },
  { "WT_PAGER",           WT_PAGER },
  { "WT_ROOT",            WT_ROOT },
  { "WT_SIDEBAR",         WT_SIDEBAR },
  { "WT_STATUS_BAR",      WT_STATUS_BAR },
  { NULL, 0 },
  // clang-format on
};

static bool window_was_visible(struct MuttWindow *win)
{
  if (!win)
    return false;
 
  for (; win; win = win->parent)
  {
    if (!win->old.visible)
      return false;
  }
 
  return true;
}

static void window_notify(struct MuttWindow *win)
{
  if (!win->notify)
    return;
 
  const struct WindowState *old = &win->old;
  const struct WindowState *wstate = &win->state;
  WindowNotifyFlags flags = WN_NONE;
 
  const bool was_visible = window_was_visible(win);
  const bool is_visible = mutt_window_is_visible(win);
  if (was_visible != is_visible)
    flags |= is_visible ? WN_VISIBLE : WN_HIDDEN;
 
  if ((wstate->row_offset != old->row_offset) || (wstate->col_offset != old->col_offset))
    flags |= WN_MOVED;
 
  if (wstate->rows > old->rows)
    flags |= WN_TALLER;
  else if (wstate->rows < old->rows)
    flags |= WN_SHORTER;
 
  if (wstate->cols > old->cols)
    flags |= WN_WIDER;
  else if (wstate->cols < old->cols)
    flags |= WN_NARROWER;
 
  if (flags == WN_NONE)
    return;
 
  mutt_debug(LL_NOTIFY, "NT_WINDOW_STATE: %s, %p\n", mutt_window_win_name(win),
             (void *) win);
  struct EventWindow ev_w = { win, flags };
  notify_send(win->notify, NT_WINDOW, NT_WINDOW_STATE, &ev_w);
}

void window_notify_all(struct MuttWindow *win)
{
  if (!win)
  {
    struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
    win = mod_data ? mod_data->root_window : NULL;
  }
  if (!win)
    return;
 
  window_notify(win);
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    window_notify_all(*wp);
  }
  win->old = win->state;
}

void window_set_visible(struct MuttWindow *win, bool visible)
{
  if (!win)
  {
    struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
    win = mod_data ? mod_data->root_window : NULL;
  }
  if (!win)
    return;
 
  win->state.visible = visible;
}

struct MuttWindow *mutt_window_new(enum WindowType type, enum MuttWindowOrientation orient,
                                   enum MuttWindowSize size, int cols, int rows)
{
  struct MuttWindow *win = MUTT_MEM_CALLOC(1, struct MuttWindow);
 
  win->type = type;
  win->orient = orient;
  win->size = size;
  win->req_rows = rows;
  win->req_cols = cols;
  win->state.visible = true;
  win->notify = notify_new();
  ARRAY_INIT(&win->children);
 
  win->actions |= WA_RECALC | WA_REPAINT;
 
  return win;
}

void mutt_window_free(struct MuttWindow **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct MuttWindow *win = *ptr;
 
  if (win->parent && (win->parent->focus == win))
    win->parent->focus = NULL;
 
  mutt_debug(LL_NOTIFY, "NT_WINDOW_DELETE: %s, %p\n", mutt_window_win_name(win),
             (void *) win);
  struct EventWindow ev_w = { win, WN_NONE };
  notify_send(win->notify, NT_WINDOW, NT_WINDOW_DELETE, &ev_w);
 
  mutt_winlist_free(&win->children);
 
  if (win->wdata_free && win->wdata)
    win->wdata_free(win, &win->wdata); // Custom function to free private data
 
  notify_free(&win->notify);
 
  FREE(ptr);
}

void mutt_window_clearline(struct MuttWindow *win, int row)
{
  mutt_window_move(win, row, 0);
  mutt_window_clrtoeol(win);
}

void mutt_window_clrtoeol(struct MuttWindow *win)
{
  if (!win || !stdscr)
    return;
 
  if ((win->state.col_offset + win->state.cols) == COLS)
  {
    clrtoeol();
  }
  else
  {
    int row = 0;
    int col = 0;
    getyx(stdscr, row, col);
    int curcol = col;
    while (curcol < (win->state.col_offset + win->state.cols))
    {
      addch(' ');
      curcol++;
    }
    move(row, col);
  }
}

void mutt_window_get_coords(struct MuttWindow *win, int *row, int *col)
{
  int x = 0;
  int y = 0;
 
  getyx(stdscr, y, x);
  if (col)
    *col = x - win->state.col_offset;
  if (row)
    *row = y - win->state.row_offset;
}

int mutt_window_move(struct MuttWindow *win, int row, int col)
{
  return move(win->state.row_offset + row, win->state.col_offset + col);
}

void mutt_window_reflow(struct MuttWindow *win)
{
  if (!OptGui)
    return;
 
  if (!win)
  {
    struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
    win = mod_data ? mod_data->root_window : NULL;
  }
  if (!win)
    return;
 
  window_reflow(win);
  window_notify_all(win);
 
  // Allow Windows to resize themselves based on the first reflow
  window_reflow(win);
  window_notify_all(win);
 
#ifdef USE_DEBUG_WINDOW
  debug_win_dump();
#endif
}

int mutt_window_wrap_cols(int width, short wrap)
{
  if (wrap < 0)
    return (width > -wrap) ? (width + wrap) : width;
  if (wrap)
    return (wrap < width) ? wrap : width;
  return width;
}

int mutt_window_addch(struct MuttWindow *win, int ch)
{
  return addch(ch);
}

int mutt_window_addnstr(struct MuttWindow *win, const char *str, int num)
{
  if (!str)
    return -1;
 
  return addnstr(str, num);
}

int mutt_window_addstr(struct MuttWindow *win, const char *str)
{
  if (!str)
    return -1;
 
  return addstr(str);
}

int mutt_window_printf(struct MuttWindow *win, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  int rc = vw_printw(stdscr, fmt, ap);
  va_end(ap);
 
  return rc;
}

void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
{
  if (!parent || !child)
    return;
 
  ARRAY_ADD(&parent->children, child);
  child->parent = parent;
 
  notify_set_parent(child->notify, parent->notify);
 
  mutt_debug(LL_NOTIFY, "NT_WINDOW_NEW: %s, %p\n", mutt_window_win_name(child),
             (void *) child);
  struct EventWindow ev_w = { child, WN_NONE };
  notify_send(child->notify, NT_WINDOW, NT_WINDOW_ADD, &ev_w);
}

struct MuttWindow *mutt_window_remove_child(struct MuttWindow *parent, struct MuttWindow *child)
{
  if (!parent || !child)
    return NULL;
 
  // A notification will be sent when the Window is freed
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &parent->children)
  {
    if (*wp == child)
    {
      ARRAY_REMOVE(&parent->children, wp);
      break;
    }
  }
  child->parent = NULL;
 
  if (parent->focus == child)
    parent->focus = NULL;
 
  notify_set_parent(child->notify, NULL);
 
  return child;
}

void mutt_winlist_free(struct MuttWindowArray *wa)
{
  if (!wa)
    return;
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, wa)
  {
    struct MuttWindow *win = *wp;
    mutt_winlist_free(&win->children);
    mutt_window_free(&win);
  }
  ARRAY_FREE(wa);
}

bool mutt_window_is_visible(struct MuttWindow *win)
{
  if (!win)
    return false;
 
  for (; win; win = win->parent)
  {
    if (!win->state.visible)
      return false;
  }
 
  return true;
}

struct MuttWindow *window_find_child(struct MuttWindow *win, enum WindowType type)
{
  if (!win)
    return NULL;
  if (win->type == type)
    return win;
 
  struct MuttWindow **wp = NULL;
  struct MuttWindow *match = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    match = window_find_child(*wp, type);
    if (match)
      return match;
  }
 
  return NULL;
}

struct MuttWindow *window_find_parent(struct MuttWindow *win, enum WindowType type)
{
  for (; win; win = win->parent)
  {
    if (win->type == type)
      return win;
  }
 
  return NULL;
}

static void window_recalc(struct MuttWindow *win)
{
  if (!win || !win->state.visible)
    return;
 
  if (win->recalc && (win->actions & WA_RECALC))
    win->recalc(win);
  win->actions &= ~WA_RECALC;
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    window_recalc(*wp);
  }
}

static void window_repaint(struct MuttWindow *win)
{
  if (!win || !win->state.visible)
    return;
 
  if (win->repaint && (win->actions & WA_REPAINT))
    win->repaint(win);
  win->actions &= ~WA_REPAINT;
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    window_repaint(*wp);
  }
}

static void window_recursor(void)
{
  // Give the focused window an opportunity to set the cursor position
  struct MuttWindow *win = window_get_focus();
  if (!win)
    return;
 
  if (win->recursor && win->recursor(win))
    return;
 
  mutt_curses_set_cursor(MUTT_CURSOR_INVISIBLE);
}

void window_redraw(struct MuttWindow *win)
{
  if (!win)
  {
    struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
    win = mod_data ? mod_data->root_window : NULL;
  }
  if (!win)
    return;
 
  window_reflow(win);
  window_notify_all(win);
 
  window_recalc(win);
  window_repaint(win);
  window_recursor();
 
  mutt_refresh();
}

bool window_is_focused(const struct MuttWindow *win)
{
  if (!win)
    return false;
 
  struct MuttWindow *win_focus = window_get_focus();
 
  return (win_focus == win);
}

struct MuttWindow *window_get_focus(void)
{
  struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  struct MuttWindow *win = mod_data ? mod_data->root_window : NULL;
 
  while (win && win->focus)
    win = win->focus;
 
  return win;
}

struct MuttWindow *window_set_focus(struct MuttWindow *win)
{
  if (!win)
    return NULL;
 
  struct MuttWindow *old_focus = window_get_focus();
 
  struct MuttWindow *parent = win->parent;
  struct MuttWindow *child = win;
 
  // Set the chain of focus, all the way to the root
  for (; parent; child = parent, parent = parent->parent)
    parent->focus = child;
 
  win->focus = NULL;
 
  if (win == old_focus)
    return NULL;
 
  mutt_debug(LL_NOTIFY, "NT_WINDOW_FOCUS: %s, %p\n", mutt_window_win_name(win),
             (void *) win);
  struct EventWindow ev_w = { win, WN_NONE };
  notify_send(win->notify, NT_WINDOW, NT_WINDOW_FOCUS, &ev_w);
#ifdef USE_DEBUG_WINDOW
  debug_win_dump();
#endif
 
  return old_focus;
}

void mutt_window_clear(struct MuttWindow *win)
{
  if (!mutt_window_is_visible(win))
    return;
 
  for (int i = 0; i < win->state.rows; i++)
    mutt_window_clearline(win, i);
}

const char *mutt_window_win_name(const struct MuttWindow *win)
{
  if (!win)
    return "UNKNOWN";
 
  const char *name = mutt_map_get_name(win->type, WindowNames);
  if (name)
    return name;
  return "UNKNOWN";
}

static void window_invalidate(struct MuttWindow *win)
{
  if (!win)
    return;
 
  win->actions |= WA_RECALC | WA_REPAINT;
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    window_invalidate(*wp);
  }
}

void window_invalidate_all(void)
{
  struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  window_invalidate(mod_data ? mod_data->root_window : NULL);
  clearok(stdscr, true);
  keypad(stdscr, true);
}

bool window_status_on_top(struct MuttWindow *panel, const struct ConfigSubset *sub)
{
  const bool c_status_on_top = cs_subset_bool(sub, "status_on_top");
 
  struct MuttWindow **wp_first = ARRAY_FIRST(&panel->children);
  if (!wp_first)
    return false;
 
  struct MuttWindow *win = *wp_first;
 
  if ((c_status_on_top && (win->type == WT_STATUS_BAR)) ||
      (!c_status_on_top && (win->type != WT_STATUS_BAR)))
  {
    return false;
  }
 
  if (c_status_on_top)
  {
    // Move last window to front
    struct MuttWindow **wp_last = ARRAY_LAST(&panel->children);
    if (wp_last)
    {
      win = *wp_last;
      ARRAY_REMOVE(&panel->children, wp_last);
      ARRAY_INSERT(&panel->children, 0, win);
    }
  }
  else
  {
    // Move first window to end
    ARRAY_REMOVE(&panel->children, wp_first);
    ARRAY_ADD(&panel->children, win);
  }
 
  mutt_window_reflow(panel);
  window_invalidate_all();
  return true;
}

bool mutt_window_swap(struct MuttWindow *parent, struct MuttWindow *win1,
                      struct MuttWindow *win2)
{
  if (!parent || !win1 || !win2)
    return false;
 
  // ensure both windows are children of the parent
  if (win1->parent != parent || win2->parent != parent)
    return false;
 
  // Find indices of both windows
  int idx1 = -1;
  int idx2 = -1;
  struct MuttWindow **wp = NULL;
  int idx = 0;
  ARRAY_FOREACH(wp, &parent->children)
  {
    if (*wp == win1)
      idx1 = idx;
    if (*wp == win2)
      idx2 = idx;
    if ((idx1 != -1) && (idx2 != -1))
      break; // Early exit when both windows found
    idx++;
  }
 
  if (idx1 == -1 || idx2 == -1)
    return false;
 
  // Swap the pointers in the array
  struct MuttWindow **ptr1 = ARRAY_GET(&parent->children, idx1);
  struct MuttWindow **ptr2 = ARRAY_GET(&parent->children, idx2);
  if (ptr1 && ptr2)
  {
    struct MuttWindow *tmp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = tmp;
  }
 
  return true;
}