tree.c File Reference

#include "internal.h"

Include dependency graph for tree.c:

Go to the source code of this file.

Data Structures
struct	nctree_int_item
struct	nctree

Typedefs
typedef struct nctree_int_item	nctree_int_item
typedef struct nctree	nctree

Functions
	__attribute__ ((unused))
int	nctree_add (nctree *n, const unsigned *spec, const struct nctree_item *add)
int	nctree_del (nctree *n, const unsigned *spec)
nctree *	nctree_create (ncplane *n, const nctree_options *opts)
void	nctree_destroy (nctree *n)
ncplane *	nctree_plane (nctree *n)
void *	nctree_prev (nctree *n)
void *	nctree_next (nctree *n)
int	nctree_redraw (nctree *n)
bool	nctree_offer_input (nctree *n, const ncinput *ni)
void *	nctree_focused (nctree *n)
void *	nctree_goto (nctree *n, const unsigned *spec, int *failspec)

Typedef Documentation

nctree

typedef struct nctree nctree

nctree_int_item

typedef struct nctree_int_item nctree_int_item

Function Documentation

__attribute__()

__attribute__

(

(unused)

)

Definition at line 44 of file tree.c.

                             {
  unsigned* path = malloc(sizeof(*path) * (n->maxdepth + 2));
  path[0] = UINT_MAX;
  nctree_debug_internal(&n->items, path, 0);
  free(path);
}

Here is the call graph for this function:

nctree_add()

int nctree_add	(	nctree *	n,
		const unsigned *	spec,
		const struct nctree_item *	add
	)

Definition at line 209 of file tree.c.

                                                                              {
  // it's illegal to pass an empty path for addition; one must pass { 0, UINT_MAX }
  if(spec[0] == UINT_MAX){
    logerror("invalid empty path");
    return -1;
  }
  if(add->subs){
    logerror("invalid subs %p", add->subs);
    return -1;
  }
  if(add->subcount){
    logerror("invalid subcount %u", add->subcount);
    return -1;
  }
  if(nctree_add_internal(n, &n->items, spec, add)){
    return -1;
  }
  if(n->activerow == -1){
    n->activerow = 0;
    n->curitem = &n->items.subs[0];
    n->currentpath = malloc(sizeof(*n->currentpath) * 3);
    n->currentpath[0] = 0;
    n->currentpath[1] = UINT_MAX;
    n->maxdepth = 1;
  }
  return 0;
}

nctree_create()

nctree * nctree_create	(	ncplane *	n,
		const nctree_options *	opts
	)

Definition at line 266 of file tree.c.

                                                             {
  if(opts->flags){
    logwarn("passed invalid flags 0x%016" PRIx64, opts->flags);
  }
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    logerror("can't use the standard plane");
    goto error;
  }
  if(opts->nctreecb == NULL){
    logerror("can't use NULL callback");
    goto error;
  }
  if(opts->indentcols < 0){
    logerror("can't indent negative columns");
    goto error;
  }
  nctree* ret = nctree_inner_create(n, opts);
  if(ret == NULL){
    logerror("couldn't prepare nctree");
    goto error;
  }
  return ret;
 
error:
  ncplane_destroy(n);
  return NULL;
}

Here is the call graph for this function:

nctree_del()

int nctree_del	(	nctree *	n,
		const unsigned *	spec
	)

Definition at line 237 of file tree.c.

                                               {
  nctree_int_item* parent = NULL;
  nctree_int_item* nii = &n->items;
  const unsigned* p = spec;
  while(*p != UINT_MAX){
    if(*p >= nii->subcount){
      logerror("invalid path element (%u >= %u)", *p, nii->subcount);
      return -1;
    }
    parent = nii;
    nii = &nii->subs[*p];
    ++p;
  }
  free_tree_items(nii);
  if(parent){
    // parent can only be defined if we had at least one path element
    unsigned lastelem = spec[-1];
    if(lastelem != --parent->subcount){
      memmove(&parent->subs[lastelem], &parent->subs[lastelem + 1],
              sizeof(*parent->subs) * (parent->subcount - lastelem));
    }
  }
  if(n->items.subcount == 0){
    n->activerow = -1;
    n->curitem = NULL;
  }
  return 0;
}

nctree_destroy()

void nctree_destroy

(

nctree *

n

)

Definition at line 294 of file tree.c.

                              {
  if(n){
    free_tree_items(&n->items);
    free(n->currentpath);
    free(n);
  }
}

Here is the call graph for this function:

nctree_focused()

void * nctree_focused

(

nctree *

n

)

Definition at line 606 of file tree.c.

                               {
  return n->curitem->curry;
}

nctree_goto()

void * nctree_goto	(	nctree *	n,
		const unsigned *	spec,
		int *	failspec
	)

Definition at line 610 of file tree.c.

                                                                 {
  n->activerow = 0;
  (void)spec;
  (void)failspec;
  // FIXME
  return NULL;
}

nctree_next()

void * nctree_next

(

nctree *

n

)

Definition at line 396 of file tree.c.

                            {
  int rows = 0;
  if(n->curitem->ncp){
    rows = ncplane_dim_y(n->curitem->ncp);
  }
  nctree_int_item* tmp = nctree_next_internal(n, n->currentpath);
  if(tmp != n->curitem){
    n->curitem = tmp;
    n->activerow += rows;
    if(n->activerow >= (int)ncplane_dim_y(n->items.ncp)){
      n->activerow = ncplane_dim_y(n->items.ncp) - 1;
    }
  }
  return n->curitem->curry;
}

Here is the caller graph for this function:

nctree_offer_input()

bool nctree_offer_input	(	nctree *	n,
		const ncinput *	ni
	)

Definition at line 579 of file tree.c.

                                                     {
  if(ni->evtype == NCTYPE_RELEASE){
    return false;
  }
  if(ni->id == NCKEY_UP){
    nctree_prev(n);
    return true;
  }else if(ni->id == NCKEY_DOWN){
    nctree_next(n);
    return true;
  }else if(ni->id == NCKEY_PGUP){
    nctree_prev(n); // more FIXME
    return true;
  }else if(ni->id == NCKEY_PGDOWN){
    nctree_next(n); // more FIXME
    return true;
  }else if(ni->id == NCKEY_HOME){
    goto_first_item(n);
    return true;
  }else if(ni->id == NCKEY_END){
    goto_last_item(n);
    return true;
  }
  // FIXME implement left, right, +, - (expand/collapse)
  return false;
}

Here is the call graph for this function:

nctree_plane()

ncplane * nctree_plane

(

nctree *

n

)

Definition at line 303 of file tree.c.

                                {
  return n->items.ncp;
}

nctree_prev()

void * nctree_prev

(

nctree *

n

)

Definition at line 349 of file tree.c.

                            {
  int rows = 0;
  if(n->curitem->ncp){
    rows = ncplane_dim_y(n->curitem->ncp);
  }
  nctree_int_item* tmp = nctree_prev_internal(n, n->currentpath);
  if(tmp != n->curitem){
    n->curitem = tmp;
    n->activerow -= rows;
    if(n->activerow < 0){
      n->activerow = 0;
    }
  }
  return n->curitem->curry;
}

Here is the caller graph for this function:

nctree_redraw()

int nctree_redraw

(

nctree *

n

)

Definition at line 568 of file tree.c.

                            {
  unsigned* tmppath = malloc(sizeof(*tmppath) * (n->maxdepth + 2));
  if(tmppath == NULL){
    return -1;
  }
  memcpy(tmppath, n->currentpath, sizeof(*tmppath) * (n->maxdepth + 1));
  int ret = nctree_inner_redraw(n, tmppath);
  free(tmppath);
  return ret;
}

Here is the call graph for this function: