internal.h File Reference

#include "version.h"
#include "builddef.h"
#include "compat/compat.h"
#include "notcurses/ncport.h"
#include "notcurses/notcurses.h"
#include "notcurses/direct.h"
#include <term.h>
#include <time.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <wctype.h>
#include <pthread.h>
#include <stdbool.h>
#include <inttypes.h>
#include <unictype.h>
#include <langinfo.h>
#include "lib/termdesc.h"
#include "lib/egcpool.h"
#include "lib/sprite.h"
#include "lib/fbuf.h"
#include "lib/gpm.h"
#include "blitset.h"

Include dependency graph for internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ncplane
struct	rasterstate
struct	nctablet
struct	ncreel
struct	ncfdplane
struct	ncsubproc
struct	ncreader
struct	ncprogbar
struct	nctab
struct	ncsharedstats
struct	ncdirect
struct	crender
struct	ncpile
struct	notcurses
struct	blitterargs
struct	blitset
struct	topolyfill
struct	ncvisual_implementation

Macros
#define	API   __attribute__((visibility("default")))
#define	ALLOC   __attribute__((malloc)) __attribute__((warn_unused_result))
#define	__STDC_FORMAT_MACROS
#define	NC_BLITTERSTACK_MASK   NC_NOBACKGROUND_MASK
#define	SET_X10_MOUSE_PROT   "9"
#define	SET_X11_MOUSE_PROT   "1000"
#define	SET_HILITE_MOUSE_PROT   "1001"
#define	SET_BTN_EVENT_MOUSE   "1002"
#define	SET_ALL_EVENT_MOUSE   "1003"
#define	SET_FOCUS_EVENT_MOUSE   "1004"
#define	SET_UTF8_MOUSE_PROT   "1005"
#define	SET_SGR_MOUSE_PROT   "1006"
#define	SET_ALTERNATE_SCROLL   "1007"
#define	SET_TTYOUTPUT_SCROLL   "1010"
#define	SET_KEYPRESS_SCROLL   "1011"
#define	SET_URXVT_MOUSE_PROT   "1015"
#define	SET_PIXEL_MOUSE_PROT   "1016"
#define	SET_ENABLE_ALTSCREEN   "1046"
#define	SET_ALTERNATE_SCREEN   "1047"
#define	SET_SAVE_CURSOR   "1048"
#define	SET_SMCUP   "1049"
#define	DECSET(p)   "\x1b[?" p "h"
#define	DECRST(p)   "\x1b[?" p "l"

Typedefs
typedef struct ncplane	ncplane
typedef struct rasterstate	rasterstate
typedef struct nctablet	nctablet
typedef struct ncreel	ncreel
typedef struct ncfdplane	ncfdplane
typedef struct ncsubproc	ncsubproc
typedef struct ncreader	ncreader
typedef struct ncprogbar	ncprogbar
typedef struct nctab	nctab
typedef struct ncsharedstats	ncsharedstats
typedef struct ncdirect	ncdirect
typedef struct ncpile	ncpile
typedef struct notcurses	notcurses
typedef struct blitterargs	blitterargs
typedef struct ncvisual_implementation	ncvisual_implementation

Functions
void	reset_stats (ncstats *stats)
void	summarize_stats (notcurses *nc)
void	update_raster_stats (const struct timespec *time1, const struct timespec *time0, ncstats *stats)
void	update_render_stats (const struct timespec *time1, const struct timespec *time0, ncstats *stats)
void	update_raster_bytes (ncstats *stats, int bytes)
void	update_write_stats (const struct timespec *time1, const struct timespec *time0, ncstats *stats, int bytes)
void	sigwinch_handler (int signo)
void	init_lang (void)
int	reset_term_attributes (const tinfo *ti, fbuf *f)
int	reset_term_palette (const tinfo *ti, fbuf *f, unsigned touchedpalette)
void	warn_terminfo (const notcurses *nc, const tinfo *ti)
int	resize_callbacks_children (ncplane *n)
int	ncvisual_init (int loglevel)
int	clear_and_home (notcurses *nc, tinfo *ti, fbuf *f)
int	sprite_wipe (const notcurses *nc, sprixel *s, int y, int x)
void	sprixel_free (sprixel *s)
void	sprixel_hide (sprixel *s)
sprixel *	sprixel_alloc (ncplane *n, int dimy, int dimx)
sprixel *	sprixel_recycle (ncplane *n)
int	sprite_clear_all (const tinfo *t, fbuf *f)
void	sprixel_invalidate (sprixel *s, int y, int x)
void	sprixel_movefrom (sprixel *s, int y, int x)
void	sprixel_debug (const sprixel *s, FILE *out)
void	sixelmap_free (struct sixelmap *s)
int	ncplane_resize_internal (ncplane *n, int keepy, int keepx, unsigned keepleny, unsigned keeplenx, int yoff, int xoff, unsigned ylen, unsigned xlen)
int	update_term_dimensions (unsigned *rows, unsigned *cols, tinfo *tcache, int margin_b, unsigned *cgeo_changed, unsigned *pgeo_changed) __attribute__((nonnull(3
ALLOC void *	bgra_to_rgba (const void *data, int rows, int *rowstride, int cols, int alpha)
ALLOC void *	rgb_loose_to_rgba (const void *data, int rows, int *rowstride, int cols, int alpha)
ALLOC void *	rgb_packed_to_rgba (const void *data, int rows, int *rowstride, int cols, int alpha)
int	ncvisual_bounding_box (const struct ncvisual *ncv, int *leny, int *lenx, int *offy, int *offx)
ncplane *	ncplane_new_internal (notcurses *nc, ncplane *n, const ncplane_options *nopts)
void	free_plane (ncplane *p)
ALLOC char *	ncplane_vprintf_prep (const char *format, va_list ap)
int	ncvisual_blit_internal (const struct ncvisual *ncv, int rows, int cols, ncplane *n, const struct blitset *bset, const blitterargs *bargs)
int	set_fd_nonblocking (int fd, unsigned state, unsigned *oldstate)
int	mouse_setup (tinfo *ti, unsigned eventmask)
void	scroll_down (ncplane *n)
int	get_tty_fd (FILE *ttyfp)
bool	check_gradient_args (uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br)
void	ncvisual_printbanner (fbuf *f)
int	ncdirect_set_fg_rgb_f (ncdirect *nc, unsigned rgb, fbuf *f)
int	ncdirect_set_bg_rgb_f (ncdirect *nc, unsigned rgb, fbuf *f)
int	term_fg_rgb8 (const tinfo *ti, fbuf *f, unsigned r, unsigned g, unsigned b)
const struct blitset *	lookup_blitset (const tinfo *tcache, ncblitter_e setid, bool may_degrade)
int	ncvisual_geom_inner (const tinfo *ti, const struct ncvisual *n, const struct ncvisual_options *vopts, ncvgeom *geom, const struct blitset **bset, unsigned *disppxy, unsigned *disppxx, unsigned *outy, unsigned *outx, int *placey, int *placex)
int	putenv_term (const char *termname) __attribute__((nonnull(1)))
int	set_loglevel_from_env (ncloglevel_e *loglevel) __attribute__((nonnull(1)))
void	ncmetric_use_utf8 (void)

Variables
API ncvisual_implementation *	visual_implementation

Macro Definition Documentation

__STDC_FORMAT_MACROS

#define __STDC_FORMAT_MACROS

Definition at line 39 of file internal.h.

ALLOC

#define ALLOC   __attribute__((malloc)) __attribute__((warn_unused_result))

Definition at line 20 of file internal.h.

API

#define API   __attribute__((visibility("default")))

Definition at line 16 of file internal.h.

DECRST

#define DECRST

(

p

)

"\x1b[?" p "l"

Definition at line 1195 of file internal.h.

DECSET

#define DECSET

(

p

)

"\x1b[?" p "h"

Definition at line 1194 of file internal.h.

NC_BLITTERSTACK_MASK

#define NC_BLITTERSTACK_MASK   NC_NOBACKGROUND_MASK

Definition at line 57 of file internal.h.

SET_ALL_EVENT_MOUSE

#define SET_ALL_EVENT_MOUSE   "1003"

Definition at line 1180 of file internal.h.

SET_ALTERNATE_SCREEN

#define SET_ALTERNATE_SCREEN   "1047"

Definition at line 1190 of file internal.h.

SET_ALTERNATE_SCROLL

#define SET_ALTERNATE_SCROLL   "1007"

Definition at line 1184 of file internal.h.

SET_BTN_EVENT_MOUSE

#define SET_BTN_EVENT_MOUSE   "1002"

Definition at line 1179 of file internal.h.

SET_ENABLE_ALTSCREEN

#define SET_ENABLE_ALTSCREEN   "1046"

Definition at line 1189 of file internal.h.

SET_FOCUS_EVENT_MOUSE

#define SET_FOCUS_EVENT_MOUSE   "1004"

Definition at line 1181 of file internal.h.

SET_HILITE_MOUSE_PROT

#define SET_HILITE_MOUSE_PROT   "1001"

Definition at line 1178 of file internal.h.

SET_KEYPRESS_SCROLL

#define SET_KEYPRESS_SCROLL   "1011"

Definition at line 1186 of file internal.h.

SET_PIXEL_MOUSE_PROT

#define SET_PIXEL_MOUSE_PROT   "1016"

Definition at line 1188 of file internal.h.

SET_SAVE_CURSOR

#define SET_SAVE_CURSOR   "1048"

Definition at line 1191 of file internal.h.

SET_SGR_MOUSE_PROT

#define SET_SGR_MOUSE_PROT   "1006"

Definition at line 1183 of file internal.h.

SET_SMCUP

#define SET_SMCUP   "1049"

Definition at line 1192 of file internal.h.

SET_TTYOUTPUT_SCROLL

#define SET_TTYOUTPUT_SCROLL   "1010"

Definition at line 1185 of file internal.h.

SET_URXVT_MOUSE_PROT

#define SET_URXVT_MOUSE_PROT   "1015"

Definition at line 1187 of file internal.h.

SET_UTF8_MOUSE_PROT

#define SET_UTF8_MOUSE_PROT   "1005"

Definition at line 1182 of file internal.h.

SET_X10_MOUSE_PROT

#define SET_X10_MOUSE_PROT   "9"

Definition at line 1175 of file internal.h.

SET_X11_MOUSE_PROT

#define SET_X11_MOUSE_PROT   "1000"

Definition at line 1177 of file internal.h.

Typedef Documentation

blitterargs

typedef struct blitterargs blitterargs

ncdirect

typedef struct ncdirect ncdirect

ncfdplane

typedef struct ncfdplane ncfdplane

ncpile

typedef struct ncpile ncpile

ncplane

typedef struct ncplane ncplane

ncprogbar

typedef struct ncprogbar ncprogbar

ncreader

typedef struct ncreader ncreader

ncreel

typedef struct ncreel ncreel

ncsharedstats

typedef struct ncsharedstats ncsharedstats

ncsubproc

typedef struct ncsubproc ncsubproc

nctab

typedef struct nctab nctab

nctablet

typedef struct nctablet nctablet

ncvisual_implementation

typedef struct ncvisual_implementation ncvisual_implementation

notcurses

typedef struct notcurses notcurses

rasterstate

typedef struct rasterstate rasterstate

Function Documentation

bgra_to_rgba()

ALLOC void * bgra_to_rgba	(	const void *	data,
		int	rows,
		int *	rowstride,
		int	cols,
		int	alpha
	)

Definition at line 508 of file visual.c.

                                                                                   {
  if(*rowstride % 4){ // must be a multiple of 4 bytes
    return NULL;
  }
  if(*rowstride < cols * 4){
    return NULL;
  }
  uint32_t* ret = malloc(4 * cols * rows);
  if(ret){
    for(int y = 0 ; y < rows ; ++y){
      for(int x = 0 ; x < cols ; ++x){
        const uint32_t* src = (const uint32_t*)data + (*rowstride / 4) * y + x;
        uint32_t* dst = ret + cols * y + x;
        *dst = 0; // kill scan-build warning about using uninitialized value below
        ncpixel_set_a(dst, alpha);
        ncpixel_set_r(dst, ncpixel_b(*src));
        ncpixel_set_g(dst, ncpixel_g(*src));
        ncpixel_set_b(dst, ncpixel_r(*src));
      }
    }
  }
  *rowstride = cols * 4;
  return ret;
}

Here is the caller graph for this function:

check_gradient_args()

bool check_gradient_args	(	uint64_t	ul,
		uint64_t	ur,
		uint64_t	bl,
		uint64_t	br
	)

Definition at line 150 of file fill.c.

                                                                            {
  if(check_gradient_channel_args(ncchannels_fchannel(ul), ncchannels_fchannel(ur),
                                 ncchannels_fchannel(bl), ncchannels_fchannel(br))){
    return true;
  }
  if(check_gradient_channel_args(ncchannels_bchannel(ul), ncchannels_bchannel(ur),
                                 ncchannels_bchannel(bl), ncchannels_bchannel(br))){
    return true;
  }
  return false;
}

Here is the caller graph for this function:

clear_and_home()

int clear_and_home	(	notcurses *	nc,
		tinfo *	ti,
		fbuf *	f
	)

Definition at line 1399 of file render.c.

                                                     {
  // clear clears the screen and homes the cursor by itself
  const char* clearscr = get_escape(ti, ESCAPE_CLEAR);
  if(clearscr){
    if(fbuf_emit(f, clearscr) == 0){
      nc->rstate.x = nc->rstate.y = 0;
      return 0;
    }
  }
  if(emit_scrolls_track(nc, ncplane_dim_y(notcurses_stdplane_const(nc)), f)){
    return -1;
  }
  if(goto_location(nc, f, 0, 0, NULL)){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

free_plane()

void free_plane

(

ncplane *

p

)

Definition at line 467 of file notcurses.c.

                           {
  if(p){
    // ncdirect fakes an ncplane with no ->pile
    if(ncplane_pile(p)){
      notcurses* nc = ncplane_notcurses(p);
      pthread_mutex_lock(&nc->stats.lock);
        --ncplane_notcurses(p)->stats.s.planes;
        ncplane_notcurses(p)->stats.s.fbbytes -= sizeof(*p->fb) * p->leny * p->lenx;
      pthread_mutex_unlock(&nc->stats.lock);
      if(p->above == NULL && p->below == NULL){
        pthread_mutex_lock(&nc->pilelock);
          ncpile_destroy(ncplane_pile(p));
        pthread_mutex_unlock(&nc->pilelock);
      }
    }
    if(p->widget){
      void* w = p->widget;
      void (*wdestruct)(void*) = p->wdestruct;
      p->widget = NULL;
      p->wdestruct = NULL;
      logdebug("calling widget destructor %p(%p)", wdestruct, w);
      wdestruct(w);
      logdebug("got the widget");
    }
    if(p->sprite){
      sprixel_hide(p->sprite);
    }
    destroy_tam(p);
    egcpool_dump(&p->pool);
    free(p->name);
    free(p->fb);
    free(p);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_tty_fd()

int get_tty_fd

(

FILE *

ttyfp

)

Definition at line 455 of file fd.c.

                           {
  int fd = -1;
  if(ttyfp){
    if((fd = fileno(ttyfp)) < 0){
      logwarn("no file descriptor was available in outfp %p", ttyfp);
    }else{
      if(tty_check(fd)){
        fd = dup(fd);
      }else{
        loginfo("fd %d is not a TTY", fd);
        fd = -1;
      }
    }
  }
  if(fd < 0){
    fd = open("/dev/tty", O_RDWR | O_CLOEXEC | O_NOCTTY);
    if(fd < 0){
      loginfo("couldn't open /dev/tty (%s)", strerror(errno));
    }else{
      if(!tty_check(fd)){
        loginfo("file descriptor for /dev/tty (%d) is not actually a TTY", fd);
        close(fd);
        fd = -1;
      }
    }
  }
  if(fd >= 0){
    loginfo("returning TTY fd %d", fd);
  }
  return fd;
}

Here is the caller graph for this function:

init_lang()

void init_lang

(

void

)

Definition at line 1097 of file notcurses.c.

                    {
#ifdef __MINGW32__
  if(setlocale(LC_ALL, ".UTF8") == NULL){
    logwarn("couldn't set LC_ALL to utf8");
  }
#endif
  const char* encoding = nl_langinfo(CODESET);
  if(encoding && encoding_is_utf8(encoding)){
    return; // already utf-8, great!
  }
  const char* lang = getenv("LANG");
  // if LANG was explicitly set to C/POSIX, life sucks, roll with it
  if(lang && (!strcmp(lang, "C") || !strcmp(lang, "POSIX"))){
    loginfo("LANG was explicitly set to %s, not changing locale", lang);
    return;
  }
#ifndef __MINGW32__
  if(setlocale(LC_ALL, "") == NULL){
    logwarn("setting locale based on LANG failed");
  }
#endif
  encoding = nl_langinfo(CODESET);
  if(encoding && encoding_is_utf8(encoding)){
    loginfo("set locale from LANG; client should call setlocale(2)!");
    return;
  }
  setlocale(LC_CTYPE, "C.UTF-8");
  encoding = nl_langinfo(CODESET);
  if(encoding && encoding_is_utf8(encoding)){
    loginfo("forced UTF-8 encoding; client should call setlocale(2)!");
    return;
  }
}

Here is the caller graph for this function:

lookup_blitset()

const struct blitset * lookup_blitset	(	const tinfo *	tcache,
		ncblitter_e	setid,
		bool	may_degrade
	)

Definition at line 1297 of file blit.c.

                                                      {
  if(setid == NCBLIT_DEFAULT){ // ought have resolved NCBLIT_DEFAULT before now
    return NULL;
  }
  // without braille support, NCBLIT_BRAILLE decays to NCBLIT_4x2
  if(setid == NCBLIT_BRAILLE){
    if(tcache->caps.braille){
      return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_4x2;
  }
  // without octant support, NCBLIT_4x2 decays to NCBLIT_3x2
  if(setid == NCBLIT_4x2){
    if(tcache->caps.octants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_3x2;
  }
  // without bitmap support, NCBLIT_PIXEL decays to NCBLIT_3x2
  if(setid == NCBLIT_PIXEL){
    if(tcache->pixel_draw || tcache->pixel_draw_late){
      return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_3x2;
  }
  // without eighths support, NCBLIT_8x1 decays to NCBLIT_4x1
  if(setid == NCBLIT_8x1){ // plotter only
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_4x1;
  }
  // without quarters support, NCBLIT_4x1 decays to NCBLIT_2x1
  if(setid == NCBLIT_4x1){ // plotter only
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x1;
  }
  // without sextant support, NCBLIT_3x2 decays to NCBLIT_2x2
  if(setid == NCBLIT_3x2){
    if(tcache->caps.sextants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x2;
  }
  // without quadrant support, NCBLIT_2x2 decays to NCBLIT_2x1
  if(setid == NCBLIT_2x2){
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x1;
  }
  // without halfblock support, NCBLIT_2x1 decays to NCBLIT_1x1
  if(setid == NCBLIT_2x1){
    if(tcache->caps.halfblocks){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_1x1;
  }
  assert(NCBLIT_1x1 == setid);
  return &notcurses_blitters[setid - 1];
}

Here is the call graph for this function:

mouse_setup()

int mouse_setup	(	tinfo *	ti,
		unsigned	eventmask
	)

Definition at line 3 of file mice.c.

                                              {
  if(ti->qterm == TERMINAL_LINUX){
    if(eventmask == 0){
      if(ti->gpmfd < 0){
        return 0;
      }
      ti->gpmfd = -1;
      return gpm_close(ti);
    }
    if(ti->gpmfd < 0){
      // FIXME pass in eventmask
      if((ti->gpmfd = gpm_connect(ti)) < 0){
        return -1;
      }
    }
    return 0;
  }
  if(ti->ttyfd < 0){
    logerror("no tty, not emitting mouse control\n");
    return -1;
  }
  // we'll need to fill in 'h' vs 'l' for both, and the event mode
  char command = 'h';
  // we have to choose one event mode, where all > drag > button > none.
  // if user wants *only* move and not button, we'll need filter those FIXME.
  if(eventmask & NCMICE_MOVE_EVENT){
    ti->mouseproto = '3'; // SET_ALL_EVENT_MOUSE
  }else if(eventmask & NCMICE_DRAG_EVENT){
    ti->mouseproto = '2'; // SET_BTN_EVENT_MOUSE
  }else if(eventmask & NCMICE_BUTTON_EVENT){
    ti->mouseproto = '0'; // SET_X11_MOUSE_PROT
  }else if(eventmask == 0){
    if(ti->mouseproto == 0){
      return 0;
    }
    command = 'l';
  }
// Sets the shift-escape option, allowing shift+mouse to override the standard
// mouse protocol (mainly so copy-and-paste can still be performed).
#define XTSHIFTESCAPE "\x1b[>1s"
  char* mousecmd;
  if(ti->pixelmice){
    static char m[] = XTSHIFTESCAPE "\x1b[?100x;" SET_PIXEL_MOUSE_PROT "x";
    mousecmd = m;
  }else{
    static char m[] = XTSHIFTESCAPE "\x1b[?100x;" SET_SGR_MOUSE_PROT "x";
    mousecmd = m;
  }
  mousecmd[11] = ti->mouseproto;
  mousecmd[17] = command;
  if(command == 'l'){
    ti->mouseproto = 0;
  }
  return tty_emit(mousecmd, ti->ttyfd);
#undef XTSHIFTESCAPE
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncdirect_set_bg_rgb_f()

int ncdirect_set_bg_rgb_f	(	ncdirect *	nc,
		unsigned	rgb,
		fbuf *	f
	)

Definition at line 1652 of file render.c.

                                                              {
  if(rgb > 0xffffffu){
    return -1;
  }
  if(!ncdirect_bg_default_p(nc) && !ncdirect_bg_palindex_p(nc)
     && ncchannels_bg_rgb(nc->channels) == rgb){
    return 0;
  }
  if(term_bg_rgb8(&nc->tcache, f, (rgb & 0xff0000u) >> 16u, (rgb & 0xff00u) >> 8u, rgb & 0xffu)){
    return -1;
  }
  ncchannels_set_bg_rgb(&nc->channels, rgb);
  return 0;
}

Here is the caller graph for this function:

ncdirect_set_fg_rgb_f()

int ncdirect_set_fg_rgb_f	(	ncdirect *	nc,
		unsigned	rgb,
		fbuf *	f
	)

Definition at line 1682 of file render.c.

                                                              {
  if(rgb > 0xffffffu){
    return -1;
  }
  if(!ncdirect_fg_default_p(nc) && !ncdirect_fg_palindex_p(nc)
     && ncchannels_fg_rgb(nc->channels) == rgb){
    return 0;
  }
  if(term_fg_rgb8(&nc->tcache, f, (rgb & 0xff0000u) >> 16u, (rgb & 0xff00u) >> 8u, rgb & 0xffu)){
    return -1;
  }
  ncchannels_set_fg_rgb(&nc->channels, rgb);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncmetric_use_utf8()

void ncmetric_use_utf8

(

void

)

Definition at line 24 of file metric.c.

                            {
  pthread_once(&utf8_verdict, ncmetric_use_utf8_internal);
}

Here is the caller graph for this function:

ncplane_new_internal()

ncplane * ncplane_new_internal	(	notcurses *	nc,
		ncplane *	n,
		const ncplane_options *	nopts
	)

Definition at line 560 of file notcurses.c.

                                                           {
  if(nopts->flags >= (NCPLANE_OPTION_FIXED << 1u)){
    logwarn("provided unsupported flags %016" PRIx64, nopts->flags);
  }
  if(nopts->flags & NCPLANE_OPTION_HORALIGNED || nopts->flags & NCPLANE_OPTION_VERALIGNED){
    if(n == NULL){
      logerror("alignment requires a parent plane");
      return NULL;
    }
  }
  if(nopts->flags & NCPLANE_OPTION_MARGINALIZED){
    if(nopts->rows != 0 || nopts->cols != 0){
      logerror("geometry specified with margins (r=%u, c=%u)",
               nopts->rows, nopts->cols);
      return NULL;
    }
  }
  ncplane* p = malloc(sizeof(*p));
  if(p == NULL){
    return NULL;
  }
  p->scrolling = nopts->flags & NCPLANE_OPTION_VSCROLL;
  p->fixedbound = nopts->flags & NCPLANE_OPTION_FIXED;
  p->autogrow = nopts->flags & NCPLANE_OPTION_AUTOGROW;
  p->widget = NULL;
  p->wdestruct = NULL;
  if(nopts->flags & NCPLANE_OPTION_MARGINALIZED){
    p->margin_b = nopts->margin_b;
    p->margin_r = nopts->margin_r;
    if(n){ // use parent size
      p->leny = ncplane_dim_y(n);
      p->lenx = ncplane_dim_x(n);
    }else{ // use pile size
      notcurses_term_dim_yx(nc, &p->leny, &p->lenx);
    }
    if((p->leny -= p->margin_b) <= 0){
      p->leny = 1;
    }
    if((p->lenx -= p->margin_r) <= 0){
      p->lenx = 1;
    }
  }else{
    p->leny = nopts->rows;
    p->lenx = nopts->cols;
  }
 
  size_t fbsize = ncplane_sizeof_cellarray(p->leny, p->lenx);
  if(!fbsize || (p->fb = calloc(fbsize, sizeof(struct nccell))) == NULL){
    logerror("error allocating cellmatrix (r=%u, c=%u)",
             p->leny, p->lenx);
    free(p);
    return NULL;
  }
  p->x = p->y = 0;
  p->logrow = 0;
  p->sprite = NULL;
  p->blist = NULL;
  p->name = strdup(nopts->name ? nopts->name : "");
  p->halign = NCALIGN_UNALIGNED;
  p->valign = NCALIGN_UNALIGNED;
  p->tam = NULL;
  if(!n){ // new root/standard plane
    p->absy = nopts->y;
    p->absx = nopts->x;
    p->bnext = NULL;
    p->bprev = NULL;
    p->boundto = p;
  }else{ // bound to preexisting pile
    if(nopts->flags & NCPLANE_OPTION_HORALIGNED){
      p->absx = ncplane_halign(n, nopts->x, nopts->cols);
      p->halign = nopts->x;
    }else{
      p->absx = nopts->x;
    }
    p->absx += n->absx;
    if(nopts->flags & NCPLANE_OPTION_VERALIGNED){
      p->absy = ncplane_valign(n, nopts->y, nopts->rows);
      p->valign = nopts->y;
    }else{
      p->absy = nopts->y;
    }
    p->absy += n->absy;
    if( (p->bnext = n->blist) ){
      n->blist->bprev = &p->bnext;
    }
    p->bprev = &n->blist;
    *p->bprev = p;
    p->boundto = n;
  }
  // FIXME handle top/left margins
  p->resizecb = nopts->resizecb;
  p->stylemask = 0;
  p->channels = 0;
  egcpool_init(&p->pool);
  nccell_init(&p->basecell);
  p->userptr = nopts->userptr;
  if(nc == NULL){ // fake ncplane backing ncdirect object
    p->above = NULL;
    p->below = NULL;
    p->pile = NULL;
  }else{
    pthread_mutex_lock(&nc->pilelock);
      ncpile* pile = n ? ncplane_pile(n) : NULL;
      if( (p->pile = pile) ){ // existing pile
        p->above = NULL;
        if( (p->below = pile->top) ){ // always happens save initial plane
          pile->top->above = p;
        }else{
          pile->bottom = p;
        }
        pile->top = p;
      }else{ // new pile
        make_ncpile(nc, p);
      }
      pthread_mutex_lock(&nc->stats.lock);
        nc->stats.s.fbbytes += fbsize;
        ++nc->stats.s.planes;
      pthread_mutex_unlock(&nc->stats.lock);
    pthread_mutex_unlock(&nc->pilelock);
  }
  loginfo("created new %ux%u plane \"%s\" @ %dx%d",
          p->leny, p->lenx, p->name ? p->name : "", p->absy, p->absx);
  return p;
}

Here is the caller graph for this function:

ncplane_resize_internal()

int ncplane_resize_internal	(	ncplane *	n,
		int	keepy,
		int	keepx,
		unsigned	keepleny,
		unsigned	keeplenx,
		int	yoff,
		int	xoff,
		unsigned	ylen,
		unsigned	xlen
	)

Definition at line 857 of file notcurses.c.

                                                         {
  unsigned rows, cols;
  if(ncplane_resize_internal_check(n, keepy, keepx, keepleny, keeplenx,
                                   yoff, xoff, ylen, xlen,
                                   &rows, &cols)){
    return -1;
  }
  if(n->absy == n->absy + keepy && n->absx == n->absx + keepx &&
      rows == ylen && cols == xlen){
    return 0;
  }
  notcurses* nc = ncplane_notcurses(n);
  if(n->sprite){
    sprixel_hide(n->sprite);
  }
  // we're good to resize. we'll need alloc up a new framebuffer, and copy in
  // those elements we're retaining, zeroing out the rest. alternatively, if
  // we've shrunk, we will be filling the new structure.
  int oldarea = rows * cols;
  int keptarea = keepleny * keeplenx;
  int newarea = ylen * xlen;
  size_t fbsize = sizeof(nccell) * newarea;
  nccell* fb;
  // there are two cases worth optimizing:
  //
  // * nothing is kept. we malloc() a new cellmatrix, dump the EGCpool in
  //    toto, and zero out the matrix. no copies, one memset.
  // * old and new x dimensions match, and we're keeping the full width.
  //    we release any cells we're about to lose, realloc() the cellmatrix,
  //    and zero out any new cells. so long as the realloc() doesn't move
  //    us, there are no copies, one memset, one iteration (since this is
  //    most often due to autogrowth by a single line, the likelihood that
  //    we remain where we are is pretty high).
  // * otherwise, we malloc() a new cellmatrix, zero out any new cells,
  //    copy over any reused cells, and release any lost cells. one
  //    gigantic iteration.
  // we might realloc instead of mallocing, in which case we NULL out
  // |preserved|. it must otherwise be free()d at the end.
  nccell* preserved = n->fb;
  if(cols == xlen && cols == keeplenx && keepleny && !keepy){
    // we need release the cells that we're losing, lest we leak EGCpool
    // memory. unfortunately, this means we mutate the plane on the error case.
    // any solution would involve copying them out first. we only do this if
    // we're keeping some, as we otherwise drop the EGCpool in toto.
    if(n->leny > keepleny){
      for(unsigned y = keepleny ; y < n->leny ; ++y){
        for(unsigned x = 0 ; x < n->lenx ; ++x){
          nccell_release(n, ncplane_cell_ref_yx(n, y, x));
        }
      }
    }
    if((fb = realloc(n->fb, fbsize)) == NULL){
      return -1;
    }
    preserved = NULL;
  }else{
    if((fb = malloc(fbsize)) == NULL){
      return -1;
    }
  }
  if(n->tam){
    loginfo("tam realloc to %d entries", newarea);
    // FIXME first, free any disposed auxiliary vectors!
    tament* tmptam = realloc(n->tam, sizeof(*tmptam) * newarea);
    if(tmptam == NULL){
      if(preserved){
        free(fb);
      }
      return -1;
    }
    n->tam = tmptam;
    if(newarea > oldarea){
      memset(n->tam + oldarea, 0, sizeof(*n->tam) * (newarea - oldarea));
    }
  }
  // update the cursor, if it would otherwise be off-plane
  if(n->y >= ylen){
    n->y = ylen - 1;
  }
  if(n->x >= xlen){
    n->x = xlen - 1;
  }
  pthread_mutex_lock(&nc->stats.lock);
    ncplane_notcurses(n)->stats.s.fbbytes -= sizeof(*fb) * (rows * cols);
    ncplane_notcurses(n)->stats.s.fbbytes += fbsize;
  pthread_mutex_unlock(&nc->stats.lock);
  const int oldabsy = n->absy;
  // go ahead and move. we can no longer fail at this point. but don't yet
  // resize, because n->len[xy] are used in fbcellidx() in the loop below. we
  // don't use ncplane_move_yx(), because we want to planebinding-invariant.
  n->absy += keepy + yoff;
  n->absx += keepx + xoff;
//fprintf(stderr, "absx: %d keepx: %d xoff: %d\n", n->absx, keepx, xoff);
  if(keptarea == 0){ // keep nothing, resize/move only.
    // if we're keeping nothing, dump the old egcspool. otherwise, we go ahead
    // and keep it. perhaps we ought compact it?
    memset(fb, 0, sizeof(*fb) * newarea);
    egcpool_dump(&n->pool);
  }else if(!preserved){
    // the x dimensions are equal, and we're keeping across the width. only the
    // y dimension changed. if we grew, we need zero out the new cells (if we
    // shrunk, we already released the old cells prior to the realloc).
    unsigned tozorch = (ylen - keepleny) * xlen * sizeof(*fb);
    if(tozorch){
      unsigned zorchoff = keepleny * xlen;
      memset(fb + zorchoff, 0, tozorch);
    }
  }else{
    // we currently have maxy rows of maxx cells each. we will be keeping rows
    // keepy..keepy + keepleny - 1 and columns keepx..keepx + keeplenx - 1.
    // anything else is zerod out. itery is the row we're writing *to*, and we
    // must write to each (and every cell in each).
    for(unsigned itery = 0 ; itery < ylen ; ++itery){
      int truey = itery + n->absy;
      int sourceoffy = truey - oldabsy;
//fprintf(stderr, "sourceoffy: %d keepy: %d ylen: %d\n", sourceoffy, keepy, ylen);
      // if we have nothing copied to this line, zero it out in one go
      if(sourceoffy < keepy || sourceoffy >= keepy + (int)keepleny){
//fprintf(stderr, "writing 0s to line %d of %d\n", itery, ylen);
        memset(fb + (itery * xlen), 0, sizeof(*fb) * xlen);
      }else{
        int copyoff = itery * xlen; // our target at any given time
        // we do have something to copy, and zero, one, or two regions to zero out
        unsigned copied = 0;
        if(xoff < 0){
          memset(fb + copyoff, 0, sizeof(*fb) * -xoff);
          copyoff += -xoff;
          copied += -xoff;
        }
        const int sourceidx = nfbcellidx(n, sourceoffy, keepx);
//fprintf(stderr, "copying line %d (%d) to %d (%d)\n", sourceoffy, sourceidx, copyoff / xlen, copyoff);
        memcpy(fb + copyoff, preserved + sourceidx, sizeof(*fb) * keeplenx);
        copyoff += keeplenx;
        copied += keeplenx;
        unsigned perline = xlen - copied;
        for(unsigned x = copyoff ; x < n->lenx ; ++x){
          nccell_release(n, ncplane_cell_ref_yx(n, sourceoffy, x));
        }
        memset(fb + copyoff, 0, sizeof(*fb) * perline);
      }
    }
  }
  n->fb = fb;
  n->lenx = xlen;
  n->leny = ylen;
  free(preserved);
  return resize_callbacks_children(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_vprintf_prep()

ALLOC char * ncplane_vprintf_prep	(	const char *	format,
		va_list	ap
	)

Definition at line 2093 of file notcurses.c.

                                                          {
  const size_t size = BUFSIZ; // healthy estimate, can embiggen below
  char* buf = malloc(size);
  if(buf == NULL){
    return NULL;
  }
  va_list vacopy;
  va_copy(vacopy, ap);
  int ret = vsnprintf(buf, size, format, ap);
  if(ret < 0){
    free(buf);
    va_end(vacopy);
    return NULL;
  }
  if((size_t)ret >= size){
    char* tmp = realloc(buf, ret + 1);
    if(tmp == NULL){
      free(buf);
      va_end(vacopy);
      return NULL;
    }
    buf = tmp;
    vsprintf(buf, format, vacopy);
  }
  va_end(vacopy);
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncvisual_blit_internal()

int ncvisual_blit_internal	(	const struct ncvisual *	ncv,
		int	rows,
		int	cols,
		ncplane *	n,
		const struct blitset *	bset,
		const blitterargs *	bargs
	)

ncvisual_bounding_box()

int ncvisual_bounding_box	(	const struct ncvisual *	ncv,
		int *	leny,
		int *	lenx,
		int *	offy,
		int *	offx
	)

ncvisual_geom_inner()

int ncvisual_geom_inner	(	const tinfo *	ti,
		const struct ncvisual *	n,
		const struct ncvisual_options *	vopts,
		ncvgeom *	geom,
		const struct blitset **	bset,
		unsigned *	disppxy,
		unsigned *	disppxx,
		unsigned *	outy,
		unsigned *	outx,
		int *	placey,
		int *	placex
	)

Here is the caller graph for this function:

ncvisual_init()

int ncvisual_init

(

int

loglevel

)

Definition at line 23 of file visual.c.

                           {
  if(visual_implementation->visual_init){
    return visual_implementation->visual_init(logl);
  }
  return 0;
}

Here is the caller graph for this function:

ncvisual_printbanner()

void ncvisual_printbanner

(

fbuf *

f

)

Definition at line 30 of file visual.c.

                                  {
  if(visual_implementation->visual_printbanner){
    visual_implementation->visual_printbanner(f);
  }
}

Here is the caller graph for this function:

putenv_term()

int putenv_term

(

const char *

termname

)

Definition at line 1655 of file termdesc.c.

                                  {
  #define ENVVAR "TERM"
  const char* oldterm = getenv(ENVVAR);
  if(oldterm){
    logdebug("replacing %s value %s with %s", ENVVAR, oldterm, tname);
  }else{
    loginfo("provided %s value %s", ENVVAR, tname);
  }
  if(oldterm && strcmp(oldterm, tname) == 0){
    return 0;
  }
  char* buf = malloc(strlen(tname) + strlen(ENVVAR) + 1);
  if(buf == NULL){
    return -1;
  }
  int c = putenv(buf);
  if(c){
    logerror("couldn't export %s", buf);
  }
  free(buf);
  return c;
}

Here is the caller graph for this function:

reset_stats()

void reset_stats

(

ncstats *

stats

)

Definition at line 74 of file stats.c.

                                {
  uint64_t fbbytes = stats->fbbytes;
  unsigned planes = stats->planes;
  memset(stats, 0, sizeof(*stats));
  stats->render_min_ns = 1ull << 62u;
  stats->raster_min_bytes = 1ull << 62u;
  stats->raster_min_ns = 1ull << 62u;
  stats->writeout_min_ns = 1ull << 62u;
  stats->fbbytes = fbbytes;
  stats->planes = planes;
}

Here is the caller graph for this function:

reset_term_attributes()

int reset_term_attributes	(	const tinfo *	ti,
		fbuf *	f
	)

Definition at line 60 of file notcurses.c.

                                                   {
  int ret = 0;
  const char* esc;
  if((esc = get_escape(ti, ESCAPE_OP)) && fbuf_emit(f, esc)){
    ret = -1;
  }
  if((esc = get_escape(ti, ESCAPE_SGR0)) && fbuf_emit(f, esc)){
    ret = -1;
  }
  return ret;
}

Here is the caller graph for this function:

reset_term_palette()

int reset_term_palette	(	const tinfo *	ti,
		fbuf *	f,
		unsigned	touchedpalette
	)

Definition at line 78 of file notcurses.c.

                                                                         {
  int ret = 0;
  const char* esc;
  if((esc = get_escape(ti, ESCAPE_RESTORECOLORS))){
    loginfo("restoring palette via xtpopcolors");
    if(fbuf_emit(f, esc)){
      ret = -1;
    }
    return ret;
  }
  if(!touchedpalette){
    return 0;
  }
  if(ti->caps.can_change_colors && ti->maxpaletteread > -1){
    loginfo("restoring saved palette (%d)", ti->maxpaletteread + 1);
    esc = get_escape(ti, ESCAPE_INITC);
    for(int z = 0 ; z < ti->maxpaletteread ; ++z){
      unsigned r, g, b;
      ncchannel_rgb8(ti->originalpalette.chans[z], &r, &g, &b);
      // Need convert RGB values [0..256) to [0..1000], ugh
      r = r * 1000 / 255;
      g = g * 1000 / 255;
      b = b * 1000 / 255;
      if(fbuf_emit(f, tiparm(esc, z, r, g, b)) < 0){
        return -1;
      }
    }
  }else if((esc = get_escape(ti, ESCAPE_OC))){
    loginfo("resetting palette");
    if(fbuf_emit(f, esc)){
      ret = -1;
    }
  }else{
    logwarn("no method known to restore palette");
  }
  return ret;
}

resize_callbacks_children()

int resize_callbacks_children

(

ncplane *

n

)

Definition at line 804 of file notcurses.c.

                                         {
  int ret = 0;
  for(struct ncplane* child = n->blist ; child ; child = child->bnext){
    if(child->resizecb){
      ret |= child->resizecb(child);
    }
  }
  return ret;
}

Here is the caller graph for this function:

rgb_loose_to_rgba()

ALLOC void * rgb_loose_to_rgba	(	const void *	data,
		int	rows,
		int *	rowstride,
		int	cols,
		int	alpha
	)

Definition at line 461 of file visual.c.

                                                                                        {
  if(*rowstride % 4){ // must be a multiple of 4 bytes
    return NULL;
  }
  if(*rowstride < cols * 4){
    return NULL;
  }
  uint32_t* ret = malloc(4 * cols * rows);
  if(ret){
    for(int y = 0 ; y < rows ; ++y){
      for(int x = 0 ; x < cols ; ++x){
        const uint32_t* src = (const uint32_t*)data + (*rowstride / 4) * y + x;
        uint32_t* dst = ret + cols * y + x;
        *dst = 0; // kill scan-build warning about using uninitialized value below
        ncpixel_set_a(dst, alpha);
        ncpixel_set_r(dst, ncpixel_r(*src));
        ncpixel_set_g(dst, ncpixel_g(*src));
        ncpixel_set_b(dst, ncpixel_b(*src));
      }
    }
  }
  *rowstride = cols * 4;
  return ret;
}

Here is the caller graph for this function:

rgb_packed_to_rgba()

ALLOC void * rgb_packed_to_rgba	(	const void *	data,
		int	rows,
		int *	rowstride,
		int	cols,
		int	alpha
	)

Definition at line 486 of file visual.c.

                                                                                         {
  if(*rowstride < cols * 3){
    return NULL;
  }
  uint32_t* ret = malloc(4 * cols * rows);
  if(ret){
    for(int y = 0 ; y < rows ; ++y){
      for(int x = 0 ; x < cols ; ++x){
        const unsigned char* src = (const unsigned char*)data + *rowstride * y + x;
        uint32_t* dst = ret + cols * y + x;
        *dst = 0; // kill scan-build warning about using uninitialized value below
        ncpixel_set_a(dst, alpha);
        ncpixel_set_r(dst, src[0]);
        ncpixel_set_g(dst, src[1]);
        ncpixel_set_b(dst, src[2]);
      }
    }
  }
  *rowstride = cols * 4;
  return ret;
}

Here is the caller graph for this function:

scroll_down()

void scroll_down

(

ncplane *

n

)

Definition at line 1761 of file notcurses.c.

                            {
//fprintf(stderr, "pre-scroll: %d/%d %d/%d log: %d scrolling: %u\n", n->y, n->x, n->leny, n->lenx, n->logrow, n->scrolling);
  n->x = 0;
  if(n->y == n->leny - 1){
    // we're on the last line of the plane
    if(n->autogrow){
      ncplane_resize_simple(n, n->leny + 1, n->lenx);
      ncplane_cursor_move_yx(n, n->leny - 1, 0);
      return;
    }
    // we'll actually be scrolling material up and out, and making a new line.
    // if this is the standard plane, that means a "physical" scroll event is
    // called for.
    if(n == notcurses_stdplane(ncplane_notcurses(n))){
      ncplane_pile(n)->scrolls++;
    }
    n->logrow = (n->logrow + 1) % n->leny;
    nccell* row = n->fb + nfbcellidx(n, n->y, 0);
    for(unsigned clearx = 0 ; clearx < n->lenx ; ++clearx){
      nccell_release(n, &row[clearx]);
    }
    memset(row, 0, sizeof(*row) * n->lenx);
    for(struct ncplane* c = n->blist ; c ; c = c->bnext){
      if(!c->fixedbound){
        if(ncplanes_intersect_p(n, c)){
          ncplane_move_rel(c, -1, 0);
        }
      }
    }
  }else{
    ++n->y;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_fd_nonblocking()

int set_fd_nonblocking	(	int	fd,
		unsigned	state,
		unsigned *	oldstate
	)

Here is the caller graph for this function:

set_loglevel_from_env()

int set_loglevel_from_env

(

ncloglevel_e *

loglevel

)

Definition at line 19 of file util.c.

                                              {
  const char* ll = getenv("NOTCURSES_LOGLEVEL");
  if(ll == NULL){
    return 0;
  }
  char* endl;
  long l = strtol(ll, &endl, 10);
  if(l < NCLOGLEVEL_PANIC || l > NCLOGLEVEL_TRACE){
    logpanic("illegal NOTCURSES_LOGLEVEL: %s", ll);
    return -1;
  }
  *llptr = l;
  loginfo("got loglevel from environment: %ld", l);
  return 0;
}

Here is the caller graph for this function:

sigwinch_handler()

void sigwinch_handler

(

int

signo

)

Definition at line 31 of file in.c.

                                {
  if(signo == SIGWINCH){
    resize_seen = signo;
    sigcont_seen_for_render = 1;
  }else if(signo == SIGCONT){
    cont_seen = signo;
    sigcont_seen_for_render = 1;
  }
}

Here is the caller graph for this function:

sixelmap_free()

void sixelmap_free

(

struct sixelmap *

s

)

Definition at line 216 of file sixel.c.

                               {
  if(s){
    for(int i = 0 ; i < s->sixelbands ; ++i){
      sixelband_free(&s->bands[i]);
    }
    free(s->bands);
    free(s);
  }
}

Here is the caller graph for this function:

sprite_clear_all()

int sprite_clear_all	(	const tinfo *	t,
		fbuf *	f
	)

Definition at line 204 of file sprite.c.

                                             {
  if(t->pixel_clear_all == NULL){
    return 0;
  }
  return t->pixel_clear_all(f);
}

Here is the caller graph for this function:

sprite_wipe()

int sprite_wipe	(	const notcurses *	nc,
		sprixel *	s,
		int	y,
		int	x
	)

Definition at line 170 of file sprite.c.

                                                                      {
  assert(s->n);
  int idx = s->dimx * ycell + xcell;
  if(s->n->tam[idx].state == SPRIXCELL_TRANSPARENT){
    // need to make a transparent auxvec, because a reload will force us to
    // update said auxvec, but needn't actually change the glyph. auxvec will
    // be entirely 0s coming from pixel_trans_auxvec().
    if(s->n->tam[idx].auxvector == NULL){
      if(nc->tcache.pixel_trans_auxvec){
        s->n->tam[idx].auxvector = nc->tcache.pixel_trans_auxvec(ncplane_pile(s->n));
        if(s->n->tam[idx].auxvector == NULL){
          return -1;
        }
      }
    }
    // no need to update to INVALIDATED; no redraw is necessary
    s->n->tam[idx].state = SPRIXCELL_ANNIHILATED_TRANS;
    return 1;
  }
  if(s->n->tam[idx].state == SPRIXCELL_ANNIHILATED_TRANS ||
     s->n->tam[idx].state == SPRIXCELL_ANNIHILATED){
//fprintf(stderr, "CACHED WIPE %d %d/%d\n", s->id, ycell, xcell);
    return 0;
  }
  logdebug("wiping %p %d %d/%d", s->n->tam, idx, ycell, xcell);
  int r = nc->tcache.pixel_wipe(s, ycell, xcell);
//fprintf(stderr, "WIPED %d %d/%d ret=%d\n", s->id, ycell, xcell, r);
  // mark the cell as annihilated whether we actually scrubbed it or not,
  // so that we use this fact should we move to another frame
  s->n->tam[idx].state = SPRIXCELL_ANNIHILATED;
  assert(s->n->tam[idx].auxvector);
  return r;
}

Here is the call graph for this function:

sprixel_alloc()

sprixel * sprixel_alloc	(	ncplane *	n,
		int	dimy,
		int	dimx
	)

Definition at line 117 of file sprite.c.

                                                      {
  sprixel* ret = malloc(sizeof(sprixel));
  if(ret == NULL){
    return NULL;
  }
  memset(ret, 0, sizeof(*ret));
  if(fbuf_init(&ret->glyph)){
    free(ret);
    return NULL;
  }
  ret->n = n;
  ret->dimy = dimy;
  ret->dimx = dimx;
  ret->id = ++sprixelid_nonce;
  ret->needs_refresh = NULL;
  if(ret->id >= 0x1000000){
    ret->id = 1;
    sprixelid_nonce = 1;
  }
//fprintf(stderr, "LOOKING AT %p (p->n = %p)\n", ret, ret->n);
  if(ncplane_pile(ret->n)){ // rendered mode
    ncpile* np = ncplane_pile(ret->n);
    if( (ret->next = np->sprixelcache) ){
      ret->next->prev = ret;
    }
    np->sprixelcache = ret;
    ret->prev = NULL;
//fprintf(stderr, "%p %p %p\n", nc->sprixelcache, ret, nc->sprixelcache->next);
  }else{ // ncdirect case
    ret->next = ret->prev = NULL;
  }
  return ret;
}

Here is the caller graph for this function:

sprixel_debug()

void sprixel_debug	(	const sprixel *	s,
		FILE *	out
	)

Definition at line 7 of file sprite.c.

                                               {
  fprintf(out, "sprixel %d (%p) %" PRIu64 "B %dx%d (%dx%d) @%d/%d state: %d\n",
          s->id, s, s->glyph.used, s->dimy, s->dimx, s->pixy, s->pixx,
          s->n ? s->n->absy : 0, s->n ? s->n->absx : 0,
          s->invalidated);
  if(s->n){
    int idx = 0;
    for(unsigned y = 0 ; y < s->dimy ; ++y){
      for(unsigned x = 0 ; x < s->dimx ; ++x){
        fprintf(out, "%d", s->n->tam[idx].state);
        ++idx;
      }
      fprintf(out, "\n");
    }
    idx = 0;
    for(unsigned y = 0 ; y < s->dimy ; ++y){
      for(unsigned x = 0 ; x < s->dimx ; ++x){
        if(s->n->tam[idx].state == SPRIXCELL_ANNIHILATED){
          if(s->n->tam[idx].auxvector){
            fprintf(out, "%03d] %p\n", idx, s->n->tam[idx].auxvector);
          }else{
            fprintf(out, "%03d] missing!\n", idx);
          }
        }
        ++idx;
      }
    }
  }
}

sprixel_free()

void sprixel_free

(

sprixel *

s

)

Definition at line 38 of file sprite.c.

                             {
  if(s){
    loginfo("destroying sprixel %u", s->id);
    if(s->n){
      s->n->sprite = NULL;
    }
    sixelmap_free(s->smap);
    free(s->needs_refresh);
    fbuf_free(&s->glyph);
    free(s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sprixel_hide()

void sprixel_hide

(

sprixel *

s

)

Definition at line 83 of file sprite.c.

                             {
  if(ncplane_pile(s->n) == NULL){ // ncdirect case; destroy now
    sprixel_free(s);
    return;
  }
  // otherwise, it'll be killed in the next rendering cycle.
  if(s->invalidated != SPRIXEL_HIDE){
    loginfo("marking sprixel %u hidden", s->id);
    s->invalidated = SPRIXEL_HIDE;
    s->movedfromy = ncplane_abs_y(s->n);
    s->movedfromx = ncplane_abs_x(s->n);
    // guard; might have already been replaced
    if(s->n){
      s->n->sprite = NULL;
      s->n = NULL;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sprixel_invalidate()

void sprixel_invalidate	(	sprixel *	s,
		int	y,
		int	x
	)

Definition at line 103 of file sprite.c.

                                                 {
//fprintf(stderr, "INVALIDATING AT %d/%d\n", y, x);
  if(s->invalidated == SPRIXEL_QUIESCENT && s->n){
    int localy = y - s->n->absy;
    int localx = x - s->n->absx;
//fprintf(stderr, "INVALIDATING AT %d/%d (%d/%d) TAM: %d\n", y, x, localy, localx, s->n->tam[localy * s->dimx + localx].state);
    if(s->n->tam[localy * s->dimx + localx].state != SPRIXCELL_TRANSPARENT &&
       s->n->tam[localy * s->dimx + localx].state != SPRIXCELL_ANNIHILATED &&
       s->n->tam[localy * s->dimx + localx].state != SPRIXCELL_ANNIHILATED_TRANS){
      s->invalidated = SPRIXEL_INVALIDATED;
    }
  }
}

Here is the caller graph for this function:

sprixel_movefrom()

void sprixel_movefrom	(	sprixel *	s,
		int	y,
		int	x
	)

Definition at line 68 of file sprite.c.

                                               {
  if(s->invalidated != SPRIXEL_HIDE && s->invalidated != SPRIXEL_UNSEEN){
    if(s->invalidated != SPRIXEL_MOVED){
    // FIXME if we're Sixel, we need to effect any wipes that were run
    // (we normally don't because redisplaying sixel doesn't change
    // what's there--you can't "write transparency"). this is probably
    // best done by conditionally reblitting the sixel(?).
//fprintf(stderr, "SETTING TO MOVE: %d/%d was: %d\n", y, x, s->invalidated);
      s->invalidated = SPRIXEL_MOVED;
      s->movedfromy = y;
      s->movedfromx = x;
    }
  }
}

Here is the caller graph for this function:

sprixel_recycle()

sprixel * sprixel_recycle

(

ncplane *

n

)

Definition at line 51 of file sprite.c.

                                    {
  assert(n->sprite);
  const notcurses* nc = ncplane_notcurses_const(n);
  if(nc->tcache.pixel_implementation >= NCPIXEL_KITTY_STATIC){
    sprixel* hides = n->sprite;
    int dimy = hides->dimy;
    int dimx = hides->dimx;
    sprixel_hide(hides);
    return sprixel_alloc(n, dimy, dimx);
  }
  sixelmap_free(n->sprite->smap);
  n->sprite->smap = NULL;
  return n->sprite;
}

Here is the call graph for this function:

Here is the caller graph for this function:

summarize_stats()

void summarize_stats

(

notcurses *

nc

)

Definition at line 166 of file stats.c.

                                   {
  const ncstats *stats = &nc->stashed_stats;
  char totalbuf[NCBPREFIXSTRLEN + 1];
  char minbuf[NCBPREFIXSTRLEN + 1];
  char maxbuf[NCBPREFIXSTRLEN + 1];
  char avgbuf[NCBPREFIXSTRLEN + 1];
  if(stats->renders){
    ncqprefix(stats->render_ns, NANOSECS_IN_SEC, totalbuf, 0);
    ncqprefix(stats->render_min_ns, NANOSECS_IN_SEC, minbuf, 0);
    ncqprefix(stats->render_max_ns, NANOSECS_IN_SEC, maxbuf, 0);
    ncqprefix(stats->render_ns / stats->renders, NANOSECS_IN_SEC, avgbuf, 0);
    fprintf(stderr, "%"PRIu64" render%s, %ss (%ss min, %ss avg, %ss max)" NL,
            stats->renders, stats->renders == 1 ? "" : "s",
            totalbuf, minbuf, avgbuf, maxbuf);
  }
  if(stats->writeouts || stats->failed_writeouts){
    ncqprefix(stats->raster_ns, NANOSECS_IN_SEC, totalbuf, 0);
    ncqprefix(stats->raster_min_ns, NANOSECS_IN_SEC, minbuf, 0);
    ncqprefix(stats->raster_max_ns, NANOSECS_IN_SEC, maxbuf, 0);
    ncqprefix(stats->raster_ns / (stats->writeouts + stats->failed_writeouts),
            NANOSECS_IN_SEC, avgbuf, 0);
    fprintf(stderr, "%"PRIu64" raster%s, %ss (%ss min, %ss avg, %ss max)" NL,
            stats->writeouts, stats->writeouts == 1 ? "" : "s",
            totalbuf, minbuf, avgbuf, maxbuf);
    ncqprefix(stats->writeout_ns, NANOSECS_IN_SEC, totalbuf, 0);
    ncqprefix(stats->writeout_ns ? stats->writeout_min_ns : 0,
            NANOSECS_IN_SEC, minbuf, 0);
    ncqprefix(stats->writeout_max_ns, NANOSECS_IN_SEC, maxbuf, 0);
    ncqprefix(stats->writeouts ? stats->writeout_ns / stats->writeouts : 0,
            NANOSECS_IN_SEC, avgbuf, 0);
    fprintf(stderr, "%"PRIu64" write%s, %ss (%ss min, %ss avg, %ss max)" NL,
            stats->writeouts, stats->writeouts == 1 ? "" : "s",
            totalbuf, minbuf, avgbuf, maxbuf);
  }
  if(stats->renders || stats->input_events){
    ncbprefix(stats->raster_bytes, 1, totalbuf, 1),
    ncbprefix(stats->raster_bytes ? stats->raster_min_bytes : 0,
              1, minbuf, 1),
    ncbprefix(stats->renders ? stats->raster_bytes / stats->renders : 0, 1, avgbuf, 1);
    ncbprefix(stats->raster_max_bytes, 1, maxbuf, 1),
    fprintf(stderr, "%sB (%sB min, %sB avg, %sB max) %"PRIu64" input%s Ghpa: %"PRIu64 NL,
            totalbuf, minbuf, avgbuf, maxbuf,
            stats->input_events,
            stats->input_events == 1 ? "" : "s",
            stats->hpa_gratuitous);
  }
  fprintf(stderr, "%"PRIu64" failed render%s, %"PRIu64" failed raster%s, %"
                  PRIu64" refresh%s, %"PRIu64" input error%s" NL,
          stats->failed_renders, stats->failed_renders == 1 ? "" : "s",
          stats->failed_writeouts, stats->failed_writeouts == 1 ? "" : "s",
          stats->refreshes, stats->refreshes == 1 ? "" : "es",
          stats->input_errors, stats->input_errors == 1 ? "" : "s");
  fprintf(stderr, "RGB emits:elides: def %"PRIu64":%"PRIu64" fg %"PRIu64":%"
                  PRIu64" bg %"PRIu64":%"PRIu64 NL,
          stats->defaultemissions,
          stats->defaultelisions,
          stats->fgemissions,
          stats->fgelisions,
          stats->bgemissions,
          stats->bgelisions);
  fprintf(stderr, "Cell emits:elides: %"PRIu64":%"PRIu64" (%.2f%%) %.2f%% %.2f%% %.2f%%" NL,
          stats->cellemissions, stats->cellelisions,
          (stats->cellemissions + stats->cellelisions) == 0 ? 0 :
          (stats->cellelisions * 100.0) / (stats->cellemissions + stats->cellelisions),
          (stats->defaultemissions + stats->defaultelisions) == 0 ? 0 :
          (stats->defaultelisions * 100.0) / (stats->defaultemissions + stats->defaultelisions),
          (stats->fgemissions + stats->fgelisions) == 0 ? 0 :
          (stats->fgelisions * 100.0) / (stats->fgemissions + stats->fgelisions),
          (stats->bgemissions + stats->bgelisions) == 0 ? 0 :
          (stats->bgelisions * 100.0) / (stats->bgemissions + stats->bgelisions));
  ncbprefix(stats->sprixelbytes, 1, totalbuf, 1);
  fprintf(stderr, "Bmap emits:elides: %"PRIu64":%"PRIu64" (%.2f%%) %sB (%.2f%%) SuM: %"PRIu64" (%.2f%%)" NL,
          stats->sprixelemissions, stats->sprixelelisions,
          (stats->sprixelemissions + stats->sprixelelisions) == 0 ? 0 :
          (stats->sprixelelisions * 100.0) / (stats->sprixelemissions + stats->sprixelelisions),
          totalbuf,
          stats->raster_bytes ? (stats->sprixelbytes * 100.0) / stats->raster_bytes : 0,
          stats->appsync_updates,
          stats->writeouts ? stats->appsync_updates * 100.0 / stats->writeouts : 0);
  if(stats->cell_geo_changes || stats->pixel_geo_changes){
    fprintf(stderr,"Screen/cell geometry changes: %"PRIu64"/%"PRIu64 NL,
            stats->cell_geo_changes, stats->pixel_geo_changes);
  }
}

Here is the caller graph for this function:

term_fg_rgb8()

int term_fg_rgb8	(	const tinfo *	ti,
		fbuf *	f,
		unsigned	r,
		unsigned	g,
		unsigned	b
	)

Definition at line 743 of file render.c.

                                                                              {
  // We typically want to use tputs() and tiperm() to acquire and write the
  // escapes, as these take into account terminal-specific delays, padding,
  // etc. For the case of DirectColor, there is no suitable terminfo entry, but
  // we're also in that case working with hopefully more robust terminals.
  // If it doesn't work, eh, it doesn't work. Fuck the world; save yourself.
  if(ti->caps.rgb){
    return term_esc_rgb(f, true, r, g, b);
  }else{
    const char* setaf = get_escape(ti, ESCAPE_SETAF);
    if(setaf){
      // For 256-color indexed mode, start constructing a palette based off
      // the inputs *if we can change the palette*. If more than 256 are used on
      // a single screen, start... combining close ones? For 8-color mode, simple
      // interpolation. I have no idea what to do for 88 colors. FIXME
      if(ti->caps.colors >= 256){
        return fbuf_emit(f, tiparm(setaf, rgb_quantize_256(r, g, b)));
      }else if(ti->caps.colors >= 8){
        return fbuf_emit(f, tiparm(setaf, rgb_quantize_8(r, g, b)));
      }
    }
  }
  return 0;
}

Here is the caller graph for this function:

update_raster_bytes()

void update_raster_bytes	(	ncstats *	stats,
		int	bytes
	)

Definition at line 27 of file stats.c.

                                                   {
  if(bytes >= 0){
    stats->raster_bytes += bytes;
    if(bytes > stats->raster_max_bytes){
      stats->raster_max_bytes = bytes;
    }
    if(bytes < stats->raster_min_bytes){
      stats->raster_min_bytes = bytes;
    }
  }
}

Here is the caller graph for this function:

update_raster_stats()

void update_raster_stats	(	const struct timespec *	time1,
		const struct timespec *	time0,
		ncstats *	stats
	)

Definition at line 58 of file stats.c.

                                        {
  const int64_t elapsed = timespec_to_ns(time1) - timespec_to_ns(time0);
  //fprintf(stderr, "Rasterizing took %ld.%03lds\n", elapsed / NANOSECS_IN_SEC,
  //        (elapsed % NANOSECS_IN_SEC) / 1000000);
  if(elapsed > 0){ // don't count clearly incorrect information, egads
    stats->raster_ns += elapsed;
    if(elapsed > stats->raster_max_ns){
      stats->raster_max_ns = elapsed;
    }
    if(elapsed < stats->raster_min_ns){
      stats->raster_min_ns = elapsed;
    }
  }
}

Here is the caller graph for this function:

update_render_stats()

void update_render_stats	(	const struct timespec *	time1,
		const struct timespec *	time0,
		ncstats *	stats
	)

Definition at line 40 of file stats.c.

                                        {
  const int64_t elapsed = timespec_to_ns(time1) - timespec_to_ns(time0);
  //fprintf(stderr, "Rendering took %ld.%03lds\n", elapsed / NANOSECS_IN_SEC,
  //        (elapsed % NANOSECS_IN_SEC) / 1000000);
  if(elapsed > 0){ // don't count clearly incorrect information, egads
    ++stats->renders;
    stats->render_ns += elapsed;
    if(elapsed > stats->render_max_ns){
      stats->render_max_ns = elapsed;
    }
    if(elapsed < stats->render_min_ns){
      stats->render_min_ns = elapsed;
    }
  }
}

Here is the caller graph for this function:

update_term_dimensions()

int update_term_dimensions	(	unsigned *	rows,
		unsigned *	cols,
		tinfo *	tcache,
		int	margin_b,
		unsigned *	cgeo_changed,
		unsigned *	pgeo_changed
	)

Here is the caller graph for this function:

update_write_stats()

void update_write_stats	(	const struct timespec *	time1,
		const struct timespec *	time0,
		ncstats *	stats,
		int	bytes
	)

Definition at line 5 of file stats.c.

                                                  {
  if(bytes >= 0){
    const int64_t elapsed = timespec_to_ns(time1) - timespec_to_ns(time0);
    if(elapsed > 0){ // don't count clearly incorrect information, egads
      ++stats->writeouts;
      stats->writeout_ns += elapsed;
      if(elapsed > stats->writeout_max_ns){
        stats->writeout_max_ns = elapsed;
      }
      if(elapsed < stats->writeout_min_ns){
        stats->writeout_min_ns = elapsed;
      }
    }
  }else{
    ++stats->failed_writeouts;
  }
}

Here is the caller graph for this function:

warn_terminfo()

void warn_terminfo	(	const notcurses *	nc,
		const tinfo *	ti
	)

Variable Documentation

visual_implementation

API ncvisual_implementation* visual_implementation

extern

Definition at line 20 of file visual.c.