direct.c File Reference

#include "version.h"
#include "builddef.h"
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include "visual-details.h"
#include "notcurses/direct.h"
#include "internal.h"
#include "unixsig.h"

Include dependency graph for direct.c:

Go to the source code of this file.

Functions
int	ncdirect_putstr (ncdirect *nc, uint64_t channels, const char *utf8)
int	ncdirect_putegc (ncdirect *nc, uint64_t channels, const char *utf8, int *sbytes)
int	ncdirect_cursor_up (ncdirect *nc, int num)
int	ncdirect_cursor_left (ncdirect *nc, int num)
int	ncdirect_cursor_right (ncdirect *nc, int num)
int	ncdirect_cursor_down (ncdirect *nc, int num)
int	ncdirect_clear (ncdirect *nc)
unsigned	ncdirect_dim_x (ncdirect *nc)
unsigned	ncdirect_dim_y (ncdirect *nc)
int	ncdirect_cursor_enable (ncdirect *nc)
int	ncdirect_cursor_disable (ncdirect *nc)
int	ncdirect_cursor_move_yx (ncdirect *n, int y, int x)
int	ncdirect_cursor_yx (ncdirect *n, unsigned *y, unsigned *x)
int	ncdirect_cursor_push (ncdirect *n)
int	ncdirect_cursor_pop (ncdirect *n)
int	ncdirect_raster_frame (ncdirect *n, ncdirectv *ncdv, ncalign_e align)
ncdirectv *	ncdirect_render_frame (ncdirect *n, const char *file, ncblitter_e blitfxn, ncscale_e scale, int ymax, int xmax)
int	ncdirect_render_image (ncdirect *n, const char *file, ncalign_e align, ncblitter_e blitfxn, ncscale_e scale)
int	ncdirect_set_fg_palindex (ncdirect *nc, int pidx)
int	ncdirect_set_bg_palindex (ncdirect *nc, int pidx)
int	ncdirect_vprintf_aligned (ncdirect *n, int y, ncalign_e align, const char *fmt, va_list ap)
int	ncdirect_printf_aligned (ncdirect *n, int y, ncalign_e align, const char *fmt,...)
ncdirect *	ncdirect_core_init (const char *termtype, FILE *outfp, uint64_t flags)
int	ncdirect_stop (ncdirect *nc)
char *	ncdirect_readline (ncdirect *n, const char *prompt)
int	ncdirect_on_styles (ncdirect *n, unsigned stylebits)
uint16_t	ncdirect_styles (const ncdirect *n)
int	ncdirect_off_styles (ncdirect *n, unsigned stylebits)
int	ncdirect_set_styles (ncdirect *n, unsigned stylebits)
unsigned	ncdirect_palette_size (const ncdirect *nc)
int	ncdirect_set_fg_default (ncdirect *nc)
int	ncdirect_set_bg_default (ncdirect *nc)
int	ncdirect_hline_interp (ncdirect *n, const char *egc, unsigned len, uint64_t c1, uint64_t c2)
int	ncdirect_vline_interp (ncdirect *n, const char *egc, unsigned len, uint64_t c1, uint64_t c2)
int	ncdirect_box (ncdirect *n, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr, const wchar_t *wchars, unsigned ylen, unsigned xlen, unsigned ctlword)
int	ncdirect_rounded_box (ncdirect *n, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr, unsigned ylen, unsigned xlen, unsigned ctlword)
int	ncdirect_double_box (ncdirect *n, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr, unsigned ylen, unsigned xlen, unsigned ctlword)
bool	ncdirect_canutf8 (const ncdirect *n)
int	ncdirect_flush (const ncdirect *nc)
int	ncdirect_check_pixel_support (const ncdirect *n)
int	ncdirect_stream (ncdirect *n, const char *filename, ncstreamcb streamer, struct ncvisual_options *vopts, void *curry)
ncdirectf *	ncdirectf_from_file (ncdirect *n __attribute__((unused)), const char *filename)
void	ncdirectf_free (ncdirectf *frame)
ncdirectv *	ncdirectf_render (ncdirect *n, ncdirectf *frame, const struct ncvisual_options *vopts)
int	ncdirectf_geom (ncdirect *n, ncdirectf *frame, const struct ncvisual_options *vopts, ncvgeom *geom)
uint16_t	ncdirect_supported_styles (const ncdirect *nc)
char *	ncdirect_detected_terminal (const ncdirect *nc)
const nccapabilities *	ncdirect_capabilities (const ncdirect *n)
bool	ncdirect_canget_cursor (const ncdirect *n)

Function Documentation

ncdirect_box()

int ncdirect_box	(	ncdirect *	n,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	ll,
		uint64_t	lr,
		const wchar_t *	wchars,
		unsigned	ylen,
		unsigned	xlen,
		unsigned	ctlword
	)

Definition at line 1398 of file direct.c.

                                                                {
  if(xlen < 2 || ylen < 2){
    return -1;
  }
  char hl[MB_LEN_MAX + 1];
  char vl[MB_LEN_MAX + 1];
  unsigned edges;
  edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_LEFT);
  // FIXME rewrite all fprintfs as ncdirect_putstr()!
  if(edges >= box_corner_needs(ctlword)){
    if(activate_channels(n, ul)){
      return -1;
    }
    if(fprintf(n->ttyfp, "%lc", wchars[0]) < 0){
      logerror("error emitting %lc\n", wchars[0]);
      return -1;
    }
  }else{
    ncdirect_cursor_right(n, 1);
  }
  mbstate_t ps = {0};
  size_t bytes;
  if((bytes = wcrtomb(hl, wchars[4], &ps)) == (size_t)-1){
    logerror("error converting %lc\n", wchars[4]);
    return -1;
  }
  hl[bytes] = '\0';
  memset(&ps, 0, sizeof(ps));
  if((bytes = wcrtomb(vl, wchars[5], &ps)) == (size_t)-1){
    logerror("error converting %lc\n", wchars[5]);
    return -1;
  }
  vl[bytes] = '\0';
  if(!(ctlword & NCBOXMASK_TOP)){ // draw top border, if called for
    if(xlen > 2){
      if(ncdirect_hline_interp(n, hl, xlen - 2, ul, ur) < 0){
        return -1;
      }
    }
  }else{
    ncdirect_cursor_right(n, xlen - 2);
  }
  edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_RIGHT);
  if(edges >= box_corner_needs(ctlword)){
    if(activate_channels(n, ur)){
      return -1;
    }
    if(fprintf(n->ttyfp, "%lc", wchars[1]) < 0){
      return -1;
    }
    ncdirect_cursor_left(n, xlen);
  }else{
    ncdirect_cursor_left(n, xlen - 1);
  }
  ncdirect_cursor_down(n, 1);
  // middle rows (vertical lines)
  if(ylen > 2){
    if(!(ctlword & NCBOXMASK_LEFT)){
      if(ncdirect_vline_interp(n, vl, ylen - 2, ul, ll) < 0){
        return -1;
      }
      ncdirect_cursor_right(n, xlen - 2);
      ncdirect_cursor_up(n, ylen - 3);
    }else{
      ncdirect_cursor_right(n, xlen - 1);
    }
    if(!(ctlword & NCBOXMASK_RIGHT)){
      if(ncdirect_vline_interp(n, vl, ylen - 2, ur, lr) < 0){
        return -1;
      }
      ncdirect_cursor_left(n, xlen);
    }else{
      ncdirect_cursor_left(n, xlen - 1);
    }
    ncdirect_cursor_down(n, 1);
  }
  // bottom line
  edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_LEFT);
  if(edges >= box_corner_needs(ctlword)){
    if(activate_channels(n, ll)){
      return -1;
    }
    if(fprintf(n->ttyfp, "%lc", wchars[2]) < 0){
      return -1;
    }
  }else{
    ncdirect_cursor_right(n, 1);
  }
  if(!(ctlword & NCBOXMASK_BOTTOM)){
    if(xlen > 2){
      if(ncdirect_hline_interp(n, hl, xlen - 2, ll, lr) < 0){
        return -1;
      }
    }
  }else{
    ncdirect_cursor_right(n, xlen - 2);
  }
  edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_RIGHT);
  if(edges >= box_corner_needs(ctlword)){
    if(activate_channels(n, lr)){
      return -1;
    }
    if(fprintf(n->ttyfp, "%lc", wchars[3]) < 0){
      return -1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_canget_cursor()

bool ncdirect_canget_cursor

(

const ncdirect *

n

)

Definition at line 1630 of file direct.c.

                                              {
  if(get_escape(&n->tcache, ESCAPE_U7) == NULL){
    return false;
  }
  if(n->tcache.ttyfd < 0){
    return false;
  }
  return true;
}

ncdirect_canutf8()

bool ncdirect_canutf8

(

const ncdirect *

n

)

Definition at line 1522 of file direct.c.

                                        {
  return n->tcache.caps.utf8;
}

Here is the caller graph for this function:

ncdirect_capabilities()

const nccapabilities * ncdirect_capabilities

(

const ncdirect *

n

)

Definition at line 1626 of file direct.c.

                                                              {
  return &n->tcache.caps;
}

Here is the caller graph for this function:

ncdirect_check_pixel_support()

int ncdirect_check_pixel_support

(

const ncdirect *

n

)

Definition at line 1530 of file direct.c.

                                                   {
  if(n->tcache.pixel_draw || n->tcache.pixel_draw_late){
    return 1;
  }
  return 0;
}

Here is the caller graph for this function:

ncdirect_clear()

int ncdirect_clear

(

ncdirect *

nc

)

Definition at line 140 of file direct.c.

                                {
  const char* clearscr = get_escape(&nc->tcache, ESCAPE_CLEAR);
  if(clearscr){
    return term_emit(clearscr, nc->ttyfp, true);
  }
  return -1;
}

Here is the caller graph for this function:

ncdirect_core_init()

ncdirect * ncdirect_core_init	(	const char *	termtype,
		FILE *	outfp,
		uint64_t	flags
	)

Definition at line 871 of file direct.c.

                                                                               {
  if(outfp == NULL){
    outfp = stdout;
  }
  if(flags > (NCDIRECT_OPTION_DRAIN_INPUT << 1)){ // allow them through with warning
    logwarn("Passed unsupported flags 0x%016" PRIx64 "\n", flags);
  }
  if(termtype){
    if(putenv_term(termtype)){
      return NULL;
    }
  }
  ncdirect* ret = malloc(sizeof(ncdirect));
  if(ret == NULL){
    return ret;
  }
  memset(ret, 0, sizeof(*ret));
  if(pthread_mutex_init(&ret->stats.lock, NULL)){
    free(ret);
    return NULL;
  }
  ret->flags = flags;
  ret->ttyfp = outfp;
  if(!(flags & NCDIRECT_OPTION_INHIBIT_SETLOCALE)){
    init_lang();
  }
  const char* encoding = nl_langinfo(CODESET);
  bool utf8 = false;
  if(encoding && encoding_is_utf8(encoding)){
    utf8 = true;
    ncmetric_use_utf8();
  }
  if(setup_signals(ret, (flags & NCDIRECT_OPTION_NO_QUIT_SIGHANDLERS),
                   true, ncdirect_stop_minimal)){
    pthread_mutex_destroy(&ret->stats.lock);
    free(ret);
    return NULL;
  }
  // don't set the loglevel until we've locked in signal handling, lest we
  // change the loglevel out from under a running instance.
  if(flags & NCDIRECT_OPTION_VERY_VERBOSE){
    loglevel = NCLOGLEVEL_TRACE;
  }else if(flags & NCDIRECT_OPTION_VERBOSE){
    loglevel = NCLOGLEVEL_WARNING;
  }else{
    loglevel = NCLOGLEVEL_SILENT;
  }
  set_loglevel_from_env(&loglevel);
  int cursor_y = -1;
  int cursor_x = -1;
  if(interrogate_terminfo(&ret->tcache, ret->ttyfp, utf8, 1,
                          flags & NCDIRECT_OPTION_INHIBIT_CBREAK,
                          0, &cursor_y, &cursor_x, &ret->stats, 0, 0, 0, 0,
                          flags & NCDIRECT_OPTION_DRAIN_INPUT)){
    goto err;
  }
  if(cursor_y >= 0){
    // the u7 led the queries so that we would get a cursor position
    // unaffected by any query spill (unconsumed control sequences). move
    // us back to that location, in case there was any such spillage.
    if(ncdirect_cursor_move_yx(ret, cursor_y, cursor_x)){
      free_terminfo_cache(&ret->tcache);
      goto err;
    }
  }
  if(ncvisual_init(loglevel)){
    free_terminfo_cache(&ret->tcache);
    goto err;
  }
  unsigned cgeo, pgeo; // both are don't-cares
  update_term_dimensions(NULL, NULL, &ret->tcache, 0, &cgeo, &pgeo);
  ncdirect_set_styles(ret, 0);
  return ret;
 
err:{
    void* altstack;
    if(ret->tcache.ttyfd >= 0){
      (void)tcsetattr(ret->tcache.ttyfd, TCSANOW, ret->tcache.tpreserved);
    }
    drop_signals(ret, &altstack);
    pthread_mutex_destroy(&ret->stats.lock);
    free(ret);
  }
  return NULL;
}

Here is the call graph for this function:

ncdirect_cursor_disable()

int ncdirect_cursor_disable

(

ncdirect *

nc

)

Definition at line 182 of file direct.c.

                                         {
  const char* cinvis = get_escape(&nc->tcache, ESCAPE_CIVIS);
  if(cinvis){
    return term_emit(cinvis, nc->ttyfp, true);
  }
  return -1;
}

Here is the caller graph for this function:

ncdirect_cursor_down()

int ncdirect_cursor_down	(	ncdirect *	nc,
		int	num
	)

Definition at line 117 of file direct.c.

                                               {
  if(num < 0){
    logerror("requested negative move %d\n", num);
    return -1;
  }
  if(num == 0){
    return 0;
  }
  int ret = 0;
  while(num--){
    if(ncfputc('\v', nc->ttyfp) == EOF){
      ret = -1;
      break;
    }
  }
  return ret;
}

Here is the caller graph for this function:

ncdirect_cursor_enable()

int ncdirect_cursor_enable

(

ncdirect *

nc

)

Definition at line 174 of file direct.c.

                                        {
  const char* cnorm = get_escape(&nc->tcache, ESCAPE_CNORM);
  if(cnorm){
    return term_emit(cnorm, nc->ttyfp, true);
  }
  return -1;
}

Here is the caller graph for this function:

ncdirect_cursor_left()

int ncdirect_cursor_left	(	ncdirect *	nc,
		int	num
	)

Definition at line 83 of file direct.c.

                                               {
  if(num < 0){
    logerror("requested negative move %d\n", num);
    return -1;
  }
  if(num == 0){
    return 0;
  }
  const char* cub = get_escape(&nc->tcache, ESCAPE_CUB);
  if(cub){
    return term_emit(tiparm(cub, num), nc->ttyfp, false);
  }
  return -1;
}

Here is the caller graph for this function:

ncdirect_cursor_move_yx()

int ncdirect_cursor_move_yx	(	ncdirect *	n,
		int	y,
		int	x
	)

Definition at line 216 of file direct.c.

                                                      {
  const char* hpa = get_escape(&n->tcache, ESCAPE_HPA);
  const char* vpa = get_escape(&n->tcache, ESCAPE_VPA);
  const char* u7 = get_escape(&n->tcache, ESCAPE_U7);
  if(y == -1){ // keep row the same, horizontal move only
    if(hpa){
      return term_emit(tiparm(hpa, x), n->ttyfp, false);
    }else if(n->tcache.ttyfd >= 0 && u7){
      unsigned yprime;
      if(cursor_yx_get(n, u7, &yprime, NULL)){
        return -1;
      }
      y = yprime;
    }else{
      y = 0;
    }
  }else if(x == -1){ // keep column the same, vertical move only
    if(!vpa){
      return term_emit(tiparm(vpa, y), n->ttyfp, false);
    }else if(n->tcache.ttyfd >= 0 && u7){
      unsigned xprime;
      if(cursor_yx_get(n, u7, NULL, &xprime)){
        return -1;
      }
      x = xprime;
    }else{
      x = 0;
    }
  }
  const char* cup = get_escape(&n->tcache, ESCAPE_CUP);
  if(cup){
    return term_emit(tiparm(cup, y, x), n->ttyfp, false);
  }else if(vpa && hpa){
    if(term_emit(tiparm(hpa, x), n->ttyfp, false) == 0 &&
       term_emit(tiparm(vpa, y), n->ttyfp, false) == 0){
      return 0;
    }
  }
  return -1; // we will not be moving the cursor today
}

Here is the caller graph for this function:

ncdirect_cursor_pop()

int ncdirect_cursor_pop

(

ncdirect *

n

)

Definition at line 403 of file direct.c.

                                    {
  const char* rc = get_escape(&n->tcache, ESCAPE_RC);
  if(rc){
    return term_emit(rc, n->ttyfp, false);
  }
  return -1;
}

ncdirect_cursor_push()

int ncdirect_cursor_push

(

ncdirect *

n

)

Definition at line 395 of file direct.c.

                                     {
  const char* sc = get_escape(&n->tcache, ESCAPE_SC);
  if(sc){
    return term_emit(sc, n->ttyfp, false);
  }
  return -1;
}

ncdirect_cursor_right()

int ncdirect_cursor_right	(	ncdirect *	nc,
		int	num
	)

Definition at line 98 of file direct.c.

                                                {
  if(num < 0){
    logerror("requested negative move %d\n", num);
    return -1;
  }
  if(num == 0){
    return 0;
  }
  const char* cuf = get_escape(&nc->tcache, ESCAPE_CUF);
  if(cuf){
    return term_emit(tiparm(cuf, num), nc->ttyfp, false);
  }
  return -1; // FIXME fall back to cuf1?
}

Here is the caller graph for this function:

ncdirect_cursor_up()

int ncdirect_cursor_up	(	ncdirect *	nc,
		int	num
	)

Definition at line 68 of file direct.c.

                                             {
  if(num < 0){
    logerror("requested negative move %d\n", num);
    return -1;
  }
  if(num == 0){
    return 0;
  }
  const char* cuu = get_escape(&nc->tcache, ESCAPE_CUU);
  if(cuu){
    return term_emit(tiparm(cuu, num), nc->ttyfp, false);
  }
  return -1;
}

Here is the caller graph for this function:

ncdirect_cursor_yx()

int ncdirect_cursor_yx	(	ncdirect *	n,
		unsigned *	y,
		unsigned *	x
	)

Definition at line 375 of file direct.c.

                                                             {
  // this is only meaningful for real terminals
  if(n->tcache.ttyfd < 0){
    return -1;
  }
  const char* u7 = get_escape(&n->tcache, ESCAPE_U7);
  if(u7 == NULL){
    fprintf(stderr, "Terminal doesn't support cursor reporting\n");
    return -1;
  }
  unsigned yval, xval;
  if(!y){
    y = &yval;
  }
  if(!x){
    x = &xval;
  }
  return cursor_yx_get(n, u7, y, x);
}

Here is the caller graph for this function:

ncdirect_detected_terminal()

char * ncdirect_detected_terminal

(

const ncdirect *

nc

)

Definition at line 1622 of file direct.c.

                                                    {
  return termdesc_longterm(&nc->tcache);
}

Here is the call graph for this function:

ncdirect_dim_x()

unsigned ncdirect_dim_x

(

ncdirect *

nc

)

Definition at line 148 of file direct.c.

                                     {
  unsigned x;
  if(nc->tcache.ttyfd >= 0){
    unsigned cgeo, pgeo; // don't care about either
    if(update_term_dimensions(NULL, &x, &nc->tcache, 0, &cgeo, &pgeo) == 0){
      return x;
    }
  }else{
    return 80; // lol
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_dim_y()

unsigned ncdirect_dim_y

(

ncdirect *

nc

)

Definition at line 161 of file direct.c.

                                     {
  unsigned y;
  if(nc->tcache.ttyfd >= 0){
    unsigned cgeo, pgeo; // don't care about either
    if(update_term_dimensions(&y, NULL, &nc->tcache, 0, &cgeo, &pgeo) == 0){
      return y;
    }
  }else{
    return 24; // lol
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_double_box()

int ncdirect_double_box	(	ncdirect *	n,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	ll,
		uint64_t	lr,
		unsigned	ylen,
		unsigned	xlen,
		unsigned	ctlword
	)

Definition at line 1515 of file direct.c.

                                                                       {
  return ncdirect_box(n, ul, ur, ll, lr, NCBOXDOUBLEW, ylen, xlen, ctlword);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_flush()

int ncdirect_flush

(

const ncdirect *

nc

)

Definition at line 1526 of file direct.c.

                                      {
  return ncflush(nc->ttyfp);
}

Here is the caller graph for this function:

ncdirect_hline_interp()

int ncdirect_hline_interp	(	ncdirect *	n,
		const char *	egc,
		unsigned	len,
		uint64_t	c1,
		uint64_t	c2
	)

Definition at line 1275 of file direct.c.

                                                   {
  if(len == 0){
    logerror("passed zero length\n");
    return -1;
  }
  unsigned ur, ug, ub;
  int r1, g1, b1, r2, g2, b2;
  int br1, bg1, bb1, br2, bg2, bb2;
  ncchannels_fg_rgb8(c1, &ur, &ug, &ub);
  r1 = ur; g1 = ug; b1 = ub;
  ncchannels_fg_rgb8(c2, &ur, &ug, &ub);
  r2 = ur; g2 = ug; b2 = ub;
  ncchannels_bg_rgb8(c1, &ur, &ug, &ub);
  br1 = ur; bg1 = ug; bb1 = ub;
  ncchannels_bg_rgb8(c2, &ur, &ug, &ub);
  br2 = ur; bg2 = ug; bb2 = ub;
  int deltr = r2 - r1;
  int deltg = g2 - g1;
  int deltb = b2 - b1;
  int deltbr = br2 - br1;
  int deltbg = bg2 - bg1;
  int deltbb = bb2 - bb1;
  unsigned ret;
  bool fgdef = false, bgdef = false;
  if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){
    if(ncdirect_set_fg_default(n)){
      return -1;
    }
    fgdef = true;
  }
  if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){
    if(ncdirect_set_bg_default(n)){
      return -1;
    }
    bgdef = true;
  }
  for(ret = 0 ; ret < len ; ++ret){
    int r = (deltr * (int)ret) / (int)len + r1;
    int g = (deltg * (int)ret) / (int)len + g1;
    int b = (deltb * (int)ret) / (int)len + b1;
    int br = (deltbr * (int)ret) / (int)len + br1;
    int bg = (deltbg * (int)ret) / (int)len + bg1;
    int bb = (deltbb * (int)ret) / (int)len + bb1;
    if(!fgdef){
      ncdirect_set_fg_rgb8(n, r, g, b);
    }
    if(!bgdef){
      ncdirect_set_bg_rgb8(n, br, bg, bb);
    }
    if(fprintf(n->ttyfp, "%s", egc) < 0){
      logerror("error emitting egc [%s]\n", egc);
      return -1;
    }
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_off_styles()

int ncdirect_off_styles	(	ncdirect *	n,
		unsigned	stylebits
	)

Definition at line 1189 of file direct.c.

                                                        {
  uint32_t stylemask = n->stylemask & ~stylebits;
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  if(ncdirect_style_emit(n, stylemask, &f)){
    fbuf_free(&f);
    return -1;
  }
  if(fbuf_finalize(&f, n->ttyfp)){
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

ncdirect_on_styles()

int ncdirect_on_styles	(	ncdirect *	n,
		unsigned	stylebits
	)

Definition at line 1165 of file direct.c.

                                                       {
  if((stylebits & n->tcache.supported_styles) < stylebits){ // unsupported styles
    return -1;
  }
  uint32_t stylemask = n->stylemask | stylebits;
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  if(ncdirect_style_emit(n, stylemask, &f)){
    fbuf_free(&f);
    return -1;
  }
  if(fbuf_finalize(&f, n->ttyfp)){
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

ncdirect_palette_size()

unsigned ncdirect_palette_size

(

const ncdirect *

nc

)

Definition at line 1225 of file direct.c.

                                                  {
  return ncdirect_capabilities(nc)->colors;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_printf_aligned()

int ncdirect_printf_aligned	(	ncdirect *	n,
		int	y,
		ncalign_e	align,
		const char *	fmt,
			...
	)

Definition at line 826 of file direct.c.

                                                                                      {
  va_list va;
  va_start(va, fmt);
  int ret = ncdirect_vprintf_aligned(n, y, align, fmt, va);
  va_end(va);
  return ret;
}

Here is the call graph for this function:

ncdirect_putegc()

int ncdirect_putegc	(	ncdirect *	nc,
		uint64_t	channels,
		const char *	utf8,
		int *	sbytes
	)

Definition at line 49 of file direct.c.

                                {
  int cols;
  int bytes = utf8_egc_len(utf8, &cols);
  if(bytes < 0){
    return -1;
  }
  if(sbytes){
    *sbytes = bytes;
  }
  if(activate_channels(nc, channels)){
    return -1;
  }
  if(fprintf(nc->ttyfp, "%.*s", bytes, utf8) < 0){
    return -1;
  }
  return cols;
}

ncdirect_putstr()

int ncdirect_putstr	(	ncdirect *	nc,
		uint64_t	channels,
		const char *	utf8
	)

Definition at line 42 of file direct.c.

                                                                      {
  if(activate_channels(nc, channels)){
    return -1;
  }
  return ncfputs(utf8, nc->ttyfp);
}

Here is the caller graph for this function:

ncdirect_raster_frame()

int ncdirect_raster_frame	(	ncdirect *	n,
		ncdirectv *	ncdv,
		ncalign_e	align
	)

Definition at line 627 of file direct.c.

                                                                        {
  int lenx = ncplane_dim_x(ncdv);
  int xoff = ncdirect_align(n, align, lenx);
  int r = ncdirect_dump_plane(n, ncdv, xoff);
  free_plane(ncdv);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_readline()

char * ncdirect_readline	(	ncdirect *	n,
		const char *	prompt
	)

Definition at line 985 of file direct.c.

                                                        {
  const char* u7 = get_escape(&n->tcache, ESCAPE_U7);
  if(!u7){ // we probably *can*, but it would be a pita; screw it
    logerror("can't readline without u7");
    return NULL;
  }
  if(n->eof){
    logerror("already got EOF");
    return NULL;
  }
  if(fprintf(n->ttyfp, "%s", prompt) < 0){
    return NULL;
  }
  unsigned dimx = ncdirect_dim_x(n);
  if(dimx == 0){
    return NULL;
  }
  // FIXME what if we're reading from redirected input, not a terminal?
  unsigned y, xstart;
  if(cursor_yx_get(n, u7, &y, &xstart)){
    return NULL;
  }
  int tline = y;
  unsigned bline = y;
  wchar_t* str;
  int wspace = BUFSIZ / sizeof(*str);
  if((str = malloc(wspace * sizeof(*str))) == NULL){
    return NULL;
  }
  int wpos = 0;  // cursor location (single-dimensional)
  int wused = 0; // number used
  str[wused++] = L'\0';
  ncinput ni;
  uint32_t id;
  unsigned oldx = xstart;
  while((id = ncdirect_get_blocking(n, &ni)) != (uint32_t)-1){
    if(ni.evtype == NCTYPE_RELEASE){
      continue;
    }
    if(id == NCKEY_EOF || id == NCKEY_ENTER || (ncinput_ctrl_p(&ni) && id == 'D')){
      if(id == NCKEY_ENTER){
        if(fputc('\n', n->ttyfp) < 0){
          free(str);
          return NULL;
        }
      }else{
        n->eof = 1;
        if(wused == 1){ // NCKEY_EOF without input returns NULL
          free(str);
          return NULL;
        }
      }
      char* ustr = ncwcsrtombs(str);
      free(str);
      return ustr;
    }else if(id == NCKEY_BACKSPACE){
      if(wused > 1){
        str[wused - 2] = L'\0';
        --wused;
      }
      --wpos;
    }else if(id == NCKEY_LEFT){
      --wpos;
    }else if(id == NCKEY_RIGHT){
      ++wpos;
    }else if(id == NCKEY_UP){
      wpos -= dimx;
    }else if(id == NCKEY_DOWN){
      wpos += dimx;
    }else if(id == 'A' && ncinput_ctrl_p(&ni)){
      wpos = 1;
    }else if(id == 'E' && ncinput_ctrl_p(&ni)){
      wpos = wused - 1;
    }else if(nckey_synthesized_p(ni.id)){
      continue;
    }else{
      if(wspace - 1 < wused){
        wspace += BUFSIZ;
        wchar_t* tmp = realloc(str, wspace * sizeof(*str));
        if(tmp == NULL){
          free(str);
          return NULL;
        }
        str = tmp;
      }
      if(wpos < wused - 1){
        memmove(str + wpos + 1, str + wpos, (wused - wpos) * sizeof(*str));
        str[wpos] = id;
        ++wused;
        ++wpos;
      }else{
        str[wused - 1] = id;
        ++wused;
        ++wpos;
        str[wused - 1] = L'\0';
      }
      // FIXME check modifiers
      unsigned x;
      if(cursor_yx_get(n, u7, &y, &x)){
        break;
      }
      if(x < oldx){
        oldx = x;
        if(--tline < 0){
          tline = 0;
        }
      }
      if(y > bline){
        bline = y;
      }
    }
    if(wpos < 0){
      wpos = 0;
    }else if(wpos > wused - 1){
      wpos = wused - 1;
    }
    // clear to end of line(s)
    const char* el = get_escape(&n->tcache, ESCAPE_EL);
    for(int i = bline ; i >= tline ; --i){
      if(ncdirect_cursor_move_yx(n, i, i > tline ? 0 : xstart)){
        break;
      }
      if(term_emit(el, n->ttyfp, false)){
        break;
      }
    }
    if(fprintf(n->ttyfp, "%ls", str) < 0){
      break;
    }
    if(wpos != wused){
      int linear = xstart + wpos;
      int ylin = linear / dimx;
      int xlin = linear % dimx;
      if(ncdirect_cursor_move_yx(n, tline + ylin, xlin)){
        break;
      }
    }
    if(fflush(n->ttyfp)){
      break;
    }
  }
  free(str);
  return NULL;
}

Here is the call graph for this function:

ncdirect_render_frame()

ncdirectv * ncdirect_render_frame	(	ncdirect *	n,
		const char *	file,
		ncblitter_e	blitfxn,
		ncscale_e	scale,
		int	ymax,
		int	xmax
	)

Definition at line 739 of file direct.c.

                                                    {
  if(ymax < 0 || xmax < 0){
    return NULL;
  }
  ncdirectf* ncv = ncdirectf_from_file(n, file);
  if(ncv == NULL){
    return NULL;
  }
  struct ncvisual_options vopts = {0};
  const struct blitset* bset = rgba_blitter_low(&n->tcache, scale, true, blitfxn);
  if(!bset){
    return NULL;
  }
  vopts.blitter = bset->geom;
  vopts.flags = NCVISUAL_OPTION_NODEGRADE;
  vopts.scaling = scale;
  if(ymax > 0){
    if((vopts.leny = ymax * bset->height) > ncv->pixy){
      vopts.leny = 0;
    }
  }
  if(xmax > 0){
    if((vopts.lenx = xmax * bset->width) > ncv->pixx){
      vopts.lenx = 0;
    }
  }
  ncdirectv* v = ncdirectf_render(n, ncv, &vopts);
  ncvisual_destroy(ncv);
  return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_render_image()

int ncdirect_render_image	(	ncdirect *	n,
		const char *	file,
		ncalign_e	align,
		ncblitter_e	blitfxn,
		ncscale_e	scale
	)

Definition at line 772 of file direct.c.

                                                               {
  ncdirectv* faken = ncdirect_render_frame(n, file, blitfxn, scale, 0, 0);
  if(!faken){
    return -1;
  }
  return ncdirect_raster_frame(n, faken, align);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_rounded_box()

int ncdirect_rounded_box	(	ncdirect *	n,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	ll,
		uint64_t	lr,
		unsigned	ylen,
		unsigned	xlen,
		unsigned	ctlword
	)

Definition at line 1509 of file direct.c.

                                                                        {
  return ncdirect_box(n, ul, ur, ll, lr, NCBOXROUNDW, ylen, xlen, ctlword);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_set_bg_default()

int ncdirect_set_bg_default

(

ncdirect *

nc

)

Definition at line 1252 of file direct.c.

                                         {
  if(ncdirect_bg_default_p(nc)){
    return 0;
  }
  const char* esc;
  if((esc = get_escape(&nc->tcache, ESCAPE_BGOP)) != NULL){
    if(term_emit(esc, nc->ttyfp, false)){
      return -1;
    }
  }else if((esc = get_escape(&nc->tcache, ESCAPE_OP)) != NULL){
    if(term_emit(esc, nc->ttyfp, false)){
      return -1;
    }
    if(!ncdirect_fg_default_p(nc)){
      if(ncdirect_set_fg_rgb(nc, ncchannels_fg_rgb(nc->channels))){
        return -1;
      }
    }
  }
  ncchannels_set_bg_default(&nc->channels);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_set_bg_palindex()

int ncdirect_set_bg_palindex	(	ncdirect *	nc,
		int	pidx
	)

Definition at line 792 of file direct.c.

                                                    {
  const char* setab = get_escape(&nc->tcache, ESCAPE_SETAB);
  if(!setab){
    return -1;
  }
  if(ncchannels_set_bg_palindex(&nc->channels, pidx) < 0){
    return -1;
  }
  return term_emit(tiparm(setab, pidx), nc->ttyfp, false);
}

Here is the caller graph for this function:

ncdirect_set_fg_default()

int ncdirect_set_fg_default

(

ncdirect *

nc

)

Definition at line 1229 of file direct.c.

                                         {
  if(ncdirect_fg_default_p(nc)){
    return 0;
  }
  const char* esc;
  if((esc = get_escape(&nc->tcache, ESCAPE_FGOP)) != NULL){
    if(term_emit(esc, nc->ttyfp, false)){
      return -1;
    }
  }else if((esc = get_escape(&nc->tcache, ESCAPE_OP)) != NULL){
    if(term_emit(esc, nc->ttyfp, false)){
      return -1;
    }
    if(!ncdirect_bg_default_p(nc)){
      if(ncdirect_set_bg_rgb(nc, ncchannels_bg_rgb(nc->channels))){
        return -1;
      }
    }
  }
  ncchannels_set_fg_default(&nc->channels);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_set_fg_palindex()

int ncdirect_set_fg_palindex	(	ncdirect *	nc,
		int	pidx
	)

Definition at line 781 of file direct.c.

                                                    {
  const char* setaf = get_escape(&nc->tcache, ESCAPE_SETAF);
  if(!setaf){
    return -1;
  }
  if(ncchannels_set_fg_palindex(&nc->channels, pidx) < 0){
    return -1;
  }
  return term_emit(tiparm(setaf, pidx), nc->ttyfp, false);
}

Here is the caller graph for this function:

ncdirect_set_styles()

int ncdirect_set_styles	(	ncdirect *	n,
		unsigned	stylebits
	)

Definition at line 1206 of file direct.c.

                                                        {
  if((stylebits & n->tcache.supported_styles) < stylebits){ // unsupported styles
    return -1;
  }
  uint32_t stylemask = stylebits;
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  if(ncdirect_style_emit(n, stylemask, &f)){
    fbuf_free(&f);
    return -1;
  }
  if(fbuf_finalize(&f, n->ttyfp)){
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

ncdirect_stop()

int ncdirect_stop

(

ncdirect *

nc

)

Definition at line 957 of file direct.c.

                               {
  int ret = 0;
  if(nc){
    void* altstack;
    ret |= ncdirect_stop_minimal(nc, &altstack, 0);
    free_terminfo_cache(&nc->tcache);
    if(nc->tcache.ttyfd >= 0){
      ret |= close(nc->tcache.ttyfd);
    }
    pthread_mutex_destroy(&nc->stats.lock);
    free(nc);
    free(altstack);
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_stream()

int ncdirect_stream	(	ncdirect *	n,
		const char *	filename,
		ncstreamcb	streamer,
		struct ncvisual_options *	vopts,
		void *	curry
	)

Definition at line 1537 of file direct.c.

                                                                {
  ncvisual* ncv = ncvisual_from_file(filename);
  if(ncv == NULL){
    return -1;
  }
  // starting position *after displaying one frame* so as to effect any
  // necessary scrolling.
  unsigned y = 0, x = 0;
  int lastid = -1;
  int thisid = -1;
  do{
    if(y > 0){
      if(x == ncdirect_dim_x(n)){
        x = 0;
        ++y;
      }
      ncdirect_cursor_up(n, y - 1);
    }
    if(x > 0){
      ncdirect_cursor_left(n, x);
    }
    ncdirectv* v = ncdirect_render_visual(n, ncv, vopts);
    if(v == NULL){
      ncvisual_destroy(ncv);
      return -1;
    }
    ncplane_dim_yx(v, &y, &x);
    if(v->sprite){
      thisid = v->sprite->id;
    }
    if(ncdirect_raster_frame(n, v, (vopts->flags & NCVISUAL_OPTION_HORALIGNED) ? vopts->x : 0)){
      ncvisual_destroy(ncv);
      return -1;
    }
    if(lastid > -1){
      if(n->tcache.pixel_remove){
        fbuf f = {0};
        fbuf_init_small(&f);
        if(n->tcache.pixel_remove(lastid, &f)){
          fbuf_free(&f);
          ncvisual_destroy(ncv);
          return -1;
        }
        if(fbuf_finalize(&f, n->ttyfp) < 0){
          ncvisual_destroy(ncv);
          return -1;
        }
      }
    }
    streamer(ncv, vopts, NULL, curry);
    lastid = thisid;
  }while(ncvisual_decode(ncv) == 0);
  ncdirect_flush(n);
  ncvisual_destroy(ncv);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_styles()

uint16_t ncdirect_styles

(

const ncdirect *

n

)

Definition at line 1184 of file direct.c.

                                           {
  return n->stylemask;
}

ncdirect_supported_styles()

uint16_t ncdirect_supported_styles

(

const ncdirect *

nc

)

Definition at line 1618 of file direct.c.

                                                      {
  return term_supported_styles(&nc->tcache);
}

ncdirect_vline_interp()

int ncdirect_vline_interp	(	ncdirect *	n,
		const char *	egc,
		unsigned	len,
		uint64_t	c1,
		uint64_t	c2
	)

Definition at line 1333 of file direct.c.

                                                   {
  if(len == 0){
    logerror("passed zero length\n");
    return -1;
  }
  unsigned ur, ug, ub;
  int r1, g1, b1, r2, g2, b2;
  int br1, bg1, bb1, br2, bg2, bb2;
  ncchannels_fg_rgb8(c1, &ur, &ug, &ub);
  r1 = ur; g1 = ug; b1 = ub;
  ncchannels_fg_rgb8(c2, &ur, &ug, &ub);
  r2 = ur; g2 = ug; b2 = ub;
  ncchannels_bg_rgb8(c1, &ur, &ug, &ub);
  br1 = ur; bg1 = ug; bb1 = ub;
  ncchannels_bg_rgb8(c2, &ur, &ug, &ub);
  br2 = ur; bg2 = ug; bb2 = ub;
  int deltr = (r2 - r1) / ((int)len + 1);
  int deltg = (g2 - g1) / ((int)len + 1);
  int deltb = (b2 - b1) / ((int)len + 1);
  int deltbr = (br2 - br1) / ((int)len + 1);
  int deltbg = (bg2 - bg1) / ((int)len + 1);
  int deltbb = (bb2 - bb1) / ((int)len + 1);
  unsigned ret;
  bool fgdef = false, bgdef = false;
  if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){
    if(ncdirect_set_fg_default(n)){
      return -1;
    }
    fgdef = true;
  }
  if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){
    if(ncdirect_set_bg_default(n)){
      return -1;
    }
    bgdef = true;
  }
  for(ret = 0 ; ret < len ; ++ret){
    r1 += deltr;
    g1 += deltg;
    b1 += deltb;
    br1 += deltbr;
    bg1 += deltbg;
    bb1 += deltbb;
    uint64_t channels = 0;
    if(!fgdef){
      ncchannels_set_fg_rgb8(&channels, r1, g1, b1);
    }
    if(!bgdef){
      ncchannels_set_bg_rgb8(&channels, br1, bg1, bb1);
    }
    if(ncdirect_putstr(n, channels, egc) == EOF){
      return -1;
    }
    if(len - ret > 1){
      if(ncdirect_cursor_down(n, 1) || ncdirect_cursor_left(n, 1)){
        return -1;
      }
    }
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_vprintf_aligned()

int ncdirect_vprintf_aligned	(	ncdirect *	n,
		int	y,
		ncalign_e	align,
		const char *	fmt,
		va_list	ap
	)

Definition at line 803 of file direct.c.

                                                                                              {
  char* r = ncplane_vprintf_prep(fmt, ap);
  if(r == NULL){
    return -1;
  }
  const int len = ncstrwidth(r, NULL, NULL);
  if(len < 0){
    free(r);
    return -1;
  }
  const int x = ncdirect_align(n, align, len);
  if(ncdirect_cursor_move_yx(n, y, x)){
    free(r);
    return -1;
  }
  int ret = puts(r);
  free(r);
  if(ret == EOF){
    return -1;
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirectf_free()

void ncdirectf_free

(

ncdirectf *

frame

)

Definition at line 1600 of file direct.c.

                                     {
  ncvisual_destroy(frame);
}

Here is the call graph for this function:

ncdirectf_from_file()

ncdirectf * ncdirectf_from_file	(	ncdirect *n	__attribute__(unused),
		const char *	filename
	)

Definition at line 1595 of file direct.c.

                                                    {
  return ncvisual_from_file(filename);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirectf_geom()

int ncdirectf_geom	(	ncdirect *	n,
		ncdirectf *	frame,
		const struct ncvisual_options *	vopts,
		ncvgeom *	geom
	)

Definition at line 1608 of file direct.c.

                                                                       {
  const struct blitset* bset;
  unsigned disppxy, disppxx, outy, outx;
  int placey, placex;
  return ncvisual_geom_inner(&n->tcache, frame, vopts, geom, &bset,
                             &disppxy, &disppxx, &outy, &outx,
                             &placey, &placex);
}

Here is the call graph for this function:

ncdirectf_render()

ncdirectv * ncdirectf_render	(	ncdirect *	n,
		ncdirectf *	frame,
		const struct ncvisual_options *	vopts
	)

Definition at line 1604 of file direct.c.

                                                                                                {
  return ncdirect_render_visual(n, frame, vopts);
}

Here is the caller graph for this function: