#include "definition.h"

Include dependency graph for node_padding.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	NodePaddingPrivate
	Private data for a Padding Node -. More...

Enumerations
enum	ExpandoPadType { EPT_FILL_EOL , EPT_HARD_FILL , EPT_SOFT_FILL }
	Padding type. More...

enum	ENPad { ENP_LEFT , ENP_RIGHT }
	Names for the Padding's children. More...

Functions
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 **parent)
	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.h.

Enumeration Type Documentation

◆ ExpandoPadType

enum ExpandoPadType

Padding type.

Padding occurs between two sides, left and right. The type of Padding, soft or hard, refers to how the left-hand-side will react if there's too little space.

Hard padding: The left-hand-side will fixed and the right-hand-side will be truncated. Soft padding: The right-hand-side will be fixed and the left-hand-side will be truncated.

Enumerator
EPT_FILL_EOL	Fill to the end-of-line.
EPT_HARD_FILL	Hard-fill: left-hand-side will be truncated.
EPT_SOFT_FILL	Soft-fill: right-hand-side will be truncated.

Definition at line 43 of file node_padding.h.

{
  EPT_FILL_EOL,     
  EPT_HARD_FILL,    
  EPT_SOFT_FILL,    
};

◆ ENPad

enum ENPad

Names for the Padding's children.

Padding has two children: Left and Right.

Enumerator
ENP_LEFT	Index of Left-Hand Nodes.
ENP_RIGHT	Index of Right-Hand Nodes.

Definition at line 55 of file node_padding.h.

{
  ENP_LEFT,           
  ENP_RIGHT,          
};

Function Documentation

◆ 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_np > 0)
    {
      for (int i = 0; i < ARRAY_FOREACH_IDX_np; i++)
      {
        node_add_child(node_left, node_get_child(parent, i));
      }
    }
 
    size_t count = ARRAY_SIZE(&parent->children);
    if ((ARRAY_FOREACH_IDX_np + 1) < count)
    {
      for (int i = ARRAY_FOREACH_IDX_np + 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:

Data Structures