node_padding.c File Reference

Expando Node for Padding. More...

#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_container.h"
#include "parse.h"
#include "render.h"

Include dependency graph for node_padding.c:

Go to the source code of this file.

Functions
struct NodePaddingPrivate *	node_padding_private_new (enum ExpandoPadType pad_type)
	Create new Padding private data.
void	node_padding_private_free (void **ptr)
	Free Padding private data - Implements ExpandoNode::ndata_free()
int	pad_string (const struct ExpandoNode *node, struct Buffer *buf, int max_cols)
	Pad a buffer with a character.
int	node_padding_render_eol (const struct ExpandoNode *node, const struct ExpandoRenderData *rdata, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render End-of-Line Padding - Implements ExpandoNode::render() -.
int	node_padding_render_hard (const struct ExpandoNode *node, const struct ExpandoRenderData *rdata, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render Hard Padding - Implements ExpandoNode::render() -.
int	node_padding_render_soft (const struct ExpandoNode *node, const struct ExpandoRenderData *rdata, struct Buffer *buf, int max_cols, void *data, MuttFormatFlags flags)
	Render Soft Padding - Implements ExpandoNode::render() -.
struct ExpandoNode *	node_padding_new (enum ExpandoPadType pad_type, const char *start, const char *end)
	Creata new Padding ExpandoNode.
struct ExpandoNode *	node_padding_parse (const char *str, struct ExpandoFormat *fmt, int did, int uid, ExpandoParserFlags flags, const char **parsed_until, struct ExpandoParseError *err)
	Parse a Padding Expando - Implements ExpandoDefinition::parse() -.
void	node_padding_repad (struct ExpandoNode **ptr)
	Rearrange Padding in a tree of ExpandoNodes.

Detailed Description

Expando Node for Padding.

Authors

• Tóth János
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file node_padding.c.

Function Documentation

node_padding_private_new()

struct NodePaddingPrivate * node_padding_private_new

(

enum ExpandoPadType

pad_type

)

Create new Padding private data.

Parameters

pad_type

Padding type

Return values

ptr	New Padding private data

Definition at line 47 of file node_padding.c.

{
  struct NodePaddingPrivate *priv = MUTT_MEM_CALLOC(1, struct NodePaddingPrivate);
 
  priv->pad_type = pad_type;
 
  return priv;
}

Here is the caller graph for this function:

node_padding_private_free()

void node_padding_private_free

(

void **

ptr

)

Free Padding private data - Implements ExpandoNode::ndata_free()

Parameters

ptr	Data to free

Definition at line 60 of file node_padding.c.

{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}

Here is the caller graph for this function:

pad_string()

int pad_string	(	const struct ExpandoNode *	node,
		struct Buffer *	buf,
		int	max_cols
	)

Pad a buffer with a character.

Parameters

node	Node with padding type
buf	Buffer to populate
max_cols	Number of screen columns available

Fill buf with the padding char (Node.start) to a maximum of max_cols screen cells.

Definition at line 76 of file node_padding.c.

{
  const int pad_len = mutt_str_len(node->text);
  const int pad_cols = mutt_strnwidth(node->text, pad_len);
  int total_cols = 0;
 
  if (pad_len != 0)
  {
    while (pad_cols <= max_cols)
    {
      buf_addstr_n(buf, node->text, pad_len);
 
      max_cols -= pad_cols;
      total_cols += pad_cols;
    }
  }
 
  if (max_cols > 0)
  {
    buf_add_printf(buf, "%*s", max_cols, "");
    total_cols += max_cols;
  }
 
  return total_cols;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_padding_new()

struct ExpandoNode * node_padding_new	(	enum ExpandoPadType	pad_type,
		const char *	start,
		const char *	end
	)

Creata new Padding ExpandoNode.

Parameters

pad_type	Padding type
start	Start of padding character
end	End of padding character

Return values

ptr	New Padding ExpandoNode

Definition at line 201 of file node_padding.c.

{
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_PADDING;
  node->text = mutt_strn_dup(start, end - start);
 
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

node_padding_repad()

void node_padding_repad

(

struct ExpandoNode **

ptr

)

Rearrange Padding in a tree of ExpandoNodes.

Parameters

ptr	Parent Node

Definition at line 291 of file node_padding.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct ExpandoNode *parent = *ptr;
  struct ExpandoNode **np = NULL;
  ARRAY_FOREACH(np, &parent->children)
  {
    if (!np || !*np)
      continue;
 
    // Repad any children, recursively
    node_padding_repad(np);
 
    struct ExpandoNode *node = *np;
    if (node->type != ENT_PADDING)
      continue;
 
    struct ExpandoNode *node_left = node_container_new();
    struct ExpandoNode *node_right = node_container_new();
 
    if (ARRAY_FOREACH_IDX > 0)
    {
      for (int i = 0; i < ARRAY_FOREACH_IDX; i++)
      {
        node_add_child(node_left, node_get_child(parent, i));
      }
    }
 
    size_t count = ARRAY_SIZE(&parent->children);
    if ((ARRAY_FOREACH_IDX + 1) < count)
    {
      for (int i = ARRAY_FOREACH_IDX + 1; i < count; i++)
      {
        node_add_child(node_right, node_get_child(parent, i));
      }
    }
 
    // All the children have been transferred
    ARRAY_FREE(&parent->children);
 
    node_add_child(node, node_left);
    node_add_child(node, node_right);
 
    node_add_child(parent, node);
 
    break; // Only repad the first padding node
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: