menu.c File Reference

#include "internal.h"

Include dependency graph for menu.c:

Go to the source code of this file.

Data Structures
struct	ncmenu_int_item
struct	ncmenu_int_section
struct	ncmenu

Macros
#define	ALTMOD   "Alt+"
#define	CTLMOD   "Ctrl+"

Typedefs
typedef struct ncmenu_int_item	ncmenu_int_item
typedef struct ncmenu_int_section	ncmenu_int_section
typedef struct ncmenu	ncmenu

Functions
ncmenu *	ncmenu_create (ncplane *n, const ncmenu_options *opts)
int	ncmenu_unroll (ncmenu *n, int sectionidx)
int	ncmenu_rollup (ncmenu *n)
int	ncmenu_nextsection (ncmenu *n)
int	ncmenu_prevsection (ncmenu *n)
int	ncmenu_nextitem (ncmenu *n)
int	ncmenu_previtem (ncmenu *n)
const char *	ncmenu_selected (const ncmenu *n, ncinput *ni)
const char *	ncmenu_mouse_selected (const ncmenu *n, const ncinput *click, ncinput *ni)
bool	ncmenu_offer_input (ncmenu *n, const ncinput *nc)
int	ncmenu_item_set_status (ncmenu *n, const char *section, const char *item, bool enabled)
ncplane *	ncmenu_plane (ncmenu *menu)
void	ncmenu_destroy (ncmenu *n)

Macro Definition Documentation

ALTMOD

#define ALTMOD   "Alt+"

CTLMOD

#define CTLMOD   "Ctrl+"

Typedef Documentation

ncmenu

typedef struct ncmenu ncmenu

ncmenu_int_item

typedef struct ncmenu_int_item ncmenu_int_item

ncmenu_int_section

typedef struct ncmenu_int_section ncmenu_int_section

Function Documentation

ncmenu_create()

ncmenu * ncmenu_create	(	ncplane *	n,
		const ncmenu_options *	opts
	)

Definition at line 377 of file menu.c.

                                                             {
  ncmenu_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(opts->sectioncount <= 0 || !opts->sections){
    logerror("invalid %d-ary section information", opts->sectioncount);
    return NULL;
  }
  if(opts->flags >= (NCMENU_OPTION_HIDING << 1u)){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  unsigned totalheight = 1;
  unsigned totalwidth = 2; // start with two-character margin on the left
  ncmenu* ret = malloc(sizeof(*ret));
  ret->sectioncount = opts->sectioncount;
  ret->sections = NULL;
  unsigned dimy, dimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  if(ret){
    ret->bottom = !!(opts->flags & NCMENU_OPTION_BOTTOM);
    if(dup_menu_sections(ret, opts, &totalwidth, &totalheight) == 0){
      ret->headerwidth = totalwidth;
      if(totalwidth < dimx){
        totalwidth = dimx;
      }
      struct ncplane_options nopts = {
        .y = ret->bottom ? dimy - totalheight : 0,
        .x = 0,
        .rows = totalheight,
        .cols = totalwidth,
        .userptr = ret,
        .name = "menu",
        .resizecb = resize_menu,
        .flags = NCPLANE_OPTION_FIXED,
      };
      ret->ncp = ncplane_create(n, &nopts);
      if(ret->ncp){
        if(ncplane_set_widget(ret->ncp, ret, (void(*)(void*))ncmenu_destroy) == 0){
          ret->unrolledsection = -1;
          ret->headerchannels = opts->headerchannels;
          ret->dissectchannels = opts->headerchannels;
          ncchannels_set_fg_rgb(&ret->dissectchannels, 0xdddddd);
          ret->sectionchannels = opts->sectionchannels;
          ret->disablechannels = ret->sectionchannels;
          ncchannels_set_fg_rgb(&ret->disablechannels, 0xdddddd);
          nccell c = NCCELL_TRIVIAL_INITIALIZER;
          nccell_set_fg_alpha(&c, NCALPHA_TRANSPARENT);
          nccell_set_bg_alpha(&c, NCALPHA_TRANSPARENT);
          ncplane_set_base_cell(ret->ncp, &c);
          nccell_release(ret->ncp, &c);
          if(write_header(ret) == 0){
            return ret;
          }
        }
        ncplane_destroy(ret->ncp);
      }
      free_menu_sections(ret);
    }
    free(ret);
  }
  logerror("error creating ncmenu");
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_destroy()

void ncmenu_destroy

(

ncmenu *

n

)

Definition at line 825 of file menu.c.

                              {
  if(n){
    free_menu_sections(n);
    if(ncplane_set_widget(n->ncp, NULL, NULL) == 0){
      ncplane_destroy(n->ncp);
    }
    free(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_item_set_status()

int ncmenu_item_set_status	(	ncmenu *	n,
		const char *	section,
		const char *	item,
		bool	enabled
	)

Definition at line 784 of file menu.c.

                                        {
  for(int si = 0 ; si < n->sectioncount ; ++si){
    struct ncmenu_int_section* sec = &n->sections[si];
    if(strcmp(sec->name, section) == 0){
      for(unsigned ii = 0 ; ii < sec->itemcount ; ++ii){
        struct ncmenu_int_item* i = &sec->items[ii];
        if(strcmp(i->desc, item) == 0){
          const bool changed = (i->disabled != enabled);
          i->disabled = !enabled;
          if(changed){
            if(i->disabled){
              if(--sec->enabled_item_count == 0){
                write_header(n);
              }
            }else{
              if(++sec->enabled_item_count == 1){
                write_header(n);
              }
            }
            if(n->unrolledsection == si){
              if(sec->enabled_item_count == 0){
                ncmenu_rollup(n);
              }else{
                ncmenu_unroll(n, n->unrolledsection);
              }
            }
          }
          return 0;
        }
      }
      break;
    }
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_mouse_selected()

const char * ncmenu_mouse_selected	(	const ncmenu *	n,
		const ncinput *	click,
		ncinput *	ni
	)

Definition at line 673 of file menu.c.

                                              {
  if(click->id != NCKEY_BUTTON1){
    return NULL;
  }
  if(click->evtype != NCTYPE_RELEASE){
    return NULL;
  }
  struct ncplane* nc = n->ncp;
  int y = click->y;
  int x = click->x;
  unsigned dimy, dimx;
  ncplane_dim_yx(nc, &dimy, &dimx);
  if(!ncplane_translate_abs(nc, &y, &x)){
    return NULL;
  }
  if(n->unrolledsection < 0){
    return NULL;
  }
  const struct ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  int itemidx = ncsection_click_index(n, sec, dimy, dimx, y, x);
  if(itemidx < 0){
    return NULL;
  }
  // don't allow a disabled item to be selected
  if(sec->items[itemidx].disabled){
    return NULL;
  }
  if(ni){
    memcpy(ni, &sec->items[itemidx].shortcut, sizeof(*ni));
  }
  return sec->items[itemidx].desc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_nextitem()

int ncmenu_nextitem

(

ncmenu *

n

)

Definition at line 593 of file menu.c.

                              {
  if(n->unrolledsection == -1){
    if(ncmenu_unroll(n, 0)){
      return -1;
    }
  }
  ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  int origselected = sec->itemselected;
  if(origselected >= 0){
    do{
      if((unsigned)++sec->itemselected == sec->itemcount){
        sec->itemselected = 0;
      }
      if(sec->itemselected == origselected){
        break;
      }
    }while(!sec->items[sec->itemselected].desc || sec->items[sec->itemselected].disabled);
  }
  return ncmenu_unroll(n, n->unrolledsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_nextsection()

int ncmenu_nextsection

(

ncmenu *

n

)

Definition at line 563 of file menu.c.

                                 {
  int nextsection = n->unrolledsection;
  int origselected = n->unrolledsection;
  do{
    if(++nextsection == n->sectioncount){
      nextsection = 0;
    }
    if(nextsection == origselected){
      break;
    }
  }while(n->sections[nextsection].name == NULL ||
         n->sections[nextsection].enabled_item_count == 0);
  return ncmenu_unroll(n, nextsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_offer_input()

bool ncmenu_offer_input	(	ncmenu *	n,
		const ncinput *	nc
	)

Definition at line 707 of file menu.c.

                                                     {
  // we can't actually select menu items in this function, since we need to
  // invoke an arbitrary function as a result.
  if(nc->id == NCKEY_BUTTON1 && nc->evtype == NCTYPE_RELEASE){
    int y = nc->y;
    int x = nc->x;
    unsigned dimy, dimx;
    ncplane_dim_yx(n->ncp, &dimy, &dimx);
    if(!ncplane_translate_abs(n->ncp, &y, &x)){
      return false;
    }
    if(n->unrolledsection >= 0){
      struct ncmenu_int_section* sec = &n->sections[n->unrolledsection];
      int itemidx = ncsection_click_index(n, sec, dimy, dimx, y, x);
      if(itemidx >= 0){
        if(!sec->items[itemidx].disabled){
          sec->itemselected = itemidx;
          ncmenu_unroll(n, n->unrolledsection);
          return false;
        }
      }
    }
    if(y != (n->bottom ? (int)dimy - 1 : 0)){
      return false;
    }
    int i = section_x(n, x);
    if(i < 0 || i == n->unrolledsection){
      ncmenu_rollup(n);
    }else{
      ncmenu_unroll(n, i);
    }
    return true;
  }else if(nc->evtype == NCTYPE_RELEASE){
    return false;
  }
  for(int si = 0 ; si < n->sectioncount ; ++si){
    const ncmenu_int_section* sec = &n->sections[si];
    if(sec->enabled_item_count == 0){
      continue;
    }
    if(!ncinput_equal_p(&sec->shortcut, nc)){
      continue;
    }
    ncmenu_unroll(n, si);
    return true;
  }
  if(n->unrolledsection < 0){ // all following need an unrolled section
    return false;
  }
  if(nc->id == NCKEY_LEFT){
    if(ncmenu_prevsection(n)){
      return false;
    }
    return true;
  }else if(nc->id == NCKEY_RIGHT){
    if(ncmenu_nextsection(n)){
      return false;
    }
    return true;
  }else if(nc->id == NCKEY_UP || nc->id == NCKEY_SCROLL_UP){
    if(ncmenu_previtem(n)){
      return false;
    }
    return true;
  }else if(nc->id == NCKEY_DOWN || nc->id == NCKEY_SCROLL_DOWN){
    if(ncmenu_nextitem(n)){
      return false;
    }
    return true;
  }else if(nc->id == NCKEY_ESC){
    ncmenu_rollup(n);
    return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_plane()

ncplane * ncmenu_plane

(

ncmenu *

menu

)

Definition at line 821 of file menu.c.

                                   {
  return menu->ncp;
}

ncmenu_previtem()

int ncmenu_previtem

(

ncmenu *

n

)

Definition at line 614 of file menu.c.

                              {
  if(n->unrolledsection == -1){
    if(ncmenu_unroll(n, 0)){
      return -1;
    }
  }
  ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  int origselected = sec->itemselected;
  if(origselected >= 0){
    do{
      if(sec->itemselected-- == 0){
        sec->itemselected = sec->itemcount - 1;
      }
      if(sec->itemselected == origselected){
        break;
      }
    }while(!sec->items[sec->itemselected].desc || sec->items[sec->itemselected].disabled);
  }
  return ncmenu_unroll(n, n->unrolledsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_prevsection()

int ncmenu_prevsection

(

ncmenu *

n

)

Definition at line 578 of file menu.c.

                                 {
  int prevsection = n->unrolledsection;
  int origselected = n->unrolledsection;
  do{
    if(--prevsection < 0){
      prevsection = n->sectioncount - 1;
    }
    if(prevsection == origselected){
      break;
    }
  }while(n->sections[prevsection].name == NULL ||
         n->sections[prevsection].enabled_item_count == 0);
  return ncmenu_unroll(n, prevsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_rollup()

int ncmenu_rollup

(

ncmenu *

n

)

Definition at line 554 of file menu.c.

                            {
  if(n->unrolledsection < 0){
    return 0;
  }
  n->unrolledsection = -1;
  ncplane_erase(n->ncp);
  return write_header(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmenu_selected()

const char * ncmenu_selected	(	const ncmenu *	n,
		ncinput *	ni
	)

Definition at line 635 of file menu.c.

                                                         {
  if(n->unrolledsection < 0){
    return NULL;
  }
  const struct ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  const int itemidx = sec->itemselected;
  if(itemidx < 0){
    return NULL;
  }
  if(ni){
    memcpy(ni, &sec->items[itemidx].shortcut, sizeof(*ni));
  }
  return sec->items[itemidx].desc;
}

Here is the caller graph for this function:

ncmenu_unroll()

int ncmenu_unroll	(	ncmenu *	n,
		int	sectionidx
	)

Definition at line 452 of file menu.c.

                                            {
  if(ncmenu_rollup(n)){ // roll up any unrolled section
    return -1;
  }
  if(sectionidx < 0 || sectionidx >= n->sectioncount){
    logerror("unrolled invalid sectionidx %d", sectionidx);
    return -1;
  }
  if(n->sections[sectionidx].enabled_item_count <= 0){
    return 0;
  }
  if(n->sections[sectionidx].name == NULL){
    return -1;
  }
  n->unrolledsection = sectionidx;
  unsigned dimy, dimx;
  ncplane_dim_yx(n->ncp, &dimy, &dimx);
  const int height = section_height(n, sectionidx);
  const int width = section_width(n, sectionidx);
  int xpos = n->sections[sectionidx].xoff < 0 ?
    (int)dimx + (n->sections[sectionidx].xoff - 2) : n->sections[sectionidx].xoff;
  if(xpos + width >= (int)dimx){
    xpos = dimx - (width + 2);
  }
  int ypos = n->bottom ? dimy - height - 1 : 1;
  if(ncplane_cursor_move_yx(n->ncp, ypos, xpos)){
    return -1;
  }
  if(ncplane_rounded_box_sized(n->ncp, 0, n->headerchannels, height, width, 0)){
    return -1;
  }
  ncmenu_int_section* sec = &n->sections[sectionidx];
  for(unsigned i = 0 ; i < sec->itemcount ; ++i){
    ++ypos;
    if(sec->items[i].desc){
      // FIXME the user ought be able to configure the disabled channel
      if(!sec->items[i].disabled){
        ncplane_set_channels(n->ncp, n->sectionchannels);
        if(sec->itemselected < 0){
          sec->itemselected = i;
        }
      }else{
        ncplane_set_channels(n->ncp, n->disablechannels);
      }
      if(sec->itemselected >= 0){
        if(i == (unsigned)sec->itemselected){
          ncplane_set_channels(n->ncp, ncchannels_reverse(ncplane_channels(n->ncp)));
        }
      }
      ncplane_set_styles(n->ncp, 0);
      int cols = ncplane_putstr_yx(n->ncp, ypos, xpos + 1, sec->items[i].desc);
      if(cols < 0){
        return -1;
      }
      // we need pad out the remaining columns of this line with spaces. if
      // there's a shortcut description, we align it to the right, printing
      // spaces only through the start of the aligned description.
      int thiswidth = width;
      if(sec->items[i].shortdesc){
        thiswidth -= sec->items[i].shortdesccols;
      }
      // print any necessary padding spaces
      for(int j = cols + 1 ; j < thiswidth - 1 ; ++j){
        if(ncplane_putchar(n->ncp, ' ') < 0){
          return -1;
        }
      }
      if(sec->items[i].shortdesc){
        if(ncplane_putstr(n->ncp, sec->items[i].shortdesc) < 0){
          return -1;
        }
      }
      if(sec->items[i].shortcut_offset >= 0){
        nccell cl = NCCELL_TRIVIAL_INITIALIZER;
        if(ncplane_at_yx_cell(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
          return -1;
        }
        nccell_on_styles(&cl, NCSTYLE_UNDERLINE|NCSTYLE_BOLD);
        if(ncplane_putc_yx(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
          return -1;
        }
        nccell_release(n->ncp, &cl);
      }
    }else{
      n->ncp->channels = n->headerchannels;
      ncplane_set_styles(n->ncp, 0);
      if(ncplane_putegc_yx(n->ncp, ypos, xpos, "├", NULL) < 0){
        return -1;
      }
      for(int j = 1 ; j < width - 1 ; ++j){
        if(ncplane_putegc(n->ncp, "─", NULL) < 0){
          return -1;
        }
      }
      if(ncplane_putegc(n->ncp, "┤", NULL) < 0){
        return -1;
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: