dorne/cursetree/cursetree.c

#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include "curse.h"
#include "ncurses.h"
#include "cursetree.h"

/* Internal allocator method for crs_node structures.
 */
static inline struct crs_node *__alloc_node(const enum crs_nodetype type) {
  struct crs_node *node = (struct crs_node *)malloc(sizeof(struct crs_node));
  node->type = type;
  return node;
}

/* Construct a new window node (crs_node of type NODE_WIN).
 */
static struct crs_node *init_window_node(WINDOW *const win) {
  struct crs_node *node = __alloc_node(NODE_WINDOW);
  node->win = win;

  return node;
}

static struct crs_node *
auto_window_node(const struct crs_nodedims *const dims) {
  WINDOW *win = newwin(dims->height, dims->width, dims->y, dims->x);
  return init_window_node(win);
}

static struct crs_node *init_abstract_node(struct crs_node *const node0,
                                           struct crs_node *const node1,
                                           const enum crs_axis axis,
                                           const float ratio,
                                           struct crs_nodedims *const dims) {
  struct crs_node *node = __alloc_node(NODE_ABSTRACT);
  node->axis = axis;
  node->ratio = ratio;
  node->dims = dims;

  node->child[0] = node0;
  node->child[1] = node1;
  return node;
}

static void destroy_node(struct crs_node *const node) {
  if (node->type == NODE_WINDOW) {
    /* Window Node */
    delwin(node->win);
    goto end;
  }
  /* Abstract Node */
  assert(node->type == NODE_ABSTRACT);
  destroy_node(node->child[0]);
  destroy_node(node->child[1]);
  free(node->dims);

end:
  free(node);
}

static inline struct crs_nodedims *__alloc_dims(int x, int y, int width,
                                                int height) {
  struct crs_nodedims *dims;

  dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
  *dims = (struct crs_nodedims){
      .x = x,
      .y = y,
      .width = width,
      .height = height,
  };
  return dims;
}

static inline struct crs_nodedims *
__dup_dims(const struct crs_nodedims *const dims) {
  struct crs_nodedims *dup;
  dup = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
  memcpy(dup, dims, sizeof(struct crs_nodedims));

  return dup;
}

static inline struct crs_nodedims *termdims(void) {
  struct crs_nodedims *dims = __alloc_dims(0, 0, 0, 0);
  termsize(dims->width, dims->height);

  return dims;
}

static inline void nodesize(const struct crs_node *const node, int *const width,
                            int *const height) {
  if (node->type == NODE_WINDOW) {
    /* Window Node */
    getmaxyx(node->win, *height, *width);
  } else {
    /* Abstract Node */
    assert(node->type == NODE_ABSTRACT);
    *width = node->dims->width;
    *height = node->dims->height;
  }
}

static inline struct crs_nodedims *nodedims(const struct crs_node *const node) {
  struct crs_nodedims *dims;
  if (node->type == NODE_WINDOW) {
    /* Window Node */
    dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
    getbegyx(node->win, dims->y, dims->x);
    getmaxyx(node->win, dims->height, dims->width);
  } else {
    /* Abstract Node */
    assert(node->type == NODE_ABSTRACT);
    dims = __dup_dims(node->dims);
  }

  return dims;
}

/* Calculate the dimensions for nodes resulting from a bifurcation.
 * Returns 0 on success, and 1 on failure if any width/height are 0 characters.
 * WARNING: This function does not guarantee the x,y positions returned
 * WARNING: are valid screen coordinates.
 */
static int bifurcate_dims(const struct crs_nodedims *const parent_dims,
                          const enum crs_axis axis, const float ratio,
                          struct crs_nodedims **const dims0,
                          struct crs_nodedims **const dims1) {
  assert(0 < ratio && ratio < 1);
  struct crs_nodedims *_dims0, *_dims1;

  _dims0 = __dup_dims(parent_dims);
  _dims1 = __dup_dims(parent_dims);

  if (axis == AXIS_X) {
    _dims0->width *= ratio;
    _dims1->width -= _dims0->width;
    _dims1->x += _dims0->width;
  } else {
    _dims0->height *= ratio;
    _dims1->height -= _dims0->height;
    _dims1->y += _dims0->height;
  }

  if (!_dims0->width || !_dims0->height || !_dims1->width || !_dims1->height)
    return 1;

  // propagate bifurcated dimensions
  *dims0 = _dims0;
  *dims1 = _dims1;
  return 0;
}

/* NOTE: resize_node calls wnoutrefresh(3x), which expects
 * NOTE: a call doupdate(3x) call afterwards to flush ncurses
 * NOTE: virtual screen to the physical screen.
 */
static void resize_node(struct crs_node *const node,
                        struct crs_nodedims *const new_dims) {
  if (node->type == NODE_WINDOW) {
    /* Window Node */
    resizemv_window(new_dims->x, new_dims->y, new_dims->width, new_dims->height,
                    node->win);
    free(new_dims);

    wnoutrefresh(node->win);
  } else {
    /* Abstract Node */
    assert(node->type == NODE_ABSTRACT);
    struct crs_nodedims *dims0, *dims1;

    free(node->dims);
    node->dims = new_dims;
    bifurcate_dims(new_dims, node->axis, node->ratio, &dims0, &dims1);

    resize_node(node->child[0], dims0);
    resize_node(node->child[1], dims1);
  }
}

/* Subdivide a window node's allocated region into two window nodes
 * replacing the original node with an abstract node.
 * Parameters:
 *   axis   - controls which direction the subdivision occurs
 *   invert_axis - invert index of the original node in the new abstract node
 */
void bifurcate_window_node(struct crs_node **const node,
                           const enum crs_axis axis, const int invert_axis,
                           const float ratio) {
  assert((*node)->type == NODE_WINDOW);
  struct crs_nodedims *dims0, *dims1;
  struct crs_node *node0, *node1;

  struct crs_nodedims *original_dims = nodedims(*node);
  if (bifurcate_dims(original_dims, axis, ratio, &dims0, &dims1)) {
    /* TODO: handle this error properly */
    free(original_dims);
    exit(1);
    return;
  }

  if (invert_axis) {
    /* Inverted Bifurcation */
    node0 = auto_window_node(dims0);
    node1 = *node;
    resize_node(node1, dims1);
  } else {
    /* Non-Inverted Bifurcation */
    node0 = *node;
    node1 = auto_window_node(dims1);
    resize_node(node0, dims0);
  }

  *node = init_abstract_node(node0, node1, axis, ratio, original_dims);
}

/* Collapse an abstract node, killing one child node and resizing
 * the other to take its place.
 */
static void collapse_abstract_node(struct crs_node **const node,
                                   const int collapse_i) {
  assert((*node)->type == NODE_ABSTRACT);
  assert(0 <= collapse_i && collapse_i < NODE_CHILD_N);

  // WARNING: only works for NODE_CHILD_N=2 (binary trees)
  destroy_node((*node)->child[!collapse_i]);

  struct crs_node *collapse_target = (*node)->child[collapse_i];
  free(*node);
  *node = collapse_target;
}

/*
 */
static struct crs_node *init_root_node(void) {
  WINDOW *rootwin;

  rootwin = root_window();
  return init_window_node(rootwin);
}

int ct_init(struct crs_tree **const tree) {
  *tree = (struct crs_tree *)malloc(sizeof(struct crs_tree));

  /* Initialise NCurses Library & Root Node */
  init_ncurses();
  (*tree)->root = init_root_node();

  return EXIT_SUCCESS;
}

void destroy_tree(struct crs_tree *const tree) {
  destroy_node(tree->root);
  endwin();
  free(tree);
}

void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims) {
  resize_node(tree->root, dims);
}

void ct_update(struct crs_tree *const tree) {
  struct crs_nodedims * term_dims;
  int term_width, term_height;
  const int key = wgetch(curscr);

  /* ncurses binds a SIGWINCH handler if SIGWINCH has SIG_DFL disposition
   * when initscr(3x) is called. This handler emits KEY_RESIZE (decimal 410) to stdin.
   * REF: manpages -> resizeterm(3x) initscr(3x) wgetch(3x)
   */
  switch (key) {
  case -1:
    wclear(tree->root->child[0]->win);
    mvwprintw(tree->root->child[0]->win, 0, 0, "    \r-1\n");
    wrefresh(tree->root->child[0]->win);
    return;
  case KEY_RESIZE:
    termsize(term_width, term_height);
    term_dims = __alloc_dims(0, 0, term_width, term_height);
    resize_tree(tree, term_dims);
    // flush ncurses virtual screen -> physical screen
    doupdate();
    break;
  default:
    wclear(tree->root->child[0]->win);
    mvwprintw(tree->root->child[0]->win, 0, 0, "    \r%d\n", key);
    wrefresh(tree->root->child[0]->win);
    break;
  }
}