reflow.c File Reference

Window reflowing. More...

#include "config.h"
#include <stddef.h>
#include "mutt/lib.h"
#include "reflow.h"
#include "mutt_window.h"

Include dependency graph for reflow.c:

Go to the source code of this file.

Functions
static int	non_negative (int value)
	Clamp an integer to a non-negative value.
static void	window_reflow_horiz (struct MuttWindow *win)
	Reflow Windows using all the available horizontal space.
static void	window_reflow_vert (struct MuttWindow *win)
	Reflow Windows using all the available vertical space.
void	window_reflow (struct MuttWindow *win)
	Reflow Windows.

Detailed Description

Window reflowing.

Authors

• 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 reflow.c.

Function Documentation

non_negative()

static int non_negative ( int value )

static

Clamp an integer to a non-negative value.

Parameters

value

Number to clamp

Return values

num	Non-negative value

Definition at line 40 of file reflow.c.

{
  return (value > 0) ? value : 0;
}

Here is the caller graph for this function:

window_reflow_horiz()

static void window_reflow_horiz ( struct MuttWindow * win )

static

Reflow Windows using all the available horizontal space.

Parameters

win

Window

Definition at line 49 of file reflow.c.

{
  if (!win)
    return;
 
  int max_count = 0;
  int space = non_negative(win->state.cols);
 
  // Pass one - minimal allocation
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    if (!(*wp)->state.visible)
      continue;
 
    switch ((*wp)->size)
    {
      case MUTT_WIN_SIZE_FIXED:
      {
        const int req = non_negative((*wp)->req_cols);
        const int avail = MIN(space, req);
        (*wp)->state.cols = avail;
        (*wp)->state.rows = win->state.rows;
        space -= avail;
        break;
      }
      case MUTT_WIN_SIZE_MAXIMISE:
      {
        const int avail = (space > 0) ? 1 : 0;
        (*wp)->state.cols = avail;
        (*wp)->state.rows = win->state.rows;
        max_count++;
        space -= avail;
        break;
      }
      case MUTT_WIN_SIZE_MINIMISE:
      {
        (*wp)->state.rows = win->state.rows;
        (*wp)->state.cols = non_negative(space);
        (*wp)->state.row_offset = win->state.row_offset;
        (*wp)->state.col_offset = win->state.col_offset;
        window_reflow(*wp);
        space -= non_negative((*wp)->state.cols);
        break;
      }
    }
 
    space = non_negative(space);
  }
 
  // Pass two - sharing
  if ((max_count > 0) && (space > 0))
  {
    int alloc = (space + max_count - 1) / max_count;
    ARRAY_FOREACH(wp, &win->children)
    {
      if (space == 0)
        break;
      if (!(*wp)->state.visible)
        continue;
      if ((*wp)->size != MUTT_WIN_SIZE_MAXIMISE)
        continue;
 
      const int share = MIN(space, alloc);
      (*wp)->state.cols += share;
      space -= share;
    }
  }
 
  // Pass three - position and recursion
  int col = win->state.col_offset;
  ARRAY_FOREACH(wp, &win->children)
  {
    if (!(*wp)->state.visible)
      continue;
 
    (*wp)->state.col_offset = col;
    (*wp)->state.row_offset = win->state.row_offset;
    col += (*wp)->state.cols;
 
    window_reflow(*wp);
  }
 
  if ((space > 0) && (win->size == MUTT_WIN_SIZE_MINIMISE))
    win->state.cols = non_negative(win->state.cols - space);
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_reflow_vert()

static void window_reflow_vert ( struct MuttWindow * win )

static

Reflow Windows using all the available vertical space.

Parameters

win

Window

Definition at line 140 of file reflow.c.

{
  if (!win)
    return;
 
  int max_count = 0;
  int space = non_negative(win->state.rows);
 
  // Pass one - minimal allocation
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH(wp, &win->children)
  {
    if (!(*wp)->state.visible)
      continue;
 
    switch ((*wp)->size)
    {
      case MUTT_WIN_SIZE_FIXED:
      {
        const int req = non_negative((*wp)->req_rows);
        const int avail = MIN(space, req);
        (*wp)->state.rows = avail;
        (*wp)->state.cols = win->state.cols;
        space -= avail;
        break;
      }
      case MUTT_WIN_SIZE_MAXIMISE:
      {
        const int avail = (space > 0) ? 1 : 0;
        (*wp)->state.rows = avail;
        (*wp)->state.cols = win->state.cols;
        max_count++;
        space -= avail;
        break;
      }
      case MUTT_WIN_SIZE_MINIMISE:
      {
        (*wp)->state.rows = non_negative(space);
        (*wp)->state.cols = win->state.cols;
        (*wp)->state.row_offset = win->state.row_offset;
        (*wp)->state.col_offset = win->state.col_offset;
        window_reflow(*wp);
        space -= non_negative((*wp)->state.rows);
        break;
      }
    }
 
    space = non_negative(space);
  }
 
  // Pass two - sharing
  if ((max_count > 0) && (space > 0))
  {
    int alloc = (space + max_count - 1) / max_count;
    ARRAY_FOREACH(wp, &win->children)
    {
      if (space == 0)
        break;
      if (!(*wp)->state.visible)
        continue;
      if ((*wp)->size != MUTT_WIN_SIZE_MAXIMISE)
        continue;
 
      const int share = MIN(space, alloc);
      (*wp)->state.rows += share;
      space -= share;
    }
  }
 
  // Pass three - position and recursion
  int row = win->state.row_offset;
  ARRAY_FOREACH(wp, &win->children)
  {
    if (!(*wp)->state.visible)
      continue;
 
    (*wp)->state.row_offset = row;
    (*wp)->state.col_offset = win->state.col_offset;
    row += (*wp)->state.rows;
 
    window_reflow(*wp);
  }
 
  if ((space > 0) && (win->size == MUTT_WIN_SIZE_MINIMISE))
    win->state.rows = non_negative(win->state.rows - space);
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_reflow()

void window_reflow

(

struct MuttWindow *

win

)

Reflow Windows.

Parameters

win	Root Window

Using the rules coded into the Windows, such as Fixed or Maximise, allocate space to a set of nested Windows.

Definition at line 234 of file reflow.c.

{
  if (!win)
    return;
  if (win->orient == MUTT_WIN_ORIENT_VERTICAL)
    window_reflow_vert(win);
  else
    window_reflow_horiz(win);
}

Here is the call graph for this function:

Here is the caller graph for this function: