tabbed.c File Reference

#include "internal.h"

Include dependency graph for tabbed.c:

Go to the source code of this file.

Data Structures
struct	nctabbed_opsint
struct	nctabbed

Typedefs
typedef struct nctabbed_opsint	nctabbed_opsint
typedef struct nctabbed	nctabbed

Functions
void	nctabbed_redraw (nctabbed *nt)
void	nctabbed_ensure_selected_header_visible (nctabbed *nt)
nctab *	nctabbed_selected (nctabbed *nt)
nctab *	nctabbed_leftmost (nctabbed *nt)
int	nctabbed_tabcount (nctabbed *nt)
ncplane *	nctabbed_plane (nctabbed *nt)
ncplane *	nctabbed_content_plane (nctabbed *nt)
tabcb	nctab_cb (nctab *t)
const char *	nctab_name (nctab *t)
int	nctab_name_width (nctab *t)
void *	nctab_userptr (nctab *t)
nctab *	nctab_next (nctab *t)
nctab *	nctab_prev (nctab *t)
nctabbed *	nctabbed_create (ncplane *n, const nctabbed_options *topts)
nctab *	nctabbed_add (nctabbed *nt, nctab *after, nctab *before, tabcb cb, const char *name, void *opaque)
int	nctabbed_del (nctabbed *nt, nctab *t)
int	nctab_move (nctabbed *nt __attribute__((unused)), nctab *t, nctab *after, nctab *before)
void	nctab_move_right (nctabbed *nt, nctab *t)
void	nctab_move_left (nctabbed *nt, nctab *t)
void	nctabbed_rotate (nctabbed *nt, int amt)
nctab *	nctabbed_next (nctabbed *nt)
nctab *	nctabbed_prev (nctabbed *nt)
nctab *	nctabbed_select (nctabbed *nt, nctab *t)
void	nctabbed_channels (nctabbed *nt, uint64_t *RESTRICT hdrchan, uint64_t *RESTRICT selchan, uint64_t *RESTRICT sepchan)
const char *	nctabbed_separator (nctabbed *nt)
int	nctabbed_separator_width (nctabbed *nt)
void	nctabbed_destroy (nctabbed *nt)
void	nctabbed_set_hdrchan (nctabbed *nt, uint64_t chan)
void	nctabbed_set_selchan (nctabbed *nt, uint64_t chan)
void	nctabbed_set_sepchan (nctabbed *nt, uint64_t chan)
tabcb	nctab_set_cb (nctab *t, tabcb newcb)
int	nctab_set_name (nctab *t, const char *newname)
void *	nctab_set_userptr (nctab *t, void *newopaque)
int	nctabbed_set_separator (nctabbed *nt, const char *separator)

Typedef Documentation

nctabbed

typedef struct nctabbed nctabbed

nctabbed_opsint

typedef struct nctabbed_opsint nctabbed_opsint

Function Documentation

nctab_cb()

tabcb nctab_cb

(

nctab *

t

)

Definition at line 124 of file tabbed.c.

                        {
  return t->cb;
}

nctab_move()

int nctab_move	(	nctabbed *nt	__attribute__(unused),
		nctab *	t,
		nctab *	after,
		nctab *	before
	)

Definition at line 303 of file tabbed.c.

                                                                                            {
  if(after && before){
    if(after->prev != before || before->next != after){
      logerror("bad before (%p) / after (%p) spec", before, after);
      return -1;
    }
  }else if(!after && !before){
    logerror("bad before (%p) / after (%p) spec", before, after);
    return -1;
  }
  // bad things would happen
  if(t == after || t == before){
    logerror("Cannot move a tab before or after itself.");
    return -1;
  }
  t->prev->next = t->next;
  t->next->prev = t->prev;
  if(after){
    t->next = after->next;
    t->prev = after;
    after->next = t;
    t->next->prev = t;
  }else{
    t->next = before;
    t->prev = before->prev;
    before->prev = t;
    t->prev->next = t;
  }
  return 0;
}

Here is the caller graph for this function:

nctab_move_left()

void nctab_move_left	(	nctabbed *	nt,
		nctab *	t
	)

Definition at line 345 of file tabbed.c.

                                            {
  if(t == nt->leftmost){
    nt->leftmost = t->next;
    nctab_move(nt, t, nt->leftmost->prev, NULL);
    return;
  }else if(t == nt->leftmost->next){
    nt->leftmost = t;
  }
  nctab_move(nt, t, NULL, t->prev);
}

Here is the call graph for this function:

nctab_move_right()

void nctab_move_right	(	nctabbed *	nt,
		nctab *	t
	)

Definition at line 334 of file tabbed.c.

                                             {
  if(t == nt->leftmost->prev){
    nctab_move(nt, t, NULL, nt->leftmost);
    nt->leftmost = t;
    return;
  }else if(t == nt->leftmost){
    nt->leftmost = t->next;
  }
  nctab_move(nt, t, t->next, NULL);
}

Here is the call graph for this function:

nctab_name()

const char * nctab_name

(

nctab *

t

)

Definition at line 128 of file tabbed.c.

                                {
  return t->name;
}

nctab_name_width()

int nctab_name_width

(

nctab *

t

)

Definition at line 132 of file tabbed.c.

                              {
  return t->namecols;
}

nctab_next()

nctab * nctab_next

(

nctab *

t

)

Definition at line 140 of file tabbed.c.

                           {
  return t->next;
}

nctab_prev()

nctab * nctab_prev

(

nctab *

t

)

Definition at line 144 of file tabbed.c.

                           {
  return t->prev;
}

nctab_set_cb()

tabcb nctab_set_cb	(	nctab *	t,
		tabcb	newcb
	)

Definition at line 448 of file tabbed.c.

                                         {
  tabcb prevcb = t->cb;
  t->cb = newcb;
  return prevcb;
}

nctab_set_name()

int nctab_set_name	(	nctab *	t,
		const char *	newname
	)

Definition at line 454 of file tabbed.c.

                                                 {
  int newnamecols;
  char* prevname = t->name;
  if((newnamecols = ncstrwidth(newname, NULL, NULL)) < 0){
    logerror("New tab name contains illegal characters");
    return -1;
  }
  if((t->name = strdup(newname)) == NULL){
    logerror("Couldn't allocate new tab name");
    t->name = prevname;
    return -1;
  }
  free(prevname);
  t->namecols = newnamecols;
  return 0;
}

Here is the call graph for this function:

nctab_set_userptr()

void * nctab_set_userptr	(	nctab *	t,
		void *	newopaque
	)

Definition at line 471 of file tabbed.c.

                                                  {
  void* prevcurry = t->curry;
  t->curry = newopaque;
  return prevcurry;
}

nctab_userptr()

void * nctab_userptr

(

nctab *

t

)

Definition at line 136 of file tabbed.c.

                             {
  return t->curry;
}

nctabbed_add()

nctab * nctabbed_add	(	nctabbed *	nt,
		nctab *	after,
		nctab *	before,
		tabcb	cb,
		const char *	name,
		void *	opaque
	)

Definition at line 231 of file tabbed.c.

                                                   {
  nctab* t;
  if(after && before){
    if(after->next != before || before->prev != after){
      logerror("bad before (%p) / after (%p) spec", before, after);
      return NULL;
    }
  }else if(!after && !before){
    // add it to the right of the selected tab
    after = nt->selected;
  }
  if((t = malloc(sizeof(*t))) == NULL){
    logerror("Couldn't allocate nctab")
    return NULL;
  }
  if((t->name = strdup(name)) == NULL){
    logerror("Couldn't allocate the tab name");
    free(t);
    return NULL;
  }
  if((t->namecols = ncstrwidth(name, NULL, NULL)) < 0){
    logerror("Tab name contains illegal characters")
    free(t->name);
    free(t);
    return NULL;
  }
  if(after){
    t->next = after->next;
    t->prev = after;
    after->next = t;
    t->next->prev = t;
  }else if(before){
    t->next = before;
    t->prev = before->prev;
    before->prev = t;
    t->prev->next = t;
  }else{
    // the first tab
    t->prev = t->next = t;
    nt->leftmost = nt->selected = t;
  }
  t->nt = nt;
  t->cb = cb;
  t->curry = opaque;
  ++nt->tabcount;
  return t;
}

Here is the call graph for this function:

nctabbed_channels()

void nctabbed_channels	(	nctabbed *	nt,
		uint64_t *RESTRICT	hdrchan,
		uint64_t *RESTRICT	selchan,
		uint64_t *RESTRICT	sepchan
	)

Definition at line 390 of file tabbed.c.

                                                                              {
  if(hdrchan){
    memcpy(hdrchan, &nt->opts.hdrchan, sizeof(*hdrchan));
  }
  if(selchan){
    memcpy(selchan, &nt->opts.selchan, sizeof(*selchan));
  }
  if(sepchan){
    memcpy(sepchan, &nt->opts.sepchan, sizeof(*sepchan));
  }
}

nctabbed_content_plane()

ncplane * nctabbed_content_plane

(

nctabbed *

nt

)

Definition at line 120 of file tabbed.c.

                                             {
  return nt->p;
}

nctabbed_create()

nctabbed * nctabbed_create	(	ncplane *	n,
		const nctabbed_options *	topts
	)

Definition at line 148 of file tabbed.c.

                                                                    {
  nctabbed_options zeroed = {0};
  ncplane_options nopts = {0};
  unsigned nrows, ncols;
  nctabbed* nt = NULL;
  if(!topts){
    topts = &zeroed;
  }
  if(!nctabbed_validate_opts(topts)){
    goto err;
  }
  if((nt = malloc(sizeof(*nt))) == NULL){
    logerror("Couldn't allocate nctabbed");
    goto err;
  }
  nt->ncp = n;
  nt->leftmost = nt->selected = NULL;
  nt->tabcount = 0;
  nt->sepcols = 0;
  nt->opts.separator = NULL;
  nt->opts.selchan = topts->selchan;
  nt->opts.hdrchan = topts->hdrchan;
  nt->opts.sepchan = topts->sepchan;
  nt->opts.flags = topts->flags;
  if(topts->separator){
    if((nt->sepcols = ncstrwidth(topts->separator, NULL, NULL)) < 0){
      logerror("Separator string contains illegal characters");
      goto err;
    }
    if((nt->opts.separator = strdup(topts->separator)) == NULL){
      logerror("Couldn't allocate nctabbed separator");
      goto err;
    }
  }
  ncplane_dim_yx(n, &nrows, &ncols);
  if(topts->flags & NCTABBED_OPTION_BOTTOM){
    nopts.y = nopts.x = 0;
    nopts.cols = ncols;
    nopts.rows = nrows - 1;
    if((nt->p = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab content plane");
      goto err;
    }
    nopts.y = nrows - 2;
    nopts.rows = 1;
    if((nt->hp = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab headers plane");
      ncplane_destroy(nt->p);
      goto err;
    }
  }else{
    nopts.y = nopts.x = 0;
    nopts.cols = ncols;
    nopts.rows = 1;
    if((nt->hp = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab headers plane");
      goto err;
    }
    nopts.y = 1;
    nopts.rows = nrows - 1;
    if((nt->p = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab content plane");
      ncplane_destroy(nt->hp);
      goto err;
    }
  }
  if(ncplane_set_widget(nt->ncp, nt, (void(*)(void*))nctabbed_destroy)){
    ncplane_destroy(nt->hp);
    ncplane_destroy(nt->p);
    goto err;
  }
  nctabbed_redraw(nt);
  return nt;
 
err:
  ncplane_family_destroy(n);
  if(nt){
    free(nt->opts.separator);
    free(nt);
  }
  return NULL;
}

Here is the call graph for this function:

nctabbed_del()

int nctabbed_del	(	nctabbed *	nt,
		nctab *	t
	)

Definition at line 280 of file tabbed.c.

                                        {
  if(!t){
    logerror("Provided NULL nctab");
    return -1;
  }
  if(nt->tabcount == 1){
    nt->leftmost = nt->selected = NULL;
  }else{
    if(nt->selected == t){
      nt->selected = t->next;
    }
    if(nt->leftmost == t){
      nt->leftmost = t->next;
    }
    t->next->prev = t->prev;
    t->prev->next = t->next;
  }
  free(t->name);
  free(t);
  --nt->tabcount;
  return 0;
}

nctabbed_destroy()

void nctabbed_destroy

(

nctabbed *

nt

)

Definition at line 411 of file tabbed.c.

                                   {
  if(!nt){
    return;
  }
  if(ncplane_set_widget(nt->ncp, NULL, NULL) == 0){
    nctab* t = nt->leftmost;
    nctab* tmp;
    if(t){
      t->prev->next = NULL;
      if(t->next){
        t->next->prev = NULL;
      }
    }
    while(t){
      tmp = t->next;
      free(t->name);
      free(t);
      t = tmp;
    }
    ncplane_family_destroy(nt->ncp);
    free(nt->opts.separator);
    free(nt);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nctabbed_ensure_selected_header_visible()

void nctabbed_ensure_selected_header_visible

(

nctabbed *

nt

)

Definition at line 69 of file tabbed.c.

                                                          {
  nctab* t = nt->leftmost;
  int cols = ncplane_dim_x(nt->hp);
  int takencols = 0;
  if(!t){
    return;
  }
//fprintf(stderr, "ensuring selected header visible\n");
  do{
    if(t == nt->selected){
      break;
    }
    takencols += t->namecols + nt->sepcols;
    if(takencols >= cols){
//fprintf(stderr, "not enough space, rotating\n");
      takencols -= nt->leftmost->namecols + nt->sepcols;
      nctabbed_rotate(nt, -1);
    }
    t = t->next;
//fprintf(stderr, "iteration over: takencols = %d, cols = %d\n", takencols, cols);
  }while(t != nt->leftmost);
//fprintf(stderr, "ensuring done\n");
}

Here is the call graph for this function:

nctabbed_leftmost()

nctab * nctabbed_leftmost

(

nctabbed *

nt

)

Definition at line 108 of file tabbed.c.

                                      {
  return nt->leftmost;
}

nctabbed_next()

nctab * nctabbed_next

(

nctabbed *

nt

)

Definition at line 368 of file tabbed.c.

                                  {
  if(nt->tabcount == 0){
    return NULL;
  }
  nt->selected = nt->selected->next;
  return nt->selected;
}

nctabbed_plane()

ncplane * nctabbed_plane

(

nctabbed *

nt

)

Definition at line 116 of file tabbed.c.

                                     {
  return nt->ncp;
}

nctabbed_prev()

nctab * nctabbed_prev

(

nctabbed *

nt

)

Definition at line 376 of file tabbed.c.

                                  {
  if(nt->tabcount == 0){
    return NULL;
  }
  nt->selected = nt->selected->prev;
  return nt->selected;
}

nctabbed_redraw()

void nctabbed_redraw

(

nctabbed *

nt

)

Definition at line 23 of file tabbed.c.

                                  {
  nctab* t;
  unsigned drawn_cols = 0;
  unsigned rows, cols;
  if(nt->tabcount == 0){
    // no tabs = nothing to draw
    ncplane_erase(nt->hp);
    return;
  }
  // update sizes for planes
  ncplane_dim_yx(nt->ncp, &rows, &cols);
  if(nt->opts.flags & NCTABBED_OPTION_BOTTOM){
    ncplane_resize_simple(nt->hp, -1, cols);
    ncplane_resize_simple(nt->p, rows - 1, cols);
    ncplane_move_yx(nt->hp, rows - 2, 0);
  }else{
    ncplane_resize_simple(nt->hp, -1, cols);
    ncplane_resize_simple(nt->p, rows - 1, cols);
  }
  // the callback draws the tab contents
  if(nt->selected->cb){
    nt->selected->cb(nt->selected, nt->p, nt->selected->curry);
  }
  // now we draw the headers
  t = nt->leftmost;
  ncplane_erase(nt->hp);
  ncplane_set_channels(nt->hp, nt->opts.hdrchan);
  do{
    if(t == nt->selected){
      ncplane_set_channels(nt->hp, nt->opts.selchan);
      drawn_cols += ncplane_putstr(nt->hp, t->name);
      ncplane_set_channels(nt->hp, nt->opts.hdrchan);
    }else{
      drawn_cols += ncplane_putstr(nt->hp, t->name);
    }
    // avoid drawing the separator after the last tab, or when we
    // ran out of space, or when it's not set
    if((t->next != nt->leftmost || drawn_cols >= cols) && nt->opts.separator){
      ncplane_set_channels(nt->hp, nt->opts.sepchan);
      drawn_cols += ncplane_putstr(nt->hp, nt->opts.separator);
      ncplane_set_channels(nt->hp, nt->opts.hdrchan);
    }
    t = t->next;
  }while(t != nt->leftmost && drawn_cols < cols);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nctabbed_rotate()

void nctabbed_rotate	(	nctabbed *	nt,
		int	amt
	)

Definition at line 356 of file tabbed.c.

                                           {
  if(amt > 0){
    for(int i = 0 ; i < amt ; ++i){
      nt->leftmost = nt->leftmost->prev;
    }
  }else{
    for(int i = 0 ; i < -amt ; ++i){
      nt->leftmost = nt->leftmost->next;
    }
  }
}

Here is the caller graph for this function:

nctabbed_select()

nctab * nctabbed_select	(	nctabbed *	nt,
		nctab *	t
	)

Definition at line 384 of file tabbed.c.

                                              {
  nctab* prevsel = nt->selected;
  nt->selected = t;
  return prevsel;
}

nctabbed_selected()

nctab * nctabbed_selected

(

nctabbed *

nt

)

Definition at line 104 of file tabbed.c.

                                      {
  return nt->selected;
}

nctabbed_separator()

const char * nctabbed_separator

(

nctabbed *

nt

)

Definition at line 403 of file tabbed.c.

                                            {
  return nt->opts.separator;
}

nctabbed_separator_width()

int nctabbed_separator_width

(

nctabbed *

nt

)

Definition at line 407 of file tabbed.c.

                                          {
  return nt->sepcols;
}

nctabbed_set_hdrchan()

void nctabbed_set_hdrchan	(	nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 436 of file tabbed.c.

                                                      {
  nt->opts.hdrchan = chan;
}

nctabbed_set_selchan()

void nctabbed_set_selchan	(	nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 440 of file tabbed.c.

                                                      {
  nt->opts.selchan = chan;
}

nctabbed_set_separator()

int nctabbed_set_separator	(	nctabbed *	nt,
		const char *	separator
	)

Definition at line 477 of file tabbed.c.

                                                               {
  int newsepcols;
  char* prevsep = nt->opts.separator;
  if((newsepcols = ncstrwidth(separator, NULL, NULL)) < 0){
    logerror("New tab separator contains illegal characters");
    return -1;
  }
  if((nt->opts.separator = strdup(separator)) == NULL){
    logerror("Couldn't allocate new tab separator");
    nt->opts.separator = prevsep;
    return -1;
  }
  free(prevsep);
  nt->sepcols = newsepcols;
  return 0;
}

Here is the call graph for this function:

nctabbed_set_sepchan()

void nctabbed_set_sepchan	(	nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 444 of file tabbed.c.

                                                      {
  nt->opts.sepchan = chan;
}

nctabbed_tabcount()

int nctabbed_tabcount

(

nctabbed *

nt

)

Definition at line 112 of file tabbed.c.

                                   {
  return nt->tabcount;
}