blackbeard420/notcurses
1
0
Fork 0
mirror of https://github.com/dankamongmen/notcurses synced 2025-03-09 17:19:03 -04:00
Code Issues Projects Releases Wiki Activity

convert another crop of cell_ to nccell_ #1532

Browse Source
This commit is contained in:
nick black 2021-04-15 01:31:12 -04:00
parent 452b7cd535
commit 7ad5219fa2
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
15 changed files with 252 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
USAGE.md
View File

@ -1657,8 +1657,8 @@ Unlike the `notcurses` or `ncplane` objects, the definition of `nccell` is
available to the user. It is somewhat ironic, then, that the user typically
needn't (and shouldn't) use `nccell`s directly. Use an `nccell` when the EGC
being output is used several times. In this case, time otherwise spent running
`cell_load()` (which tokenizes and verifies EGCs) can be saved. It can also be
useful to use an `ncell` when the same styling is used in a discontinuous
`nccell_load()` (which tokenizes and verifies EGCs) can be saved. It can also
be useful to use an `nccell` when the same styling is used in a discontinuous
manner.
```c
@ -1813,10 +1813,10 @@ An `nccell` has three fundamental elements:
* The Curses-style attributes of the text.
* The 52 bits of foreground and background RGBA (2x8/8/8/2), plus a few flags.
The EGC should be loaded using `cell_load()`. Either a single NUL-terminated
The EGC should be loaded using `nccell_load()`. Either a single NUL-terminated
EGC can be provided, or a string composed of multiple EGCs. In the latter case,
the first EGC from the string is loaded. Remember, backing storage for the EGC
is provided by the `ncplane` passed to `cell_load()`; if this `ncplane` is
is provided by the `ncplane` passed to `nccell_load()`; if this `ncplane` is
destroyed (or even erased), the `nccell` cannot safely be used. If you're done
using the `nccell` before being done with the `ncplane`, call `nccell_release()`
to free up the EGC resources.
@ -1825,15 +1825,15 @@ to free up the EGC resources.
// Breaks the UTF-8 string in 'gcluster' down, setting up the nccell 'c'.
// Returns the number of bytes copied out of 'gcluster', or -1 on failure. The
// styling of the cell is left untouched, but any resources are released.
int cell_load(struct ncplane* n, nccell* c, const char* gcluster);
int nccell_load(struct ncplane* n, nccell* c, const char* gcluster);
// cell_load(), plus blast the styling with 'attr' and 'channels'.
// nccell_load(), plus blast the styling with 'attr' and 'channels'.
static inline int
nccell_prime(struct ncplane* n, nccell* c, const char* gcluster,
uint32_t stylemask, uint64_t channels){
c->stylemask = stylemask;
c->channels = channels;
int ret = cell_load(n, c, gcluster);
int ret = nccell_load(n, c, gcluster);
return ret;
}
@ -1879,19 +1879,19 @@ nccell_styles(const nccell* c){
// Add the specified styles (in the LSBs) to the cell's existing spec, whether
// they're actively supported or not.
static inline void
cell_on_styles(nccell* c, unsigned stylebits){
nccell_on_styles(nccell* c, unsigned stylebits){
c->stylemask |= (stylebits & NCSTYLE_MASK);
}
// Remove the specified styles (in the LSBs) from the cell's existing spec.
static inline void
cell_off_styles(nccell* c, unsigned stylebits){
nccell_off_styles(nccell* c, unsigned stylebits){
c->stylemask &= ~(stylebits & NCSTYLE_MASK);
}
// Is the cell part of a multicolumn element?
static inline bool
cell_double_wide_p(const nccell* c){
nccell_double_wide_p(const nccell* c){
return (c->width >= 2);
}
@ -1902,7 +1902,7 @@ nccell_load_char(struct ncplane* n, nccell* c, char ch){
char gcluster[2];
gcluster[0] = ch;
gcluster[1] = '\0';
return cell_load(n, c, gcluster);
return nccell_load(n, c, gcluster);
}
// Load a UTF-8 encoded EGC of up to 4 bytes into the nccell 'c'. Returns the
@ -1913,7 +1913,7 @@ nccell_load_egc32(struct ncplane* n, nccell* c, uint32_t egc){
egc = htole(egc);
memcpy(gcluster, &egc, sizeof(egc));
gcluster[4] = '\0';
return cell_load(n, c, gcluster);
return nccell_load(n, c, gcluster);
}
// return a pointer to the NUL-terminated EGC referenced by 'c'. this pointer
@ -1989,103 +1989,103 @@ all implemented in terms of the lower-level [Channels API](#channels).
```c
// Extract the 32-bit background channel from a cell.
static inline uint32_t
cell_bchannel(const nccell* cl){
nccell_bchannel(const nccell* cl){
return channels_bchannel(cl->channels);
}
// Extract the 32-bit foreground channel from a cell.
static inline uint32_t
cell_fchannel(const nccell* cl){
nccell_fchannel(const nccell* cl){
return channels_fchannel(cl->channels);
}
// Extract 24 bits of foreground RGB from 'cl', shifted to LSBs.
static inline uint32_t
cell_fg_rgb(const nccell* cl){
nccell_fg_rgb(const nccell* cl){
return channels_fg_rgb(cl->channels);
}
// Extract 24 bits of background RGB from 'cl', shifted to LSBs.
static inline uint32_t
cell_bg_rgb(const nccell* cl){
nccell_bg_rgb(const nccell* cl){
return channels_bg_rgb(cl->channels);
}
// Extract 2 bits of foreground alpha from 'cl', shifted to LSBs.
static inline unsigned
cell_fg_alpha(const nccell* cl){
nccell_fg_alpha(const nccell* cl){
return channels_fg_alpha(cl->channels);
}
// Extract 2 bits of background alpha from 'cl', shifted to LSBs.
static inline unsigned
cell_bg_alpha(const nccell* cl){
nccell_bg_alpha(const nccell* cl){
return channels_bg_alpha(cl->channels);
}
// Extract 24 bits of foreground RGB from 'cl', split into subcell.
static inline uint32_t
cell_fg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){
nccell_fg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){
return channels_fg_rgb8(cl->channels, r, g, b);
}
// Extract 24 bits of background RGB from 'cl', split into subcell.
static inline uint32_t
cell_bg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){
nccell_bg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){
return channels_bg_rgb8(cl->channels, r, g, b);
}
// Set the r, g, and b cell for the foreground component of this 64-bit
// 'cell' variable, and mark it as not using the default color.
static inline int
cell_set_fg_rgb8(nccell* cl, int r, int g, int b){
nccell_set_fg_rgb8(nccell* cl, int r, int g, int b){
return channels_set_fg_rgb8(&cl->channels, r, g, b);
}
// Same, but clipped to [0..255].
static inline void
cell_set_fg_rgb8_clipped(nccell* cl, int r, int g, int b){
nccell_set_fg_rgb8_clipped(nccell* cl, int r, int g, int b){
channels_set_fg_rgb8_clipped(&cl->channels, r, g, b);
}
// Same, but with an assembled 24-bit RGB value.
static inline int
cell_set_fg_rgb(nccell* c, uint32_t channel){
nccell_set_fg_rgb(nccell* c, uint32_t channel){
return channels_set_fg_rgb(&c->channels, channel);
}
// Set the r, g, and b cell for the background component of this 64-bit
// 'cell' variable, and mark it as not using the default color.
static inline int
cell_set_bg_rgb8(nccell* cl, int r, int g, int b){
nccell_set_bg_rgb8(nccell* cl, int r, int g, int b){
return channels_set_bg_rgb8(&cl->channels, r, g, b);
}
// Same, but clipped to [0..255].
static inline void
cell_set_bg_rgb8_clipped(nccell* cl, int r, int g, int b){
nccell_set_bg_rgb8_clipped(nccell* cl, int r, int g, int b){
channels_set_bg_rgb8_clipped(&cl->channels, r, g, b);
}
// Same, but with an assembled 24-bit RGB value.
static inline int
cell_set_bg_rgb(nccell* c, uint32_t channel){
nccell_set_bg_rgb(nccell* c, uint32_t channel){
return channels_set_bg_rgb(&c->channels, channel);
}
static inline int
cell_set_fg_alpha(nccell* c, unsigned alpha){
nccell_set_fg_alpha(nccell* c, unsigned alpha){
return channels_set_fg_alpha(&c->channels, alpha);
}
static inline int
cell_set_bg_alpha(nccell* c, unsigned alpha){
nccell_set_bg_alpha(nccell* c, unsigned alpha){
return channels_set_bg_alpha(&c->channels, alpha);
}
// Is the foreground using the "default foreground color"?
static inline bool
cell_fg_default_p(const nccell* cl){
nccell_fg_default_p(const nccell* cl){
return channels_fg_default_p(cl->channels);
}
@ -2093,19 +2093,19 @@ cell_fg_default_p(const nccell* cl){
// background color" must generally be used to take advantage of
// terminal-effected transparency.
static inline bool
cell_bg_default_p(const nccell* cl){
nccell_bg_default_p(const nccell* cl){
return channels_bg_default_p(cl->channels);
}
// Use the default color for the foreground.
static inline void
cell_set_fg_default(nccell* c){
nccell_set_fg_default(nccell* c){
channels_set_fg_default(&c->channels);
}
// Use the default color for the background.
static inline void
cell_set_bg_default(nccell* c){
nccell_set_bg_default(nccell* c){
channels_set_bg_default(&c->channels);
}

54
doc/man/man3/notcurses_cell.3.md
View File

@ -57,19 +57,19 @@ typedef struct nccell {
**bool nccellcmp(const struct ncplane* ***n1***, const nccell* ***c1***, const struct ncplane* ***n2***, const nccell* ***c2***);**
**void cell_on_styles(nccell* ***c***, unsigned ***stylebits***);**
**void nccell_on_styles(nccell* ***c***, unsigned ***stylebits***);**
**void cell_off_styles(nccell* ***c***, unsigned ***stylebits***);**
**void nccell_off_styles(nccell* ***c***, unsigned ***stylebits***);**
**void cell_set_fg_default(nccell* ***c***);**
**void nccell_set_fg_default(nccell* ***c***);**
**void cell_set_bg_default(nccell* ***c***);**
**void nccell_set_bg_default(nccell* ***c***);**
**int cell_set_fg_alpha(nccell* ***c***, unsigned ***alpha***);**
**int nccell_set_fg_alpha(nccell* ***c***, unsigned ***alpha***);**
**int cell_set_bg_alpha(nccell* ***c***, unsigned ***alpha***);**
**int nccell_set_bg_alpha(nccell* ***c***, unsigned ***alpha***);**
**bool cell_double_wide_p(const nccell* ***c***);**
**bool nccell_double_wide_p(const nccell* ***c***);**
**const char* nccell_extended_gcluster(const struct ncplane* ***n***, const nccell* ***c***);**
@ -79,43 +79,43 @@ typedef struct nccell {
**int nccell_load_egc32(struct ncplane* ***n***, nccell* ***c***, uint32_t ***egc***);**
**char* cell_extract(const struct ncplane* ***n***, const nccell* ***c***, uint16_t* ***stylemask***, uint64_t* ***channels***);**
**char* nccell_extract(const struct ncplane* ***n***, const nccell* ***c***, uint16_t* ***stylemask***, uint64_t* ***channels***);**
**uint32_t cell_bchannel(const nccell* ***c***);**
**uint32_t nccell_bchannel(const nccell* ***c***);**
**uint32_t cell_fchannel(const nccell* ***c***);**
**uint32_t nccell_fchannel(const nccell* ***c***);**
**uint64_t cell_set_bchannel(nccell* ***c***, uint32_t ***channel***);**
**uint64_t nccell_set_bchannel(nccell* ***c***, uint32_t ***channel***);**
**uint64_t cell_set_fchannel(nccell* ***c***, uint32_t ***channel***);**
**uint64_t nccell_set_fchannel(nccell* ***c***, uint32_t ***channel***);**
**uint32_t cell_fg_rgb(const nccell* ***c***);**
**uint32_t nccell_fg_rgb(const nccell* ***c***);**
**uint32_t cell_bg_rgb(const nccell* ***c***);**
**uint32_t nccell_bg_rgb(const nccell* ***c***);**
**unsigned cell_fg_alpha(const nccell* ***c***);**
**unsigned nccell_fg_alpha(const nccell* ***c***);**
**unsigned cell_bg_alpha(const nccell* ***c***);**
**unsigned nccell_bg_alpha(const nccell* ***c***);**
**unsigned cell_fg_rgb8(const nccell* ***c***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);**
**unsigned nccell_fg_rgb8(const nccell* ***c***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);**
**unsigned cell_bg_rgb8(const ncell* ***c***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);**
**unsigned nccell_bg_rgb8(const ncell* ***c***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);**
**int cell_set_fg_rgb8(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**int nccell_set_fg_rgb8(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**int cell_set_bg_rgb8(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**int nccell_set_bg_rgb8(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**void cell_set_fg_rgb8_clipped(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**void nccell_set_fg_rgb8_clipped(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**void cell_set_bg_rgb8_clipped(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**void nccell_set_bg_rgb8_clipped(nccell* ***c***, int ***r***, int ***g***, int ***b***);**
**int cell_set_fg_rgb(nccell* ***c***, uint32_t ***channel***);**
**int nccell_set_fg_rgb(nccell* ***c***, uint32_t ***channel***);**
**int cell_set_bg_rgb(nccell* ***c***, uint32_t ***channel***);**
**int nccell_set_bg_rgb(nccell* ***c***, uint32_t ***channel***);**
**bool cell_fg_default_p(const nccell* ***c***);**
**bool nccell_fg_default_p(const nccell* ***c***);**
**bool cell_bg_default_p(const nccell* ***c***);**
**bool nccell_bg_default_p(const nccell* ***c***);**
**int ncstrwidth(const char* ***text***)**;
@ -151,7 +151,7 @@ A heap-allocated copy can be acquired with **nccell_strdup**.
EGC, or -1 on failure. They can fail due to either an invalid UTF-8 input, or the
backing egcpool reaching its maximum size.
**cell_set_fg_rgb8** and similar functions will return -1 if provided invalid
**nccell_set_fg_rgb8** and similar functions will return -1 if provided invalid
inputs, and 0 otherwise.
**nccellcmp** returns a negative integer, 0, or a positive integer if ***c1*** is

14
include/ncpp/Cell.hh
View File

@ -97,7 +97,7 @@ namespace ncpp
bool is_double_wide () const noexcept
{
return cell_double_wide_p (&_cell);
return nccell_double_wide_p (&_cell);
}
unsigned get_fg_rgb () const noexcept
@ -112,12 +112,12 @@ namespace ncpp
unsigned get_fg_alpha () const noexcept
{
return cell_fg_alpha (&_cell);
return nccell_fg_alpha (&_cell);
}
bool is_fg_default () const noexcept
{
return cell_fg_default_p (&_cell);
return nccell_fg_default_p (&_cell);
}
bool set_fg_alpha (unsigned alpha) noexcept
@ -127,7 +127,7 @@ namespace ncpp
unsigned get_bg_alpha () const noexcept
{
return cell_bg_alpha (&_cell);
return nccell_bg_alpha (&_cell);
}
bool set_bg_alpha (unsigned alpha) noexcept
@ -187,17 +187,17 @@ namespace ncpp
bool is_bg_default () const noexcept
{
return cell_bg_default_p (&_cell);
return nccell_bg_default_p (&_cell);
}
bool is_wide_right () const noexcept
{
return cell_wide_right_p (&_cell);
return nccell_wide_right_p (&_cell);
}
bool is_wide_left () const noexcept
{
return cell_wide_left_p (&_cell);
return nccell_wide_left_p (&_cell);
}
private:

91
include/notcurses/notcurses.h
View File

@ -788,20 +788,35 @@ cell_set_bg_alpha(nccell* c, int alpha){
// Is the cell part of a multicolumn element?
static inline bool
cell_double_wide_p(const nccell* c){
nccell_double_wide_p(const nccell* c){
return (c->width >= 2);
}
__attribute__ ((deprecated)) static inline bool
cell_double_wide_p(const nccell* c){
return nccell_double_wide_p(c);
}
// Is this the right half of a wide character?
static inline bool
nccell_wide_right_p(const nccell* c){
return nccell_double_wide_p(c) && c->gcluster == 0;
}
__attribute__ ((deprecated)) static inline bool
cell_wide_right_p(const nccell* c){
return cell_double_wide_p(c) && c->gcluster == 0;
return nccell_wide_right_p(c);
}
// Is this the left half of a wide character?
static inline bool
nccell_wide_left_p(const nccell* c){
return nccell_double_wide_p(c) && c->gcluster;
}
__attribute__ ((deprecated)) static inline bool
cell_wide_left_p(const nccell* c){
return cell_double_wide_p(c) && c->gcluster;
return nccell_wide_left_p(c);
}
// return a pointer to the NUL-terminated EGC referenced by 'c'. this pointer
@ -2083,16 +2098,26 @@ cell_bg_rgb(const nccell* cl){
// Extract 2 bits of foreground alpha from 'cl', shifted to LSBs.
static inline uint32_t
cell_fg_alpha(const nccell* cl){
nccell_fg_alpha(const nccell* cl){
return channels_fg_alpha(cl->channels);
}
__attribute__ ((deprecated)) static inline uint32_t
cell_fg_alpha(const nccell* cl){
return nccell_fg_alpha(cl);
}
// Extract 2 bits of background alpha from 'cl', shifted to LSBs.
static inline uint32_t
cell_bg_alpha(const nccell* cl){
nccell_bg_alpha(const nccell* cl){
return channels_bg_alpha(cl->channels);
}
__attribute__ ((deprecated)) static inline uint32_t
cell_bg_alpha(const nccell* cl){
return nccell_bg_alpha(cl);
}
// Extract 24 bits of foreground RGB from 'cl', split into components.
static inline uint32_t
nccell_fg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){
@ -2153,15 +2178,25 @@ cell_set_fg_rgb(nccell* c, uint32_t channel){
// Set the cell's foreground palette index, set the foreground palette index
// bit, set it foreground-opaque, and clear the foreground default color bit.
static inline int
cell_set_fg_palindex(nccell* cl, int idx){
nccell_set_fg_palindex(nccell* cl, int idx){
return channels_set_fg_palindex(&cl->channels, idx);
}
__attribute__ ((deprecated)) static inline int
cell_set_fg_palindex(nccell* cl, int idx){
return nccell_set_fg_palindex(cl, idx);
}
static inline uint32_t
cell_fg_palindex(const nccell* cl){
nccell_fg_palindex(const nccell* cl){
return channels_fg_palindex(cl->channels);
}
__attribute__ ((deprecated)) static inline uint32_t
cell_fg_palindex(const nccell* cl){
return nccell_fg_palindex(cl);
}
// Set the r, g, and b cell for the background component of this 64-bit
// 'cl' variable, and mark it as not using the default color.
static inline int
@ -2195,39 +2230,69 @@ cell_set_bg_rgb(nccell* c, uint32_t channel){
// Set the cell's background palette index, set the background palette index
// bit, set it background-opaque, and clear the background default color bit.
static inline int
cell_set_bg_palindex(nccell* cl, int idx){
nccell_set_bg_palindex(nccell* cl, int idx){
return channels_set_bg_palindex(&cl->channels, idx);
}
__attribute__ ((deprecated)) static inline int
cell_set_bg_palindex(nccell* cl, int idx){
return nccell_set_bg_palindex(cl, idx);
}
static inline uint32_t
cell_bg_palindex(const nccell* cl){
nccell_bg_palindex(const nccell* cl){
return channels_bg_palindex(cl->channels);
}
__attribute__ ((deprecated)) static inline uint32_t
cell_bg_palindex(const nccell* cl){
return nccell_bg_palindex(cl);
}
// Is the foreground using the "default foreground color"?
static inline bool
cell_fg_default_p(const nccell* cl){
nccell_fg_default_p(const nccell* cl){
return channels_fg_default_p(cl->channels);
}
__attribute__ ((deprecated)) static inline bool
cell_fg_default_p(const nccell* cl){
return nccell_fg_default_p(cl);
}
static inline bool
cell_fg_palindex_p(const nccell* cl){
nccell_fg_palindex_p(const nccell* cl){
return channels_fg_palindex_p(cl->channels);
}
__attribute__ ((deprecated)) static inline bool
cell_fg_palindex_p(const nccell* cl){
return nccell_fg_palindex_p(cl);
}
// Is the background using the "default background color"? The "default
// background color" must generally be used to take advantage of
// terminal-effected transparency.
static inline bool
cell_bg_default_p(const nccell* cl){
nccell_bg_default_p(const nccell* cl){
return channels_bg_default_p(cl->channels);
}
__attribute__ ((deprecated)) static inline bool
cell_bg_default_p(const nccell* cl){
return nccell_bg_default_p(cl);
}
static inline bool
cell_bg_palindex_p(const nccell* cl){
nccell_bg_palindex_p(const nccell* cl){
return channels_bg_palindex_p(cl->channels);
}
__attribute__ ((deprecated)) static inline bool
cell_bg_palindex_p(const nccell* cl){
return nccell_bg_palindex_p(cl);
}
// Extract the 32-bit working background channel from an ncplane.
static inline uint32_t
ncplane_bchannel(const struct ncplane* n){

2
src/demo/fallin.c
View File

@ -162,7 +162,7 @@ int fallin_demo(struct notcurses* nc){
if(ncplane_putc_yx(n, usey - y, usex - x, &c) < 0){
// allow a fail if we were printing a wide char to the
// last column of our plane
if(!cell_double_wide_p(&c) || usex + 1 < x + newx){
if(!nccell_double_wide_p(&c) || usex + 1 < x + newx){
nccell_release(n, &c);
goto err;
}

6
src/demo/jungle.c
View File

@ -26622,15 +26622,15 @@ int jungle_demo(struct notcurses* nc){
for(size_t x = 1 ; x < ORIGWIDTH ; x += xiter){
int idx = y * ORIGWIDTH + x;
int idx2 = (y + yiter) * ORIGWIDTH + x;
if(cell_set_fg_palindex(&c, buf[idx])){
if(nccell_set_fg_palindex(&c, buf[idx])){
return -1;
}
if(y + yiter < ORIGHEIGHT){
if(cell_set_bg_palindex(&c, buf[idx2])){
if(nccell_set_bg_palindex(&c, buf[idx2])){
return -1;
}
}else{
if(cell_set_bg_palindex(&c, 0)){
if(nccell_set_bg_palindex(&c, 0)){
return -1;
}
}

2
src/demo/whiteout.c
View File

@ -49,7 +49,7 @@ mathplane(struct notcurses* nc){
// the closer the coordinate is (lower distance), the more we lighten the cell
static inline int
lighten(struct ncplane* n, nccell* c, int distance, int y, int x){
if(cell_wide_right_p(c)){ // not really a character
if(nccell_wide_right_p(c)){ // not really a character
return 0;
}
unsigned r, g, b;

12
src/lib/fade.c
View File

@ -120,13 +120,13 @@ int ncplane_fadein_iteration(ncplane* n, ncfadectx* nctx, int iter,
unsigned br, bg, bb;
channels_bg_rgb8(nctx->channels[nctx->cols * y + x], &br, &bg, &bb);
nccell* c = &n->fb[dimx * y + x];
if(!cell_fg_default_p(c)){
if(!nccell_fg_default_p(c)){
r = r * iter / nctx->maxsteps;
g = g * iter / nctx->maxsteps;
b = b * iter / nctx->maxsteps;
nccell_set_fg_rgb8(c, r, g, b);
}
if(!cell_bg_default_p(c)){
if(!nccell_bg_default_p(c)){
br = br * iter / nctx->maxsteps;
bg = bg * iter / nctx->maxsteps;
bb = bb * iter / nctx->maxsteps;
@ -183,14 +183,14 @@ int ncplane_fadeout_iteration(ncplane* n, ncfadectx* nctx, int iter,
for(y = 0 ; y < nctx->rows && y < dimy ; ++y){
for(x = 0 ; x < nctx->cols && x < dimx; ++x){
nccell* c = &n->fb[dimx * y + x];
if(!cell_fg_default_p(c)){
if(!nccell_fg_default_p(c)){
channels_fg_rgb8(nctx->channels[nctx->cols * y + x], &r, &g, &b);
r = r * (nctx->maxsteps - iter) / nctx->maxsteps;
g = g * (nctx->maxsteps - iter) / nctx->maxsteps;
b = b * (nctx->maxsteps - iter) / nctx->maxsteps;
nccell_set_fg_rgb8(c, r, g, b);
}
if(!cell_bg_default_p(c)){
if(!nccell_bg_default_p(c)){
channels_bg_rgb8(nctx->channels[nctx->cols * y + x], &br, &bg, &bb);
br = br * (nctx->maxsteps - iter) / nctx->maxsteps;
bg = bg * (nctx->maxsteps - iter) / nctx->maxsteps;
@ -200,14 +200,14 @@ int ncplane_fadeout_iteration(ncplane* n, ncfadectx* nctx, int iter,
}
}
nccell* c = &n->basecell;
if(!cell_fg_default_p(c)){
if(!nccell_fg_default_p(c)){
channels_fg_rgb8(nctx->channels[nctx->cols * y], &r, &g, &b);
r = r * (nctx->maxsteps - iter) / nctx->maxsteps;
g = g * (nctx->maxsteps - iter) / nctx->maxsteps;
b = b * (nctx->maxsteps - iter) / nctx->maxsteps;
nccell_set_fg_rgb8(&n->basecell, r, g, b);
}
if(!cell_bg_default_p(c)){
if(!nccell_bg_default_p(c)){
channels_bg_rgb8(nctx->channels[nctx->cols * y], &br, &bg, &bb);
br = br * (nctx->maxsteps - iter) / nctx->maxsteps;
bg = bg * (nctx->maxsteps - iter) / nctx->maxsteps;

10
src/lib/notcurses.c
View File

@ -1280,7 +1280,7 @@ int ncplane_set_bg_palindex(ncplane* n, int idx){
}
int ncplane_set_base_cell(ncplane* ncp, const nccell* c){
if(cell_wide_right_p(c)){
if(nccell_wide_right_p(c)){
return -1;
}
return nccell_duplicate(ncp, &ncp->basecell, c);
@ -1475,7 +1475,7 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
// wide chars, totalling four columns.
nccell* targ = ncplane_cell_ref_yx(n, n->y, n->x);
if(n->x > 0){
if(cell_double_wide_p(targ)){ // replaced cell is half of a wide char
if(nccell_double_wide_p(targ)){ // replaced cell is half of a wide char
nccell* sacrifice = targ->gcluster == 0 ?
// right half will never be on the first column of a row
&n->fb[nfbcellidx(n, n->y, n->x - 1)] :
@ -1489,12 +1489,12 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
if(cell_load_direct(n, targ, egc, bytes, cols) < 0){
return -1;
}
//fprintf(stderr, "%08x %016lx %c %d %d\n", targ->gcluster, targ->channels, cell_double_wide_p(targ) ? 'D' : 'd', bytes, cols);
//fprintf(stderr, "%08x %016lx %c %d %d\n", targ->gcluster, targ->channels, nccell_double_wide_p(targ) ? 'D' : 'd', bytes, cols);
// must set our right hand sides wide, and check for further damage
++n->x;
for(int i = 1 ; i < cols ; ++i){
nccell* candidate = &n->fb[nfbcellidx(n, n->y, n->x)];
if(cell_wide_left_p(candidate)){
if(nccell_wide_left_p(candidate)){
nccell_obliterate(n, &n->fb[nfbcellidx(n, n->y, n->x + 1)]);
}
nccell_release(n, candidate);
@ -1507,7 +1507,7 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
}
int ncplane_putc_yx(ncplane* n, int y, int x, const nccell* c){
const int cols = cell_double_wide_p(c) ? 2 : 1;
const int cols = nccell_double_wide_p(c) ? 2 : 1;
const char* egc = nccell_extended_gcluster(n, c);
return ncplane_put(n, y, x, egc, cols, c->stylemask, c->channels, strlen(egc));
}

66
src/lib/render.c
View File

@ -205,7 +205,7 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
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(cell_wide_right_p(targc)){
if(nccell_wide_right_p(targc)){
continue;
}
const nccell* vis = &p->fb[nfbcellidx(p, y, x)];
@ -218,17 +218,17 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
continue;
}
if(cell_fg_alpha(targc) > CELL_ALPHA_OPAQUE){
if(nccell_fg_alpha(targc) > CELL_ALPHA_OPAQUE){
vis = &p->fb[nfbcellidx(p, y, x)];
if(cell_fg_default_p(vis)){
if(nccell_fg_default_p(vis)){
vis = &p->basecell;
}
if(cell_fg_palindex_p(vis)){
if(cell_fg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
cell_set_fg_palindex(targc, cell_fg_palindex(vis));
if(nccell_fg_palindex_p(vis)){
if(nccell_fg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
nccell_set_fg_palindex(targc, nccell_fg_palindex(vis));
}
}else{
if(cell_fg_alpha(vis) == CELL_ALPHA_HIGHCONTRAST){
if(nccell_fg_alpha(vis) == CELL_ALPHA_HIGHCONTRAST){
crender->s.highcontrast = true;
crender->s.hcfgblends = crender->s.fgblends;
crender->hcfg = cell_fchannel(targc);
@ -250,19 +250,19 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
// 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(cell_bg_alpha(targc) > CELL_ALPHA_OPAQUE){
if(nccell_bg_alpha(targc) > CELL_ALPHA_OPAQUE){
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(cell_bg_default_p(vis)){
if(nccell_bg_default_p(vis)){
vis = &p->basecell;
}
if(cell_bg_palindex_p(vis)){
if(cell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
cell_set_bg_palindex(targc, cell_bg_palindex(vis));
if(nccell_bg_palindex_p(vis)){
if(nccell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
nccell_set_bg_palindex(targc, nccell_bg_palindex(vis));
}
}else{
unsigned bgblends = crender->s.bgblends;
@ -270,12 +270,12 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
crender->s.bgblends = bgblends;
}
}else{ // use the local foreground; we're stacking blittings
if(cell_fg_default_p(vis)){
if(nccell_fg_default_p(vis)){
vis = &p->basecell;
}
if(cell_fg_palindex_p(vis)){
if(cell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
cell_set_bg_palindex(targc, cell_fg_palindex(vis));
if(nccell_fg_palindex_p(vis)){
if(nccell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
nccell_set_bg_palindex(targc, nccell_fg_palindex(vis));
}
}else{
unsigned bgblends = crender->s.bgblends;
@ -295,7 +295,7 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
// from cells underneath us.
if(!crender->p){
vis = &p->fb[nfbcellidx(p, y, x)];
if(vis->gcluster == 0 && !cell_double_wide_p(vis)){
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
@ -307,7 +307,7 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
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(cell_double_wide_p(vis)){
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(' ');
@ -326,7 +326,7 @@ paint(const ncplane* p, struct crender* rvec, int dstleny, int dstlenx,
targc->width = vis->width;
}
crender->p = p;
}else if(cell_wide_right_p(vis)){
}else if(nccell_wide_right_p(vis)){
crender->p = p;
targc->width = 0;
}
@ -352,15 +352,15 @@ init_rvec(struct crender* rvec, int totalcells){
// against the real background.
static inline void
lock_in_highcontrast(nccell* targc, struct crender* crender){
if(cell_fg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
if(nccell_fg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
nccell_set_fg_default(targc);
}
if(cell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
if(nccell_bg_alpha(targc) == CELL_ALPHA_TRANSPARENT){
nccell_set_bg_default(targc);
}
if(crender->s.highcontrast){
// highcontrast weighs the original at 1/4 and the contrast at 3/4
if(!cell_fg_default_p(targc)){
if(!nccell_fg_default_p(targc)){
unsigned fgblends = 3;
uint32_t fchan = cell_fchannel(targc);
uint32_t bchan = cell_bchannel(targc);
@ -387,7 +387,7 @@ postpaint_cell(nccell* lastframe, int dimx, struct crender* crender,
if(cellcmp_and_dupfar(pool, prevcell, crender->p, targc) > 0){
//fprintf(stderr, "damaging due to cmp\n");
crender->s.damaged = 1;
assert(!cell_wide_right_p(targc));
assert(!nccell_wide_right_p(targc));
const int width = targc->width;
for(int i = 1 ; i < width ; ++i){
const ncplane* tmpp = crender->p;
@ -808,7 +808,7 @@ raster_defaults(notcurses* nc, bool fgdef, bool bgdef, FILE* out){
// these are unlikely, so we leave it uninlined
static int
emit_fg_palindex(notcurses* nc, FILE* out, const nccell* srccell){
unsigned palfg = cell_fg_palindex(srccell);
unsigned palfg = nccell_fg_palindex(srccell);
// we overload lastr for the palette index; both are 8 bits
if(nc->rstate.fgpalelidable && nc->rstate.lastr == palfg){
++nc->stats.fgelisions;
@ -827,7 +827,7 @@ emit_fg_palindex(notcurses* nc, FILE* out, const nccell* srccell){
static int
emit_bg_palindex(notcurses* nc, FILE* out, const nccell* srccell){
unsigned palbg = cell_bg_palindex(srccell);
unsigned palbg = nccell_bg_palindex(srccell);
if(nc->rstate.bgpalelidable && nc->rstate.lastbr == palbg){
++nc->stats.bgelisions;
}else{
@ -930,7 +930,7 @@ rasterize_core(notcurses* nc, const ncpile* p, FILE* out, unsigned phase){
// no need to emit a cell; what we rendered appears to already be
// here. no updates are performed to elision state nor lastframe.
++nc->stats.cellelisions;
if(cell_wide_left_p(srccell)){
if(nccell_wide_left_p(srccell)){
++x;
}
}else if(phase != 0 || !rvec[damageidx].s.p_beats_sprixel){
@ -952,9 +952,9 @@ rasterize_core(notcurses* nc, const ncpile* p, FILE* out, unsigned phase){
// * we are a no-foreground glyph, and the previous was default background, or
// * we are a no-background glyph, and the previous was default foreground
bool nobackground = cell_nobackground_p(srccell);
if((cell_fg_default_p(srccell)) || (!nobackground && cell_bg_default_p(srccell))){
if(raster_defaults(nc, cell_fg_default_p(srccell),
!nobackground && cell_bg_default_p(srccell), out)){
if((nccell_fg_default_p(srccell)) || (!nobackground && nccell_bg_default_p(srccell))){
if(raster_defaults(nc, nccell_fg_default_p(srccell),
!nobackground && nccell_bg_default_p(srccell), out)){
return -1;
}
}
@ -962,11 +962,11 @@ rasterize_core(notcurses* nc, const ncpile* p, FILE* out, unsigned phase){
// non-default foreground set iff either:
// * the previous was non-default, and matches what we have now, or
// * we are a no-foreground glyph (iswspace() is true)
if(cell_fg_palindex_p(srccell)){ // palette-indexed foreground
if(nccell_fg_palindex_p(srccell)){ // palette-indexed foreground
if(emit_fg_palindex(nc, out, srccell)){
return -1;
}
}else if(!cell_fg_default_p(srccell)){ // rgb foreground
}else if(!nccell_fg_default_p(srccell)){ // rgb foreground
nccell_fg_rgb8(srccell, &r, &g, &b);
if(nc->rstate.fgelidable && nc->rstate.lastr == r && nc->rstate.lastg == g && nc->rstate.lastb == b){
++nc->stats.fgelisions;
@ -987,11 +987,11 @@ rasterize_core(notcurses* nc, const ncpile* p, FILE* out, unsigned phase){
// * the previous was non-default, and matches what we have now, or
if(nobackground){
++nc->stats.bgelisions;
}else if(cell_bg_palindex_p(srccell)){ // palette-indexed background
}else if(nccell_bg_palindex_p(srccell)){ // palette-indexed background
if(emit_bg_palindex(nc, out, srccell)){
return -1;
}
}else if(!cell_bg_default_p(srccell)){ // rgb background
}else if(!nccell_bg_default_p(srccell)){ // rgb background
nccell_bg_rgb8(srccell, &br, &bg, &bb);
if(nc->rstate.bgelidable && nc->rstate.lastbr == br && nc->rstate.lastbg == bg && nc->rstate.lastbb == bb){
++nc->stats.bgelisions;

2
src/lib/terminfo.c
View File

@ -353,7 +353,7 @@ query_sixel(tinfo* ti, int fd){
// perhaps the most lackadaisical response is that of st, which returns a
// bare ESC[?6c (note no semicolon). this is equivalent to alacritty's
// return, both suggesting a VT102. alacritty's miraculous technicolor VT102
// can display sixel, but real VT102s can even reply to XTSMGRAPHICS, so we
// can display sixel, but real VT102s don't even reply to XTSMGRAPHICS, so we
// detect VT102 + TERM including alacritty, and special-case that.
// FIXME need unit tests on this
enum {

20
src/tests/cell.cpp
View File

@ -125,13 +125,13 @@ TEST_CASE("Cell") {
CHECK(0 > nccell_set_fg_alpha(&c, -1));
CHECK(0 > nccell_set_fg_alpha(&c, 4));
CHECK(0 == nccell_set_fg_alpha(&c, CELL_ALPHA_OPAQUE));
CHECK(cell_fg_default_p(&c));
CHECK(cell_bg_default_p(&c));
CHECK(CELL_ALPHA_OPAQUE == cell_fg_alpha(&c));
CHECK(nccell_fg_default_p(&c));
CHECK(nccell_bg_default_p(&c));
CHECK(CELL_ALPHA_OPAQUE == nccell_fg_alpha(&c));
CHECK(0 == nccell_set_fg_alpha(&c, CELL_ALPHA_HIGHCONTRAST));
CHECK(CELL_ALPHA_HIGHCONTRAST == cell_fg_alpha(&c));
CHECK(!cell_fg_default_p(&c));
CHECK(cell_bg_default_p(&c));
CHECK(CELL_ALPHA_HIGHCONTRAST == nccell_fg_alpha(&c));
CHECK(!nccell_fg_default_p(&c));
CHECK(nccell_bg_default_p(&c));
}
SUBCASE("CellSetBGAlpha"){
@ -139,12 +139,12 @@ TEST_CASE("Cell") {
CHECK(0 > nccell_set_bg_alpha(&c, -1));
CHECK(0 > nccell_set_bg_alpha(&c, 4));
CHECK(0 == nccell_set_bg_alpha(&c, CELL_ALPHA_OPAQUE));
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&c));
CHECK(CELL_ALPHA_OPAQUE == nccell_bg_alpha(&c));
CHECK(0 != nccell_set_bg_alpha(&c, CELL_ALPHA_HIGHCONTRAST));
CHECK(0 == nccell_set_bg_alpha(&c, CELL_ALPHA_TRANSPARENT));
CHECK(CELL_ALPHA_TRANSPARENT == cell_bg_alpha(&c));
CHECK(cell_fg_default_p(&c));
CHECK(!cell_bg_default_p(&c));
CHECK(CELL_ALPHA_TRANSPARENT == nccell_bg_alpha(&c));
CHECK(nccell_fg_default_p(&c));
CHECK(!nccell_bg_default_p(&c));
}
// white on a black background ought be unmolested for highcontrast

56
src/tests/palette.cpp
View File

@ -41,50 +41,50 @@ TEST_CASE("Palette256") {
// when we set a palette index, it ought change us from using default
SUBCASE("FAttributes") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(cell_fg_default_p(&c));
CHECK(nccell_fg_default_p(&c));
nccell_set_fg_alpha(&c, CELL_ALPHA_TRANSPARENT);
CHECK(0 == cell_set_fg_palindex(&c, 0x20));
CHECK(!cell_fg_default_p(&c));
CHECK(cell_fg_palindex_p(&c));
CHECK(CELL_ALPHA_OPAQUE == cell_fg_alpha(&c));
CHECK(0x20 == cell_fg_palindex(&c));
CHECK(0 == nccell_set_fg_palindex(&c, 0x20));
CHECK(!nccell_fg_default_p(&c));
CHECK(nccell_fg_palindex_p(&c));
CHECK(CELL_ALPHA_OPAQUE == nccell_fg_alpha(&c));
CHECK(0x20 == nccell_fg_palindex(&c));
}
SUBCASE("BAttributes") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(cell_bg_default_p(&c));
CHECK(nccell_bg_default_p(&c));
nccell_set_bg_alpha(&c, CELL_ALPHA_TRANSPARENT);
CHECK(0 == cell_set_bg_palindex(&c, 0x20));
CHECK(!cell_bg_default_p(&c));
CHECK(cell_bg_palindex_p(&c));
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&c));
CHECK(0x20 == cell_bg_palindex(&c));
CHECK(0 == nccell_set_bg_palindex(&c, 0x20));
CHECK(!nccell_bg_default_p(&c));
CHECK(nccell_bg_palindex_p(&c));
CHECK(CELL_ALPHA_OPAQUE == nccell_bg_alpha(&c));
CHECK(0x20 == nccell_bg_palindex(&c));
}
// write it to an ncplane, and verify attributes via reflection
SUBCASE("PutCAttrs") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(1 == nccell_load_char(n_, &c, 'X'));
CHECK(0 == cell_set_fg_palindex(&c, 0x20));
CHECK(0 == cell_set_bg_palindex(&c, 0x40));
CHECK(0 == nccell_set_fg_palindex(&c, 0x20));
CHECK(0 == nccell_set_bg_palindex(&c, 0x40));
CHECK(1 == ncplane_putc_yx(n_, 0, 0, &c));
nccell_release(n_, &c);
nccell r = CELL_TRIVIAL_INITIALIZER;
CHECK(0 < ncplane_at_yx_cell(n_, 0, 0, &r));
CHECK(cell_fg_palindex_p(&r));
CHECK(cell_bg_palindex_p(&r));
CHECK(CELL_ALPHA_OPAQUE == cell_fg_alpha(&r));
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
CHECK(0x20 == cell_fg_palindex(&r));
CHECK(0x40 == cell_bg_palindex(&r));
CHECK(nccell_fg_palindex_p(&r));
CHECK(nccell_bg_palindex_p(&r));
CHECK(CELL_ALPHA_OPAQUE == nccell_fg_alpha(&r));
CHECK(CELL_ALPHA_OPAQUE == nccell_bg_alpha(&r));
CHECK(0x20 == nccell_fg_palindex(&r));
CHECK(0x40 == nccell_bg_palindex(&r));
nccell_release(n_, &r);
}
SUBCASE("RenderCAttrs") {
nccell c = CELL_TRIVIAL_INITIALIZER;
nccell_load_char(n_, &c, 'X');
CHECK(0 == cell_set_fg_palindex(&c, 0x20));
CHECK(0 == cell_set_bg_palindex(&c, 0x40));
CHECK(0 == nccell_set_fg_palindex(&c, 0x20));
CHECK(0 == nccell_set_bg_palindex(&c, 0x40));
CHECK(0 == ncplane_set_fg_palindex(n_, 0x20));
CHECK(0 == ncplane_set_bg_palindex(n_, 0x40));
CHECK(0 < ncplane_putc_yx(n_, 0, 0, &c));
@ -92,12 +92,12 @@ TEST_CASE("Palette256") {
CHECK(0 == notcurses_render(nc_));
nccell r = CELL_TRIVIAL_INITIALIZER;
CHECK(nullptr != notcurses_at_yx(nc_, 0, 0, &r.stylemask, &r.channels));
CHECK(cell_fg_palindex_p(&r));
CHECK(cell_bg_palindex_p(&r));
CHECK(CELL_ALPHA_OPAQUE == cell_fg_alpha(&r));
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
CHECK(0x20 == cell_fg_palindex(&r));
CHECK(0x40 == cell_bg_palindex(&r));
CHECK(nccell_fg_palindex_p(&r));
CHECK(nccell_bg_palindex_p(&r));
CHECK(CELL_ALPHA_OPAQUE == nccell_fg_alpha(&r));
CHECK(CELL_ALPHA_OPAQUE == nccell_bg_alpha(&r));
CHECK(0x20 == nccell_fg_palindex(&r));
CHECK(0x40 == nccell_bg_palindex(&r));
nccell_release(n_, &r);
}

4
src/tests/plane.cpp
View File

@ -362,8 +362,8 @@ TEST_CASE("Plane") {
REQUIRE(0 < u2);
REQUIRE(strlen(w1) == u1);
REQUIRE(strlen(w2) == u2);
CHECK(ncstrwidth(w1) == 1 + cell_double_wide_p(&c1));
CHECK_FALSE(cell_double_wide_p(&c2));
CHECK(ncstrwidth(w1) == 1 + nccell_double_wide_p(&c1));
CHECK_FALSE(nccell_double_wide_p(&c2));
nccell_release(n_, &c1);
nccell_release(n_, &c2);
}

36
src/tests/wide.cpp
View File

@ -125,13 +125,13 @@ TEST_CASE("Wide") {
ncplane_at_yx_cell(n_, 0, 0, &c);
CHECK(0 == strcmp(nccell_extended_gcluster(n_, &c), FROG));
ncplane_at_yx_cell(n_, 0, 1, &c);
CHECK(ncstrwidth(FROG) == 1 + cell_double_wide_p(&c)); // should be wide
CHECK(ncstrwidth(FROG) == 1 + nccell_double_wide_p(&c)); // should be wide
ncplane_at_yx_cell(n_, 0, 2, &c);
CHECK(0 == strlen(nccell_extended_gcluster(n_, &c))); // should be nothing
ncplane_at_yx_cell(n_, 1, 0, &c);
CHECK(0 == strcmp(nccell_extended_gcluster(n_, &c), FROG));
ncplane_at_yx_cell(n_, 1, 1, &c);
CHECK(ncstrwidth(FROG) == 1 + cell_double_wide_p(&c)); //should be wide
CHECK(ncstrwidth(FROG) == 1 + nccell_double_wide_p(&c)); //should be wide
CHECK(0 == notcurses_render(nc_)); // should be nothing
}
@ -157,7 +157,7 @@ TEST_CASE("Wide") {
ncplane_at_yx_cell(n_, 0, 1, &c);
CHECK(0 == strcmp(nccell_extended_gcluster(n_, &c), SNAKE));
ncplane_at_yx_cell(n_, 0, 2, &c);
CHECK(ncstrwidth(SNAKE) == 1 + cell_double_wide_p(&c)); // should be wide
CHECK(ncstrwidth(SNAKE) == 1 + nccell_double_wide_p(&c)); // should be wide
CHECK(0 == notcurses_render(nc_));
}
@ -210,13 +210,13 @@ TEST_CASE("Wide") {
ncplane_at_yx_cell(n_, 0, 0, &c);
CHECK(0 == strcmp(nccell_extended_gcluster(n_, &c), SNAKE));
ncplane_at_yx_cell(n_, 0, 1, &c);
CHECK(ncstrwidth(SNAKE) == 1 + cell_double_wide_p(&c));
CHECK(ncstrwidth(SNAKE) == 1 + nccell_double_wide_p(&c));
ncplane_at_yx_cell(n_, 0, 2, &c);
CHECK(0 == strcmp(cc, nccell_extended_gcluster(n_, &c))); // should be 'X'
ncplane_at_yx_cell(n_, 0, 3, &c);
CHECK(0 == strcmp(nccell_extended_gcluster(n_, &c), SCORPION));
ncplane_at_yx_cell(n_, 0, 4, &c);
CHECK(ncstrwidth(SCORPION) == 1 + cell_double_wide_p(&c));
CHECK(ncstrwidth(SCORPION) == 1 + nccell_double_wide_p(&c));
CHECK(0 == notcurses_render(nc_));
}
@ -261,15 +261,15 @@ TEST_CASE("Wide") {
CHECK(0 <= ncplane_putstr(n_, "\u5f62\u5168"));
nccell c = CELL_TRIVIAL_INITIALIZER;
ncplane_at_yx_cell(n_, 0, 0, &c);
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
ncplane_at_yx_cell(n_, 0, 1, &c);
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
ncplane_at_yx_cell(n_, 0, 2, &c);
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
ncplane_at_yx_cell(n_, 0, 3, &c);
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
ncplane_at_yx_cell(n_, 0, 4, &c);
CHECK(!cell_double_wide_p(&c));
CHECK(!nccell_double_wide_p(&c));
CHECK(0 == notcurses_render(nc_));
auto egc = notcurses_at_yx(nc_, 0, 0, &c.stylemask, &c.channels);
REQUIRE(nullptr != egc);
@ -310,42 +310,42 @@ TEST_CASE("Wide") {
// should be wide char 1
CHECK(3 == ncplane_at_yx_cell(n_, 0, 0, &c));
CHECK(!strcmp("\xe5\x85\xa8", nccell_extended_gcluster(n_, &c)));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
egc = notcurses_at_yx(nc_, 0, 0, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp("\xe5\x85\xa8", egc));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
free(egc);
nccell_init(&c);
// should be wide char 1 right side
REQUIRE(0 == ncplane_at_yx_cell(n_, 0, 1, &c));
CHECK(!strcmp("", nccell_extended_gcluster(n_, &c)));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
egc = notcurses_at_yx(nc_, 0, 1, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp("", egc));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
free(egc);
nccell_init(&c);
// should be wide char 2
REQUIRE(3 == ncplane_at_yx_cell(n_, 0, 2, &c));
CHECK(!strcmp("\xe5\xbd\xa2", nccell_extended_gcluster(n_, &c)));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
egc = notcurses_at_yx(nc_, 0, 2, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp("\xe5\xbd\xa2", egc));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
free(egc);
nccell_init(&c);
// should be wide char 2 right side
CHECK(0 == ncplane_at_yx_cell(n_, 0, 3, &c));
CHECK(!strcmp("", nccell_extended_gcluster(n_, &c)));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
egc = notcurses_at_yx(nc_, 0, 3, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp("", egc));
CHECK(cell_double_wide_p(&c));
CHECK(nccell_double_wide_p(&c));
free(egc);
nccell_init(&c);