reflow.c

Go to the documentation of this file.

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

static int non_negative(int value)
{
  return (value > 0) ? value : 0;
}

static void window_reflow_horiz(struct MuttWindow *win)
{
  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);
}

static void window_reflow_vert(struct MuttWindow *win)
{
  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);
}

void window_reflow(struct MuttWindow *win)
{
  if (!win)
    return;
  if (win->orient == MUTT_WIN_ORIENT_VERTICAL)
    window_reflow_vert(win);
  else
    window_reflow_horiz(win);
}