selector.c File Reference

#include "internal.h"

Include dependency graph for selector.c:

Go to the source code of this file.

Data Structures
struct	ncselector_int
struct	ncmselector_int
struct	ncselector
struct	ncmultiselector

Typedefs
typedef struct ncselector	ncselector
typedef struct ncmultiselector	ncmultiselector

Functions
void	ncselector_destroy (ncselector *n, char **item)
ncselector *	ncselector_create (ncplane *n, const ncselector_options *opts)
int	ncselector_additem (ncselector *n, const struct ncselector_item *item)
int	ncselector_delitem (ncselector *n, const char *item)
ncplane *	ncselector_plane (ncselector *n)
const char *	ncselector_selected (const ncselector *n)
const char *	ncselector_previtem (ncselector *n)
const char *	ncselector_nextitem (ncselector *n)
bool	ncselector_offer_input (ncselector *n, const ncinput *nc)
ncplane *	ncmultiselector_plane (ncmultiselector *n)
const char *	ncmultiselector_previtem (ncmultiselector *n)
const char *	ncmultiselector_nextitem (ncmultiselector *n)
bool	ncmultiselector_offer_input (ncmultiselector *n, const ncinput *nc)
ncmultiselector *	ncmultiselector_create (ncplane *n, const ncmultiselector_options *opts)
void	ncmultiselector_destroy (ncmultiselector *n)
int	ncmultiselector_selected (ncmultiselector *n, bool *selected, unsigned count)

Typedef Documentation

ncmultiselector

typedef struct ncmultiselector ncmultiselector

ncselector

typedef struct ncselector ncselector

Function Documentation

ncmultiselector_create()

ncmultiselector * ncmultiselector_create	(	ncplane *	n,
		const ncmultiselector_options *	opts
	)

Definition at line 885 of file selector.c.

                                                                                        {
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    logerror("won't use the standard plane"); // would fail later on resize
    return NULL;
  }
  ncmultiselector_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(opts->flags > 0){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  unsigned itemcount = 0;
  if(opts->items){
    for(const struct ncmselector_item* i = opts->items ; i->option ; ++i){
      ++itemcount;
    }
  }
  ncmultiselector* ns = malloc(sizeof(*ns));
  if(ns == NULL){
    return NULL;
  }
  memset(ns, 0, sizeof(*ns));
  ns->title = opts->title ? strdup(opts->title) : NULL;
  ns->titlecols = opts->title ? ncstrwidth(opts->title, NULL, NULL) : 0;
  ns->secondary = opts->secondary ? strdup(opts->secondary) : NULL;
  ns->secondarycols = opts->secondary ? ncstrwidth(opts->secondary, NULL, NULL) : 0;
  ns->footer = opts->footer ? strdup(opts->footer) : NULL;
  ns->footercols = opts->footer ? ncstrwidth(opts->footer, NULL, NULL) : 0;
  ns->current = 0;
  ns->startdisp = 0;
  ns->longitem = 0;
  ns->maxdisplay = opts->maxdisplay;
  ns->opchannels = opts->opchannels;
  ns->boxchannels = opts->boxchannels;
  ns->descchannels = opts->descchannels;
  ns->titlechannels = opts->titlechannels;
  ns->footchannels = opts->footchannels;
  ns->boxchannels = opts->boxchannels;
  ns->darrowy = ns->uarrowy = ns->arrowx = -1;
  if(itemcount){
    if(!(ns->items = malloc(sizeof(*ns->items) * itemcount))){
      goto freeitems;
    }
  }else{
    ns->items = NULL;
  }
  for(ns->itemcount = 0 ; ns->itemcount < itemcount ; ++ns->itemcount){
    const struct ncmselector_item* src = &opts->items[ns->itemcount];
    int unsafe = ncstrwidth(src->option, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols = unsafe;
    if(cols > ns->longitem){
      ns->longitem = cols;
    }
    unsafe = ncstrwidth(src->desc, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols2 = unsafe;
    if(cols + cols2 > ns->longitem){
      ns->longitem = cols + cols2;
    }
    ns->items[ns->itemcount].option = strdup(src->option);
    ns->items[ns->itemcount].desc = strdup(src->desc);
    ns->items[ns->itemcount].selected = src->selected;
    if(!(ns->items[ns->itemcount].desc && ns->items[ns->itemcount].option)){
      free(ns->items[ns->itemcount].option);
      free(ns->items[ns->itemcount].desc);
      goto freeitems;
    }
  }
  unsigned dimy, dimx;
  ns->ncp = n;
  if(ncmultiselector_dim_yx(ns, &dimy, &dimx)){
    goto freeitems;
  }
  if(ncplane_resize_simple(ns->ncp, dimy, dimx)){
    goto freeitems;
  }
  if(ncplane_set_widget(ns->ncp, ns, (void(*)(void*))ncmultiselector_destroy)){
    goto freeitems;
  }
  ncmultiselector_draw(ns); // deal with error here?
  return ns;
 
freeitems:
  while(ns->itemcount--){
    free(ns->items[ns->itemcount].option);
    free(ns->items[ns->itemcount].desc);
  }
  free(ns->items);
  free(ns->title); free(ns->secondary); free(ns->footer);
  free(ns);
  ncplane_destroy(n);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmultiselector_destroy()

void ncmultiselector_destroy

(

ncmultiselector *

n

)

Definition at line 985 of file selector.c.

                                                {
  if(n){
    while(n->itemcount--){
      free(n->items[n->itemcount].option);
      free(n->items[n->itemcount].desc);
    }
    if(ncplane_set_widget(n->ncp, NULL, NULL) == 0){
      ncplane_destroy(n->ncp);
    }
    free(n->items);
    free(n->title);
    free(n->secondary);
    free(n->footer);
    free(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmultiselector_nextitem()

const char * ncmultiselector_nextitem

(

ncmultiselector *

n

)

Definition at line 762 of file selector.c.

                                                        {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return NULL;
  }
  unsigned lastdisp = n->startdisp;
  lastdisp += n->maxdisplay && n->maxdisplay < n->itemcount ? n->maxdisplay : n->itemcount;
  --lastdisp;
  lastdisp %= n->itemcount;
  if(lastdisp == n->current){
    if(++n->startdisp == n->itemcount){
      n->startdisp = 0;
    }
  }
  ++n->current;
  if(n->current == n->itemcount){
    n->current = 0;
  }
  ret = n->items[n->current].option;
  ncmultiselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

ncmultiselector_offer_input()

bool ncmultiselector_offer_input	(	ncmultiselector *	n,
		const ncinput *	nc
	)

Definition at line 785 of file selector.c.

                                                                       {
  const int items_shown = ncplane_dim_y(n->ncp) - 4 - (n->title ? 2 : 0);
  if(nc->id == NCKEY_BUTTON1 && nc->evtype == NCTYPE_RELEASE){
    int y = nc->y, x = nc->x;
    if(!ncplane_translate_abs(n->ncp, &y, &x)){
      return false;
    }
    if(y == n->uarrowy && x == n->arrowx){
      ncmultiselector_previtem(n);
      return true;
    }else if(y == n->darrowy && x == n->arrowx){
      ncmultiselector_nextitem(n);
      return true;
    }else if(n->uarrowy < y && y < n->darrowy){
      // FIXME we probably only want to consider it a click if both the release
      // and the depress happened to be on us. for now, just check release.
      // FIXME verify that we're within the body walls!
      // FIXME verify we're on the left of the split?
      // FIXME verify that we're on a visible glyph?
      int cury = (n->current + n->itemcount - n->startdisp) % n->itemcount;
      int click = y - n->uarrowy - 1;
      while(click > cury){
        ncmultiselector_nextitem(n);
        ++cury;
      }
      while(click < cury){
        ncmultiselector_previtem(n);
        --cury;
      }
      return true;
    }
  }else if(nc->evtype != NCTYPE_RELEASE){
    if(nc->id == ' '){
      n->items[n->current].selected = !n->items[n->current].selected;
      ncmultiselector_draw(n);
      return true;
    }else if(nc->id == NCKEY_UP){
      ncmultiselector_previtem(n);
      return true;
    }else if(nc->id == NCKEY_DOWN){
      ncmultiselector_nextitem(n);
      return true;
    }else if(nc->id == NCKEY_PGDOWN){
      if(items_shown > 0){
        for(int i = 0 ; i < items_shown ; ++i){
          ncmultiselector_nextitem(n);
        }
      }
      return true;
    }else if(nc->id == NCKEY_PGUP){
      if(items_shown > 0){
        for(int i = 0 ; i < items_shown ; ++i){
          ncmultiselector_previtem(n);
        }
      }
      return true;
    }else if(nc->id == NCKEY_SCROLL_UP){
      ncmultiselector_previtem(n);
      return true;
    }else if(nc->id == NCKEY_SCROLL_DOWN){
      ncmultiselector_nextitem(n);
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmultiselector_plane()

ncplane * ncmultiselector_plane

(

ncmultiselector *

n

)

Definition at line 586 of file selector.c.

                                                  {
  return n->ncp;
}

ncmultiselector_previtem()

const char * ncmultiselector_previtem

(

ncmultiselector *

n

)

Definition at line 743 of file selector.c.

                                                        {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return ret;
  }
  if(n->current == n->startdisp){
    if(n->startdisp-- == 0){
      n->startdisp = n->itemcount - 1;
    }
  }
  if(n->current == 0){
    n->current = n->itemcount;
  }
  --n->current;
  ret = n->items[n->current].option;
  ncmultiselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

ncmultiselector_selected()

int ncmultiselector_selected	(	ncmultiselector *	n,
		bool *	selected,
		unsigned	count
	)

Definition at line 1002 of file selector.c.

                                                                                {
  if(n->itemcount != count || n->itemcount < 1){
    return -1;
  }
  while(--count){
    selected[count] = n->items[count].selected;
  }
  return 0;
}

Here is the caller graph for this function:

ncselector_additem()

int ncselector_additem	(	ncselector *	n,
		const struct ncselector_item *	item
	)

Definition at line 392 of file selector.c.

                                                                         {
  unsigned origdimy, origdimx;
  ncselector_dim_yx(n, &origdimy, &origdimx);
  size_t newsize = sizeof(*n->items) * (n->itemcount + 1);
  struct ncselector_int* items = realloc(n->items, newsize);
  if(!items){
    return -1;
  }
  n->items = items;
  n->items[n->itemcount].option = strdup(item->option);
  const char *desc = item->desc ? item->desc : "";
  n->items[n->itemcount].desc = strdup(desc);
  int usafecols = ncstrwidth(item->option, NULL, NULL);
  if(usafecols < 0){
    return -1;
  }
  unsigned cols = usafecols;
  n->items[n->itemcount].opcolumns = cols;
  if(cols > n->longop){
    n->longop = cols;
  }
  cols = ncstrwidth(desc, NULL, NULL);
  n->items[n->itemcount].desccolumns = cols;
  if(cols > n->longdesc){
    n->longdesc = cols;
  }
  ++n->itemcount;
  unsigned dimy, dimx;
  ncselector_dim_yx(n, &dimy, &dimx);
  if(origdimx < dimx || origdimy < dimy){ // resize if too small
    ncplane_resize_simple(n->ncp, dimy, dimx);
  }
  return ncselector_draw(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncselector_create()

ncselector * ncselector_create	(	ncplane *	n,
		const ncselector_options *	opts
	)

Definition at line 280 of file selector.c.

                                                                         {
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    logerror("won't use the standard plane"); // would fail later on resize
    return NULL;
  }
  ncselector_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  unsigned itemcount = 0;
  if(opts->flags > 0){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  if(opts->items){
    for(const struct ncselector_item* i = opts->items ; i->option ; ++i){
      ++itemcount;
    }
  }
  ncselector* ns = malloc(sizeof(*ns));
  if(ns == NULL){
    return NULL;
  }
  memset(ns, 0, sizeof(*ns));
  if(opts->defidx && opts->defidx >= itemcount){
    logerror("default index %u too large (%u items)", opts->defidx, itemcount);
    goto freeitems;
  }
  ns->title = opts->title ? strdup(opts->title) : NULL;
  ns->titlecols = opts->title ? ncstrwidth(opts->title, NULL, NULL) : 0;
  ns->secondary = opts->secondary ? strdup(opts->secondary) : NULL;
  ns->secondarycols = opts->secondary ? ncstrwidth(opts->secondary, NULL, NULL) : 0;
  ns->footer = opts->footer ? strdup(opts->footer) : NULL;
  ns->footercols = opts->footer ? ncstrwidth(opts->footer, NULL, NULL) : 0;
  ns->selected = opts->defidx;
  ns->longop = 0;
  if( (ns->maxdisplay = opts->maxdisplay) ){
    if(opts->defidx >= ns->maxdisplay){
      ns->startdisp = opts->defidx - ns->maxdisplay + 1;
    }else{
      ns->startdisp = 0;
    }
  }else{
    ns->startdisp = 0;
  }
  ns->longdesc = 0;
  ns->opchannels = opts->opchannels;
  ns->boxchannels = opts->boxchannels;
  ns->descchannels = opts->descchannels;
  ns->titlechannels = opts->titlechannels;
  ns->footchannels = opts->footchannels;
  ns->boxchannels = opts->boxchannels;
  ns->darrowy = ns->uarrowy = ns->arrowx = -1;
  if(itemcount){
    if(!(ns->items = malloc(sizeof(*ns->items) * itemcount))){
      goto freeitems;
    }
  }else{
    ns->items = NULL;
  }
  for(ns->itemcount = 0 ; ns->itemcount < itemcount ; ++ns->itemcount){
    const struct ncselector_item* src = &opts->items[ns->itemcount];
    int unsafe = ncstrwidth(src->option, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols = unsafe;
    ns->items[ns->itemcount].opcolumns = cols;
    if(cols > ns->longop){
      ns->longop = cols;
    }
    const char *desc = src->desc ? src->desc : "";
    unsafe = ncstrwidth(desc, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    cols = unsafe;
    ns->items[ns->itemcount].desccolumns = cols;
    if(cols > ns->longdesc){
      ns->longdesc = cols;
    }
    ns->items[ns->itemcount].option = strdup(src->option);
    ns->items[ns->itemcount].desc = strdup(desc);
    if(!(ns->items[ns->itemcount].desc && ns->items[ns->itemcount].option)){
      free(ns->items[ns->itemcount].option);
      free(ns->items[ns->itemcount].desc);
      goto freeitems;
    }
  }
  unsigned dimy, dimx;
  ns->ncp = n;
  ncselector_dim_yx(ns, &dimy, &dimx);
  if(ncplane_resize_simple(n, dimy, dimx)){
    goto freeitems;
  }
  if(ncplane_set_widget(ns->ncp, ns, (void(*)(void*))ncselector_destroy_internal)){
    goto freeitems;
  }
  ncselector_draw(ns); // deal with error here?
  return ns;
 
freeitems:
  while(ns->itemcount--){
    free(ns->items[ns->itemcount].option);
    free(ns->items[ns->itemcount].desc);
  }
  free(ns->items);
  free(ns->title); free(ns->secondary); free(ns->footer);
  free(ns);
  ncplane_destroy(n);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncselector_delitem()

int ncselector_delitem	(	ncselector *	n,
		const char *	item
	)

Definition at line 427 of file selector.c.

                                                       {
  unsigned origdimy, origdimx;
  ncselector_dim_yx(n, &origdimy, &origdimx);
  bool found = false;
  int maxop = 0, maxdesc = 0;
  for(unsigned idx = 0 ; idx < n->itemcount ; ++idx){
    if(strcmp(n->items[idx].option, item) == 0){ // found it
      free(n->items[idx].option);
      free(n->items[idx].desc);
      if(idx < n->itemcount - 1){
        memmove(n->items + idx, n->items + idx + 1, sizeof(*n->items) * (n->itemcount - idx - 1));
      }else{
        if(idx){
          --n->selected;
        }
      }
      --n->itemcount;
      found = true;
      --idx;
    }else{
      int cols = ncstrwidth(n->items[idx].option, NULL, NULL);
      if(cols > maxop){
        maxop = cols;
      }
      cols = ncstrwidth(n->items[idx].desc, NULL, NULL);
      if(cols > maxdesc){
        maxdesc = cols;
      }
    }
  }
  if(found){
    n->longop = maxop;
    n->longdesc = maxdesc;
    unsigned dimy, dimx;
    ncselector_dim_yx(n, &dimy, &dimx);
    if(origdimx > dimx || origdimy > dimy){ // resize if too big
      ncplane_resize_simple(n->ncp, dimy, dimx);
    }
    return ncselector_draw(n);
  }
  return -1; // wasn't found
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncselector_destroy()

void ncselector_destroy	(	ncselector *	n,
		char **	item
	)

Definition at line 270 of file selector.c.

                                                   {
  if(n){
    if(item){
      *item = n->items[n->selected].option;
      n->items[n->selected].option = NULL;
    }
    ncselector_destroy_internal(n);
  }
}

Here is the caller graph for this function:

ncselector_nextitem()

const char * ncselector_nextitem

(

ncselector *

n

)

Definition at line 500 of file selector.c.

                                              {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return NULL;
  }
  unsigned lastdisp = n->startdisp;
  lastdisp += n->maxdisplay && n->maxdisplay < n->itemcount ? n->maxdisplay : n->itemcount;
  --lastdisp;
  lastdisp %= n->itemcount;
  if(lastdisp == n->selected){
    if(++n->startdisp == n->itemcount){
      n->startdisp = 0;
    }
  }
  ++n->selected;
  if(n->selected == n->itemcount){
    n->selected = 0;
  }
  ret = n->items[n->selected].option;
  ncselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

ncselector_offer_input()

bool ncselector_offer_input	(	ncselector *	n,
		const ncinput *	nc
	)

Definition at line 523 of file selector.c.

                                                             {
  const int items_shown = ncplane_dim_y(n->ncp) - 4 - (n->title ? 2 : 0);
  if(nc->id == NCKEY_BUTTON1 && nc->evtype == NCTYPE_RELEASE){
    int y = nc->y, x = nc->x;
    if(!ncplane_translate_abs(n->ncp, &y, &x)){
      return false;
    }
    if(y == n->uarrowy && x == n->arrowx){
      ncselector_previtem(n);
      return true;
    }else if(y == n->darrowy && x == n->arrowx){
      ncselector_nextitem(n);
      return true;
    }else if(n->uarrowy < y && y < n->darrowy){
      // FIXME we probably only want to consider it a click if both the release
      // and the depress happened to be on us. for now, just check release.
      // FIXME verify that we're within the body walls!
      // FIXME verify we're on the left of the split?
      // FIXME verify that we're on a visible glyph?
      int cury = (n->selected + n->itemcount - n->startdisp) % n->itemcount;
      int click = y - n->uarrowy - 1;
      while(click > cury){
        ncselector_nextitem(n);
        ++cury;
      }
      while(click < cury){
        ncselector_previtem(n);
        --cury;
      }
      return true;
    }
  }else if(nc->evtype != NCTYPE_RELEASE){
    if(nc->id == NCKEY_UP){
      ncselector_previtem(n);
      return true;
    }else if(nc->id == NCKEY_DOWN){
      ncselector_nextitem(n);
      return true;
    }else if(nc->id == NCKEY_SCROLL_UP){
      ncselector_previtem(n);
      return true;
    }else if(nc->id == NCKEY_SCROLL_DOWN){
      ncselector_nextitem(n);
      return true;
    }else if(nc->id == NCKEY_PGDOWN){
      if(items_shown > 0){
        for(int i = 0 ; i < items_shown ; ++i){
          ncselector_nextitem(n);
        }
      }
      return true;
    }else if(nc->id == NCKEY_PGUP){
      if(items_shown > 0){
        for(int i = 0 ; i < items_shown ; ++i){
          ncselector_previtem(n);
        }
      }
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncselector_plane()

ncplane * ncselector_plane

(

ncselector *

n

)

Definition at line 470 of file selector.c.

                                        {
  return n->ncp;
}

ncselector_previtem()

const char * ncselector_previtem

(

ncselector *

n

)

Definition at line 481 of file selector.c.

                                              {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return ret;
  }
  if(n->selected == n->startdisp){
    if(n->startdisp-- == 0){
      n->startdisp = n->itemcount - 1;
    }
  }
  if(n->selected == 0){
    n->selected = n->itemcount;
  }
  --n->selected;
  ret = n->items[n->selected].option;
  ncselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

ncselector_selected()

const char * ncselector_selected

(

const ncselector *

n

)

Definition at line 474 of file selector.c.

                                                    {
  if(n->itemcount == 0){
    return NULL;
  }
  return n->items[n->selected].option;
}

Here is the caller graph for this function: