node_padding.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "gui/lib.h"
#include "node_padding.h"
#include "definition.h"
#include "node.h"
#include "node_condition.h"
#include "parse.h"
#include "render.h"
 
struct NodePaddingPrivate *node_padding_private_new(enum ExpandoPadType pad_type)
{
  struct NodePaddingPrivate *priv = mutt_mem_calloc(1, sizeof(struct NodePaddingPrivate));
 
  priv->pad_type = pad_type;
 
  return priv;
}
 
void node_padding_private_free(void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}
 
int pad_string(const struct ExpandoNode *node, struct Buffer *buf, int max_cols)
{
  const int pad_len = node->end - node->start;
  const int pad_cols = mutt_strnwidth(node->start, pad_len);
  int total_cols = 0;
 
  while (pad_cols <= max_cols)
  {
    buf_addstr_n(buf, node->start, pad_len);
 
    max_cols -= pad_cols;
    total_cols += pad_cols;
  }
 
  for (; (max_cols > 0); buf++, max_cols--)
  {
    buf_addch(buf, ' ');
    total_cols++;
  }
 
  return total_cols;
}
 
int node_padding_render_eol(const struct ExpandoNode *node,
                            const struct ExpandoRenderData *rdata, struct Buffer *buf,
                            int max_cols, void *data, MuttFormatFlags flags)
{
  struct ExpandoNode *left = node_get_child(node, ENP_LEFT);
 
  int total_cols = node_tree_render(left, rdata, buf, max_cols, data, flags);
 
  total_cols += pad_string(node, buf, max_cols - total_cols);
 
  return total_cols;
}
 
int node_padding_render_hard(const struct ExpandoNode *node,
                             const struct ExpandoRenderData *rdata, struct Buffer *buf,
                             int max_cols, void *data, MuttFormatFlags flags)
{
  struct Buffer *buf_left = buf_pool_get();
  struct Buffer *buf_pad = buf_pool_get();
  struct Buffer *buf_right = buf_pool_get();
 
  int cols_used = 0;
 
  struct ExpandoNode *left = node_get_child(node, ENP_LEFT);
  if (left)
    cols_used += node_tree_render(left, rdata, buf_left, max_cols - cols_used, data, flags);
 
  struct ExpandoNode *right = node_get_child(node, ENP_RIGHT);
  if (right)
    cols_used += node_tree_render(right, rdata, buf_right, max_cols - cols_used, data, flags);
 
  if (max_cols > cols_used)
    cols_used += pad_string(node, buf_pad, max_cols - cols_used);
 
  buf_addstr(buf, buf_string(buf_left));
  buf_addstr(buf, buf_string(buf_pad));
  buf_addstr(buf, buf_string(buf_right));
 
  buf_pool_release(&buf_left);
  buf_pool_release(&buf_pad);
  buf_pool_release(&buf_right);
 
  return cols_used;
}
 
int node_padding_render_soft(const struct ExpandoNode *node,
                             const struct ExpandoRenderData *rdata, struct Buffer *buf,
                             int max_cols, void *data, MuttFormatFlags flags)
{
  struct Buffer *buf_left = buf_pool_get();
  struct Buffer *buf_pad = buf_pool_get();
  struct Buffer *buf_right = buf_pool_get();
 
  int cols_used = 0;
 
  struct ExpandoNode *right = node_get_child(node, ENP_RIGHT);
  if (right)
    cols_used += node_tree_render(right, rdata, buf_right, max_cols - cols_used, data, flags);
 
  struct ExpandoNode *left = node_get_child(node, ENP_LEFT);
  if (left)
    cols_used += node_tree_render(left, rdata, buf_left, max_cols - cols_used, data, flags);
 
  if (max_cols > cols_used)
    cols_used += pad_string(node, buf_pad, max_cols - cols_used);
 
  buf_addstr(buf, buf_string(buf_left));
  buf_addstr(buf, buf_string(buf_pad));
  buf_addstr(buf, buf_string(buf_right));
 
  buf_pool_release(&buf_left);
  buf_pool_release(&buf_pad);
  buf_pool_release(&buf_right);
 
  return cols_used;
}
 
struct ExpandoNode *node_padding_new(enum ExpandoPadType pad_type,
                                     const char *start, const char *end)
{
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_PADDING;
  node->start = start;
  node->end = end;
 
  switch (pad_type)
  {
    case EPT_FILL_EOL:
      node->render = node_padding_render_eol;
      break;
    case EPT_HARD_FILL:
      node->render = node_padding_render_hard;
      break;
    case EPT_SOFT_FILL:
      node->render = node_padding_render_soft;
      break;
  };
 
  node->ndata = node_padding_private_new(pad_type);
  node->ndata_free = node_padding_private_free;
 
  return node;
}
 
struct ExpandoNode *node_padding_parse(const char *str, const char **parsed_until,
                                       int did, int uid, ExpandoParserFlags flags,
                                       struct ExpandoParseError *error)
{
  if (flags & EP_CONDITIONAL)
  {
    snprintf(error->message, sizeof(error->message),
             // L10N: Conditional Expandos can only depend on other Expandos
             //       e.g. "%<X?apple>" displays "apple" if "%X" is true.
             _("Padding cannot be used as a condition"));
    error->position = str;
    return NULL;
  }
 
  enum ExpandoPadType pt = 0;
  if (*str == '|')
  {
    pt = EPT_FILL_EOL;
  }
  else if (*str == '>')
  {
    pt = EPT_HARD_FILL;
  }
  else if (*str == '*')
  {
    pt = EPT_SOFT_FILL;
  }
  else
  {
    return NULL;
  }
  str++;
 
  const size_t consumed = mutt_mb_charlen(str, NULL);
 
  *parsed_until = str + consumed;
  return node_padding_new(pt, str, str + consumed);
}
 
void node_padding_repad(struct ExpandoNode **parent)
{
  if (!parent || !*parent)
    return;
 
  struct ExpandoNode *node = *parent;
  struct ExpandoNode *prev = NULL;
  for (; node; prev = node, node = node->next)
  {
    if (node->type == ENT_PADDING)
    {
      if (node != *parent)
        ARRAY_SET(&node->children, ENP_LEFT, *parent); // First sibling
 
      ARRAY_SET(&node->children, ENP_RIGHT, node->next); // Sibling after Padding
 
      if (prev)
        prev->next = NULL;
      node->next = NULL;
      *parent = node;
      return;
    }
 
    if (node->type == ENT_CONDITION)
    {
      struct ExpandoNode **ptr = NULL;
 
      ptr = ARRAY_GET(&node->children, ENC_TRUE);
      node_padding_repad(ptr);
 
      ptr = ARRAY_GET(&node->children, ENC_FALSE);
      node_padding_repad(ptr);
    }
  }
}