render.c File Reference

#include <ctype.h>
#include <limits.h>
#include <unistd.h>
#include "internal.h"
#include "unixsig.h"

Include dependency graph for render.c:

Go to the source code of this file.

Macros
#define	RGBESC1   "\x1b" "["
#define	RGBESC2   "8;2;"
#define	MIN_SUMODE_SIZE   BUFSIZ

Functions
void	nccell_release (ncplane *n, nccell *c)
int	nccell_duplicate (ncplane *n, nccell *targ, const nccell *c)
	__attribute__ ((nonnull(1, 2, 7)))
int	ncplane_mergedown (ncplane *restrict src, ncplane *restrict dst, int begsrcy, int begsrcx, unsigned leny, unsigned lenx, int dsty, int dstx)
int	ncplane_mergedown_simple (ncplane *restrict src, ncplane *restrict dst)
int	term_fg_rgb8 (const tinfo *ti, fbuf *f, unsigned r, unsigned g, unsigned b)
int	clear_and_home (notcurses *nc, tinfo *ti, fbuf *f)
int	notcurses_refresh (notcurses *nc, unsigned *restrict dimy, unsigned *restrict dimx)
int	ncpile_render_to_file (ncplane *n, FILE *fp)
int	ncpile_rasterize (ncplane *n)
int	ncpile_render (ncplane *n)
int	ncpile_render_to_buffer (ncplane *p, char **buf, size_t *buflen)
char *	notcurses_at_yx (notcurses *nc, unsigned yoff, unsigned xoff, uint16_t *stylemask, uint64_t *channels)
int	ncdirect_set_bg_rgb_f (ncdirect *nc, unsigned rgb, fbuf *f)
int	ncdirect_set_bg_rgb (ncdirect *nc, unsigned rgb)
int	ncdirect_set_fg_rgb_f (ncdirect *nc, unsigned rgb, fbuf *f)
int	ncdirect_set_fg_rgb (ncdirect *nc, unsigned rgb)
int	notcurses_default_foreground (const struct notcurses *nc, uint32_t *fg)
int	notcurses_default_background (const struct notcurses *nc, uint32_t *bg)
int	notcurses_cursor_yx (const notcurses *nc, int *y, int *x)
int	notcurses_cursor_enable (notcurses *nc, int y, int x)
int	notcurses_cursor_disable (notcurses *nc)

Variables
sig_atomic_t	sigcont_seen_for_render = 0

Macro Definition Documentation

MIN_SUMODE_SIZE

#define MIN_SUMODE_SIZE   BUFSIZ

RGBESC1

#define RGBESC1   "\x1b" "["

RGBESC2

#define RGBESC2   "8;2;"

Function Documentation

__attribute__()

__attribute__

(

(nonnull(1, 2, 7))

)

Definition at line 235 of file render.c.

                            {
  unsigned y, x, dimy, dimx;
  int offy, offx;
  ncplane_dim_yx(p, &dimy, &dimx);
  offy = p->absy - dstabsy;
  offx = p->absx - dstabsx;
//fprintf(stderr, "PLANE %p %d %d %d %d %d %d %p\n", p, dimy, dimx, offy, offx, dstleny, dstlenx, p->sprite);
  // skip content above or to the left of the physical screen
  unsigned starty, startx;
  if(offy < 0){
    starty = -offy;
  }else{
    starty = 0;
  }
  if(offx < 0){
    startx = -offx;
  }else{
    startx = 0;
  }
  // if we're a sprixel, we must not register ourselves as the active
  // glyph, but we *do* need to null out any cellregions that we've
  // scribbled upon.
  if(p->sprite){
    if(pgeo_changed){
      // do what on failure? FIXME
      sprixel_rescale(p->sprite, ncplane_pile(p)->cellpxy, ncplane_pile(p)->cellpxx);
    }
    paint_sprixel(p, rvec, starty, startx, offy, offx, dstleny, dstlenx);
    // decouple from the pile's sixel list
    if(p->sprite->next){
      p->sprite->next->prev = p->sprite->prev;
    }
    if(p->sprite->prev){
      p->sprite->prev->next = p->sprite->next;
    }else{
      ncplane_pile(p)->sprixelcache = p->sprite->next;
    }
    // stick on the head of the running list: top sprixel is at end
    if(*sprixelstack){
      (*sprixelstack)->prev = p->sprite;
    }
    p->sprite->next = *sprixelstack;
    p->sprite->prev = NULL;
    *sprixelstack = p->sprite;
    return;
  }
  for(y = starty ; y < dimy ; ++y){
    const int absy = y + offy;
    // once we've passed the physical screen's bottom, we're done
    if(absy >= dstleny || absy < 0){
      break;
    }
    for(x = startx ; x < dimx ; ++x){ // iteration for each cell
      const int absx = x + offx;
      if(absx >= dstlenx || absx < 0){
        break;
      }
      struct crender* crender = &rvec[fbcellidx(absy, dstlenx, absx)];
//fprintf(stderr, "p: %p damaged: %u %d/%d\n", p, crender->s.damaged, y, x);
      nccell* targc = &crender->c;
      if(nccell_wide_right_p(targc)){
        continue;
      }
 
      if(nccell_fg_alpha(targc) > NCALPHA_OPAQUE){
        const nccell* vis = &p->fb[nfbcellidx(p, y, x)];
        if(nccell_fg_default_p(vis)){
          vis = &p->basecell;
        }
        if(nccell_fg_alpha(vis) == NCALPHA_HIGHCONTRAST){
          crender->s.highcontrast = true;
          crender->s.hcfgblends = crender->s.fgblends;
          crender->hcfg = cell_fchannel(targc);
        }
        unsigned fgblends = crender->s.fgblends;
        cell_blend_fchannel(ncplane_notcurses(p), targc, cell_fchannel(vis), &fgblends);
        crender->s.fgblends = fgblends;
        // crender->highcontrast can only be true if we just set it, since we're
        // about to set targc opaque based on crender->highcontrast (and this
        // entire stanza is conditional on targc not being NCALPHA_OPAQUE).
        if(crender->s.highcontrast){
          nccell_set_fg_alpha(targc, NCALPHA_OPAQUE);
        }
      }
 
      // Background color takes effect independently of whether we have a
      // glyph. If we've already locked in the background, it has no effect.
      // If it's transparent, it has no effect. Otherwise, update the
      // background channel and balpha.
      // Evaluate the background first, in case we have HIGHCONTRAST fg text.
      if(nccell_bg_alpha(targc) > NCALPHA_OPAQUE){
        const nccell* vis = &p->fb[nfbcellidx(p, y, x)];
        // to be on the blitter stacking path, we need
        //  1) crender->s.blittedquads to be non-zero (we're below semigraphics)
        //  2) cell_blittedquadrants(vis) to be non-zero (we're semigraphics)
        //  3) somewhere crender is 0, blittedquads is 1 (we're visible)
        if(!crender->s.blittedquads || !((~crender->s.blittedquads) & cell_blittedquadrants(vis))){
          if(nccell_bg_default_p(vis)){
            vis = &p->basecell;
          }
          unsigned bgblends = crender->s.bgblends;
          cell_blend_bchannel(ncplane_notcurses(p), targc, cell_bchannel(vis), &bgblends);
          crender->s.bgblends = bgblends;
        }else{ // use the local foreground; we're stacking blittings
          if(nccell_fg_default_p(vis)){
            vis = &p->basecell;
          }
          unsigned bgblends = crender->s.bgblends;
          cell_blend_bchannel(ncplane_notcurses(p), targc, cell_fchannel(vis), &bgblends);
          crender->s.bgblends = bgblends;
          crender->s.blittedquads = 0;
        }
      }
 
      // if we never loaded any content into the cell (or obliterated it by
      // writing in a zero), use the plane's base cell.
      // if we have no character in this cell, we continue to look for a
      // character, but our foreground color will still be used unless it's
      // been set to transparent. if that foreground color is transparent, we
      // still use a character we find here, but its color will come entirely
      // from cells underneath us.
      if(!crender->p){
        const nccell* vis = &p->fb[nfbcellidx(p, y, x)];
        if(vis->gcluster == 0 && !nccell_double_wide_p(vis)){
          vis = &p->basecell;
        }
        // if the following is true, we're a real glyph, and not the right-hand
        // side of a wide glyph (nor the null codepoint).
        if( (targc->gcluster = vis->gcluster) ){ // index copy only
          if(crender->sprixel && crender->sprixel->invalidated == SPRIXEL_HIDE){
//fprintf(stderr, "damaged due to hide %d/%d\n", y, x);
            crender->s.damaged = 1;
          }
          crender->s.blittedquads = cell_blittedquadrants(vis);
          // we can't plop down a wide glyph if the next cell is beyond the
          // screen, nor if we're bisected by a higher plane.
          if(nccell_double_wide_p(vis)){
            // are we on the last column of the real screen? if so, 0x20 us
            if(absx >= dstlenx - 1){
              targc->gcluster = htole(' ');
              targc->width = 1;
            // is the next cell occupied? if so, 0x20 us
            }else if(crender[1].c.gcluster){
//fprintf(stderr, "NULLING out %d/%d (%d/%d) due to %u\n", y, x, absy, absx, crender[1].c.gcluster);
              targc->gcluster = htole(' ');
              targc->width = 1;
            }else{
              targc->stylemask = vis->stylemask;
              targc->width = vis->width;
            }
          }else{
            targc->stylemask = vis->stylemask;
            targc->width = vis->width;
          }
          crender->p = p;
        }else if(nccell_wide_right_p(vis)){
          crender->p = p;
          targc->width = 0;
        }
      }
    }
  }
}

Here is the call graph for this function:

clear_and_home()

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

Definition at line 1401 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:

nccell_duplicate()

int nccell_duplicate	(	ncplane *	n,
		nccell *	targ,
		const nccell *	c
	)

Definition at line 133 of file render.c.

                                                               {
  if(cell_duplicate_far(&n->pool, targ, n, c) < 0){
    logerror("failed duplicating cell");
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

nccell_release()

void nccell_release	(	ncplane *	n,
		nccell *	c
	)

Definition at line 128 of file render.c.

                                          {
  pool_release(&n->pool, c);
}

Here is the caller graph for this function:

ncdirect_set_bg_rgb()

int ncdirect_set_bg_rgb	(	ncdirect *	nc,
		unsigned	rgb
	)

Definition at line 1669 of file render.c.

                                                   {
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  if(ncdirect_set_bg_rgb_f(nc, rgb, &f)){
    fbuf_free(&f);
    return -1;
  }
  if(fbuf_finalize(&f, nc->ttyfp) < 0){
    return -1;
  }
  return 0;
}

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 1654 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()

int ncdirect_set_fg_rgb	(	ncdirect *	nc,
		unsigned	rgb
	)

Definition at line 1699 of file render.c.

                                                   {
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  if(ncdirect_set_fg_rgb_f(nc, rgb, &f)){
    fbuf_free(&f);
    return -1;
  }
  if(fbuf_finalize(&f, nc->ttyfp) < 0){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

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 1684 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:

ncpile_rasterize()

int ncpile_rasterize

(

ncplane *

n

)

Definition at line 1519 of file render.c.

                                {
  struct timespec start, rasterdone, writedone;
  clock_gettime(CLOCK_MONOTONIC, &start);
  ncpile* pile = ncplane_pile(n);
  struct notcurses* nc = ncpile_notcurses(pile);
  const struct tinfo* ti = &ncplane_notcurses_const(n)->tcache;
  postpaint(nc, ti, nc->lastframe, pile->dimy, pile->dimx, pile->crender, &nc->pool);
  clock_gettime(CLOCK_MONOTONIC, &rasterdone);
  int bytes = notcurses_rasterize(nc, pile, &nc->rstate.f);
  clock_gettime(CLOCK_MONOTONIC, &writedone);
  pthread_mutex_lock(&nc->stats.lock);
    // accepts negative |bytes| as an indication of failure
    update_raster_bytes(&nc->stats.s, bytes);
    update_raster_stats(&rasterdone, &start, &nc->stats.s);
    update_write_stats(&writedone, &rasterdone, &nc->stats.s, bytes);
  pthread_mutex_unlock(&nc->stats.lock);
  // we want to refresh if the screen geometry changed (or if we were just
  // woken up from SIGSTOP), but we mustn't do so until after rasterizing
  // the solved rvec, since this might result in a geometry update.
  if(sigcont_seen_for_render){
    sigcont_seen_for_render = 0;
    notcurses_refresh(ncplane_notcurses(n), NULL, NULL);
  }
  if(bytes < 0){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncpile_render()

int ncpile_render

(

ncplane *

n

)

Definition at line 1571 of file render.c.

                             {
  scroll_lastframe(ncplane_notcurses(n), ncplane_pile(n)->scrolls);
  struct timespec start, renderdone;
  clock_gettime(CLOCK_MONOTONIC, &start);
  notcurses* nc = ncplane_notcurses(n);
  ncpile* pile = ncplane_pile(n);
  // update our notion of screen geometry, and render against that
  unsigned pgeo_changed = 0;
  notcurses_resize_internal(n, NULL, NULL);
  if(pile->cellpxy != nc->tcache.cellpxy || pile->cellpxx != nc->tcache.cellpxx){
    pile->cellpxy = nc->tcache.cellpxy;
    pile->cellpxx = nc->tcache.cellpxx;
    pgeo_changed = 1;
  }
  if(engorge_crender_vector(pile)){
    return -1;
  }
  ncpile_render_internal(pile, pgeo_changed);
  clock_gettime(CLOCK_MONOTONIC, &renderdone);
  pthread_mutex_lock(&nc->stats.lock);
    update_render_stats(&renderdone, &start, &nc->stats.s);
  pthread_mutex_unlock(&nc->stats.lock);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncpile_render_to_buffer()

int ncpile_render_to_buffer	(	ncplane *	p,
		char **	buf,
		size_t *	buflen
	)

Definition at line 1597 of file render.c.

                                                                   {
  if(ncpile_render(p)){
    return -1;
  }
  notcurses* nc = ncplane_notcurses(p);
  unsigned useasu = false; // no SUM with file
  fbuf_reset(&nc->rstate.f);
  int bytes = notcurses_rasterize_inner(nc, ncplane_pile(p), &nc->rstate.f, &useasu);
  pthread_mutex_lock(&nc->stats.lock);
    update_raster_bytes(&nc->stats.s, bytes);
  pthread_mutex_unlock(&nc->stats.lock);
  if(bytes < 0){
    return -1;
  }
  *buf = nc->rstate.f.buf;
  *buflen = nc->rstate.f.used;
  fbuf_reset(&nc->rstate.f);
  return 0;
}

Here is the call graph for this function:

ncpile_render_to_file()

int ncpile_render_to_file	(	ncplane *	n,
		FILE *	fp
	)

Definition at line 1454 of file render.c.

                                               {
  notcurses* nc = ncplane_notcurses(n);
  ncpile* p = ncplane_pile(n);
  if(nc->lfdimx == 0 || nc->lfdimy == 0){
    return 0;
  }
  fbuf f = {0};
  if(fbuf_init(&f)){
    return -1;
  }
  const unsigned count = (nc->lfdimx > p->dimx ? nc->lfdimx : p->dimx) *
                         (nc->lfdimy > p->dimy ? nc->lfdimy : p->dimy);
  p->crender = malloc(count * sizeof(*p->crender));
  if(p->crender == NULL){
    fbuf_free(&f);
    return -1;
  }
  init_rvec(p->crender, count);
  for(unsigned i = 0 ; i < count ; ++i){
    p->crender[i].s.damaged = 1;
  }
  int ret = raster_and_write(nc, p, &f);
  free(p->crender);
  if(ret > 0){
    if(fwrite(f.buf, f.used, 1, fp) == 1){
      ret = 0;
    }else{
      ret = -1;
    }
  }
  fbuf_free(&f);
  return ret;
}

Here is the call graph for this function:

ncplane_mergedown()

int ncplane_mergedown	(	ncplane *restrict	src,
		ncplane *restrict	dst,
		int	begsrcy,
		int	begsrcx,
		unsigned	leny,
		unsigned	lenx,
		int	dsty,
		int	dstx
	)

Definition at line 514 of file render.c.

                                         {
//fprintf(stderr, "Merging down %d/%d @ %d/%d to %d/%d\n", leny, lenx, begsrcy, begsrcx, dsty, dstx);
  if(dsty < 0){
    if(dsty != -1){
      logerror("invalid dsty %d", dsty);
      return -1;
    }
    dsty = dst->y;
  }
  if(dstx < 0){
    if(dstx != -1){
      logerror("invalid dstx %d", dstx);
      return -1;
    }
    dstx = dst->x;
  }
  if((unsigned)dsty >= dst->leny || (unsigned)dstx >= dst->lenx){
    logerror("dest origin %u/%u ≥ dest dimensions %d/%d",
             dsty, dstx, dst->leny, dst->lenx);
    return -1;
  }
  if(begsrcy < 0){
    if(begsrcy != -1){
      logerror("invalid begsrcy %d", begsrcy);
      return -1;
    }
    begsrcy = src->y;
  }
  if(begsrcx < 0){
    if(begsrcx != -1){
      logerror("invalid begsrcx %d", begsrcx);
      return -1;
    }
    begsrcx = src->x;
  }
  if((unsigned)begsrcy >= src->leny || (unsigned)begsrcx >= src->lenx){
    logerror("source origin %u/%u ≥ source dimensions %d/%d",
             begsrcy, begsrcx, src->leny, src->lenx);
    return -1;
  }
  if(leny == 0){
    if((leny = src->leny - begsrcy) == 0){
      logerror("source area was zero height");
      return -1;
    }
  }
  if(lenx == 0){
    if((lenx = src->lenx - begsrcx) == 0){
      logerror("source area was zero width");
      return -1;
    }
  }
  if(dst->leny - leny < (unsigned)dsty || dst->lenx - lenx < (unsigned)dstx){
    logerror("dest len %u/%u ≥ dest dimensions %d/%d",
             leny, lenx, dst->leny, dst->lenx);
    return -1;
  }
  if(src->leny - leny < (unsigned)begsrcy || src->lenx - lenx < (unsigned)begsrcx){
    logerror("source len %u/%u ≥ source dimensions %d/%d",
             leny, lenx, src->leny, src->lenx);
    return -1;
  }
  if(src->sprite || dst->sprite){
    logerror("can't merge sprixel planes");
    return -1;
  }
  const int totalcells = dst->leny * dst->lenx;
  nccell* rendfb = calloc(totalcells, sizeof(*rendfb));
  const size_t crenderlen = sizeof(struct crender) * totalcells;
  struct crender* rvec = malloc(crenderlen);
  if(!rendfb || !rvec){
    logerror("error allocating render state for %ux%u", leny, lenx);
    free(rendfb);
    free(rvec);
    return -1;
  }
  init_rvec(rvec, totalcells);
  sprixel* s = NULL;
  paint(src, rvec, dst->leny, dst->lenx, dst->absy, dst->absx, &s, 0);
  assert(NULL == s);
  paint(dst, rvec, dst->leny, dst->lenx, dst->absy, dst->absx, &s, 0);
  assert(NULL == s);
//fprintf(stderr, "Postpaint start (%dx%d)\n", dst->leny, dst->lenx);
  const struct tinfo* ti = &ncplane_notcurses_const(dst)->tcache;
  postpaint(ncplane_notcurses(dst), ti, rendfb, dst->leny, dst->lenx, rvec, &dst->pool);
//fprintf(stderr, "Postpaint done (%dx%d)\n", dst->leny, dst->lenx);
  free(dst->fb);
  dst->fb = rendfb;
  free(rvec);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_mergedown_simple()

int ncplane_mergedown_simple	(	ncplane *restrict	src,
		ncplane *restrict	dst
	)

Definition at line 608 of file render.c.

                                                                          {
  return ncplane_mergedown(src, dst, 0, 0, 0, 0, 0, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

notcurses_at_yx()

char * notcurses_at_yx	(	notcurses *	nc,
		unsigned	yoff,
		unsigned	xoff,
		uint16_t *	stylemask,
		uint64_t *	channels
	)

Definition at line 1627 of file render.c.

                                                                                                           {
  if(nc->lastframe == NULL){
    logerror("haven't yet rendered");
    return NULL;
  }
  if(yoff >= nc->lfdimy){
    logerror("invalid coordinates: %u/%u", yoff, xoff);
    return NULL;
  }
  if(xoff >= nc->lfdimx){
    logerror("invalid coordinates: %u/%u", yoff, xoff);
    return NULL;
  }
  const nccell* srccell = &nc->lastframe[yoff * nc->lfdimx + xoff];
  if(nccell_wide_right_p(srccell)){
    return notcurses_at_yx(nc, yoff, xoff - 1, stylemask, channels);
  }
  if(stylemask){
    *stylemask = srccell->stylemask;
  }
  if(channels){
    *channels = srccell->channels;
  }
//fprintf(stderr, "COPYING: %d from %p\n", srccell->gcluster, &nc->pool);
  return pool_egc_copy(&nc->pool, srccell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

notcurses_cursor_disable()

int notcurses_cursor_disable

(

notcurses *

nc

)

Definition at line 1774 of file render.c.

                                           {
  if(nc->cursorx < 0 || nc->cursory < 0){
    logerror("cursor is not enabled");
    return -1;
  }
  const char* cinvis = get_escape(&nc->tcache, ESCAPE_CIVIS);
  if(cinvis){
    if(!tty_emit(cinvis, nc->tcache.ttyfd) && !ncflush(nc->ttyfp)){
      nc->cursory = -1;
      nc->cursorx = -1;
      return 0;
    }
  }
  return -1;
}

Here is the caller graph for this function:

notcurses_cursor_enable()

int notcurses_cursor_enable	(	notcurses *	nc,
		int	y,
		int	x
	)

Definition at line 1740 of file render.c.

                                                        {
  if(y < 0 || x < 0){
    logerror("illegal cursor placement: %d, %d", y, x);
    return -1;
  }
  // if we're already at the demanded location, we must already be visible, and
  // we needn't move the cursor -- return success immediately.
  if(nc->cursory == y && nc->cursorx == x){
    return 0;
  }
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  // updates nc->rstate.cursor{y,x}
  if(goto_location(nc, &f, y + nc->margin_t, x + nc->margin_l, nc->rstate.lastsrcp)){
    fbuf_free(&f);
    return -1;
  }
  if(nc->cursory < 0){ // we weren't visible before, need cnorm
    const char* cnorm = get_escape(&nc->tcache, ESCAPE_CNORM);
    if(!cnorm || fbuf_emit(&f, cnorm)){
      fbuf_free(&f);
      return -1;
    }
  }
  if(fbuf_finalize(&f, nc->ttyfp)){
    return -1;
  }
  nc->cursory = y;
  nc->cursorx = x;
  return 0;
}

Here is the caller graph for this function:

notcurses_cursor_yx()

int notcurses_cursor_yx	(	const notcurses *	nc,
		int *	y,
		int *	x
	)

Definition at line 1734 of file render.c.

                                                            {
  *y = nc->rstate.y;
  *x = nc->rstate.x;
  return 0;
}

notcurses_default_background()

int notcurses_default_background	(	const struct notcurses *	nc,
		uint32_t *	bg
	)

Definition at line 1724 of file render.c.

                                                                          {
  const tinfo* ti = &nc->tcache;
  if(ti->bg_collides_default & 0x80000000){
    logerror("default background could not be determined");
    return -1;
  }
  *bg = ti->bg_collides_default & NC_BG_RGB_MASK;
  return 0;
}

notcurses_default_foreground()

int notcurses_default_foreground	(	const struct notcurses *	nc,
		uint32_t *	fg
	)

Definition at line 1714 of file render.c.

                                                                          {
  const tinfo* ti = &nc->tcache;
  if(ti->fg_default & 0x80000000){
    logerror("default foreground could not be determined");
    return -1;
  }
  *fg = ti->fg_default & NC_BG_RGB_MASK;
  return 0;
}

notcurses_refresh()

int notcurses_refresh	(	notcurses *	nc,
		unsigned *restrict	dimy,
		unsigned *restrict	dimx
	)

Definition at line 1419 of file render.c.

                                                                                      {
  if(notcurses_resize(nc, dimy, dimx)){
    return -1;
  }
  fbuf_reset(&nc->rstate.f);
  if(clear_and_home(nc, &nc->tcache, &nc->rstate.f)){
    return -1;
  }
  if(fbuf_flush(&nc->rstate.f, nc->ttyfp)){
    return -1;
  }
  if(nc->lfdimx == 0 || nc->lfdimy == 0){
    return 0;
  }
  ncpile p = {0};
  p.dimy = nc->lfdimy;
  p.dimx = nc->lfdimx;
  const int count = p.dimy * p.dimx;
  p.crender = malloc(count * sizeof(*p.crender));
  if(p.crender == NULL){
    return -1;
  }
  init_rvec(p.crender, count);
  for(int i = 0 ; i < count ; ++i){
    p.crender[i].s.damaged = 1;
  }
  int ret = notcurses_rasterize(nc, &p, &nc->rstate.f);
  free(p.crender);
  if(ret < 0){
    return -1;
  }
  ++nc->stats.s.refreshes;
  return 0;
}

Here is the call graph for this function:

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:

Variable Documentation

sigcont_seen_for_render

sig_atomic_t sigcont_seen_for_render = 0

Definition at line 7 of file render.c.