fill.c File Reference

#include "internal.h"

Include dependency graph for fill.c:

Go to the source code of this file.

Functions
void	ncplane_greyscale (ncplane *n)
int	ncplane_polyfill_yx (ncplane *n, int ystart, int xstart, const nccell *c)
bool	check_gradient_args (uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br)
int	ncplane_gradient2x1 (ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint32_t ul, uint32_t ur, uint32_t ll, uint32_t lr)
int	ncplane_highgradient_sized (ncplane *n, uint32_t ul, uint32_t ur, uint32_t ll, uint32_t lr, int ylen, int xlen)
int	ncplane_gradient (ncplane *n, int y, int x, unsigned ylen, unsigned xlen, const char *egc, uint16_t stylemask, uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br)
int	ncplane_stain (ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint64_t tl, uint64_t tr, uint64_t bl, uint64_t br)
int	ncplane_format (ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint16_t stylemask)
int	ncplane_rotate_cw (ncplane *n)
int	ncplane_rotate_ccw (ncplane *n)
int	ncplane_qrcode (ncplane *n, unsigned *ymax, unsigned *xmax, const void *data, size_t len)

Function Documentation

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:

ncplane_format()

int ncplane_format	(	ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint16_t	stylemask
	)

Definition at line 296 of file fill.c.

                                                     {
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      targc->stylemask = stylemask;
      ++total;
    }
  }
  return total;
}

Here is the caller graph for this function:

ncplane_gradient()

int ncplane_gradient	(	ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		const char *	egc,
		uint16_t	stylemask,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	bl,
		uint64_t	br
	)

Definition at line 227 of file fill.c.

                                                                        {
  if(check_gradient_args(ul, ur, bl, br)){
    return -1;
  }
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  if(ylen == 1){
    if(xlen == 1){
      if(ul != ur || ur != br || br != bl){
        logerror("channel variation in 1x1 area");
        return -1;
      }
    }else{
      if(ul != bl || ur != br){
        logerror("vertical channel variation in single row");
        return -1;
      }
    }
  }else if(xlen == 1){
    if(ul != ur || bl != br){
      logerror("horizontal channel variation in single column");
      return -1;
    }
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      targc->channels = 0;
      if(nccell_load(n, targc, egc) < 0){
        return -1;
      }
      targc->stylemask = stylemask;
      calc_gradient_channels(&targc->channels, ul, ur, bl, br,
                             yy - ystart, xx - xstart, ylen, xlen);
      ++total;
    }
  }
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_gradient2x1()

int ncplane_gradient2x1	(	ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint32_t	ul,
		uint32_t	ur,
		uint32_t	ll,
		uint32_t	lr
	)

Definition at line 179 of file fill.c.

                                                                           {
  if(!notcurses_canutf8(ncplane_notcurses(n))){
    logerror("highdef gradients require utf8");
    return -1;
  }
  if(check_gradient_channel_args(ul, ur, ll, lr)){
    return -1;
  }
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  if(xlen == 1){
    if(ul != ur || ll != lr){
      logerror("horizontal channel variation in single column");
      return -1;
    }
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      targc->channels = 0;
      if(pool_blit_direct(&n->pool, targc, "▀", strlen("▀"), 1) <= 0){
        return -1;
      }
      calc_highgradient(targc, ul, ur, ll, lr, yy - ystart, xx - xstart, ylen * 2, xlen);
      ++total;
    }
  }
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_greyscale()

void ncplane_greyscale

(

ncplane *

n

)

Definition at line 3 of file fill.c.

                                  {
  for(unsigned y = 0 ; y < n->leny ; ++y){
    for(unsigned x = 0 ; x < n->lenx ; ++x){
      nccell* c = &n->fb[nfbcellidx(n, y, x)];
      unsigned r, g, b;
      nccell_fg_rgb8(c, &r, &g, &b);
      int gy = rgb_greyscale(r, g, b);
      nccell_set_fg_rgb8(c, gy, gy, gy);
      nccell_bg_rgb8(c, &r, &g, &b);
      gy = rgb_greyscale(r, g, b);
      nccell_set_bg_rgb8(c, gy, gy, gy);
    }
  }
}

Here is the caller graph for this function:

ncplane_highgradient_sized()

int ncplane_highgradient_sized	(	ncplane *	n,
		uint32_t	ul,
		uint32_t	ur,
		uint32_t	ll,
		uint32_t	lr,
		int	ylen,
		int	xlen
	)

Definition at line 214 of file fill.c.

                                                                            {
  if(ylen < 1 || xlen < 1){
    return -1;
  }
  if(!notcurses_canutf8(ncplane_notcurses_const(n))){
    // this works because the uin32_ts we pass in will be promoted to uint64_ts
    // via extension, and the space will employ the background. mwahh!
    return ncplane_gradient(n, -1, -1, ylen, xlen, " ", 0, ul, ur, ll, lr);
  }
  return ncplane_gradient2x1(n, -1, -1, ylen, xlen, ul, ur, ll, lr);
}

Here is the call graph for this function:

ncplane_polyfill_yx()

int ncplane_polyfill_yx	(	ncplane *	n,
		int	ystart,
		int	xstart,
		const nccell *	c
	)

Definition at line 80 of file fill.c.

                                                                            {
  if(ystart < 0){
    if(ystart != -1){
      logerror("invalid y: %d", ystart);
      return -1;
    }
    ystart = n->y;
  }
  unsigned y = ystart;
  if(xstart < 0){
    if(xstart != -1){
      logerror("invalid x: %d", xstart);
      return -1;
    }
    xstart = n->x;
  }
  unsigned x = xstart;
  if(y >= n->leny || x >= n->lenx){
    logerror("invalid start: %u/%u (%u/%u)", y, x, n->leny, n->lenx);
    return -1;
  }
  const nccell* cur = &n->fb[nfbcellidx(n, y, x)];
  const char* targ = nccell_extended_gcluster(n, cur);
  const char* fillegc = nccell_extended_gcluster(n, c);
//fprintf(stderr, "checking %d/%d (%s) for [%s]\n", y, x, targ, fillegc);
  if(strcmp(fillegc, targ) == 0){
    return 0;
  }
  int ret = -1;
  // we need an external copy of this, since we'll be writing to it on
  // the first call into ncplane_polyfill_inner()
  char* targcopy = strdup(targ);
  if(targcopy){
    ret = ncplane_polyfill_inner(n, y, x, c, targcopy);
    free(targcopy);
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_qrcode()

int ncplane_qrcode	(	ncplane *	n,
		unsigned *	ymax,
		unsigned *	xmax,
		const void *	data,
		size_t	len
	)

Definition at line 651 of file fill.c.

                                                                                            {
  (void)n;
  (void)ymax;
  (void)xmax;
  (void)data;
  (void)len;
  return -1;
}

Here is the caller graph for this function:

ncplane_rotate_ccw()

int ncplane_rotate_ccw

(

ncplane *

n

)

Definition at line 515 of file fill.c.

                                  {
  ncplane* newp = rotate_plane(n);
  if(newp == NULL){
    return -1;
  }
  unsigned dimy, dimx, targdimy, targdimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  ncplane_dim_yx(newp, &targdimy, &targdimx);
  int x = (int)dimx - 2;
  int y;
  // Each row of the target plane is taken from a column of the source plane.
  // As the target row grows (down), the source column shrinks (moves left).
  for(unsigned targy = 0 ; targy < targdimy ; ++targy){
    y = 0;
    for(unsigned targx = 0 ; targx < targdimx ; targx += 2){
      if(rotate_2x1_ccw(n, newp, y, x, targy, targx)){
        ncplane_destroy(newp);
        return -1;
      }
      ++y;
    }
    x -= 2;
  }
  int ret = rotate_merge(n, newp);
  ret |= ncplane_destroy(newp);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_rotate_cw()

int ncplane_rotate_cw

(

ncplane *

n

)

Definition at line 484 of file fill.c.

                                 {
  ncplane* newp = rotate_plane(n);
  if(newp == NULL){
    return -1;
  }
  unsigned dimy, dimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  int centy, centx;
  ncplane_center_abs(n, &centy, &centx);
  // the topmost row consists of the leftmost two columns. the rightmost column
  // of the topmost row consists of the top half of the top two leftmost cells.
  // the penultimate column of the topmost row consists of the bottom half of
  // the top two leftmost cells. work from the bottom up on the source, so we
  // can copy to the top row from the left to the right.
  int targx, targy = 0;
  for(unsigned x = 0 ; x < dimx ; x += 2){
    targx = 0;
    for(int y = (int)dimy - 1 ; y >= 0 ; --y){
      if(rotate_2x1_cw(n, newp, y, x, targy, targx)){
        ncplane_destroy(newp);
        return -1;
      }
      targx += 2;
    }
    ++targy;
  }
  int ret = rotate_merge(n, newp);
  ret |= ncplane_destroy(newp);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncplane_stain()

int ncplane_stain	(	ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint64_t	tl,
		uint64_t	tr,
		uint64_t	bl,
		uint64_t	br
	)

Definition at line 272 of file fill.c.

                                                                     {
  // Can't use default or palette-indexed colors in a gradient
  if(check_gradient_args(tl, tr, bl, br)){
    return -1;
  }
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      if(targc->gcluster){
        calc_gradient_channels(&targc->channels, tl, tr, bl, br,
                               yy - ystart, xx - xstart, ylen, xlen);
      }
      ++total;
    }
  }
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function: