diff --git a/USAGE.md b/USAGE.md index 540f1fde0..7840e9915 100644 --- a/USAGE.md +++ b/USAGE.md @@ -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); } diff --git a/doc/man/man3/notcurses_cell.3.md b/doc/man/man3/notcurses_cell.3.md index 0b1ca125b..3bb83b198 100644 --- a/doc/man/man3/notcurses_cell.3.md +++ b/doc/man/man3/notcurses_cell.3.md @@ -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 diff --git a/include/ncpp/Cell.hh b/include/ncpp/Cell.hh index b3a63a50c..457dcd297 100644 --- a/include/ncpp/Cell.hh +++ b/include/ncpp/Cell.hh @@ -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: diff --git a/include/notcurses/notcurses.h b/include/notcurses/notcurses.h index f70942206..0e6f7a3b4 100644 --- a/include/notcurses/notcurses.h +++ b/include/notcurses/notcurses.h @@ -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){ diff --git a/src/demo/fallin.c b/src/demo/fallin.c index ecb18d455..86e022c56 100644 --- a/src/demo/fallin.c +++ b/src/demo/fallin.c @@ -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; } diff --git a/src/demo/jungle.c b/src/demo/jungle.c index ab6618a86..ba3417537 100644 --- a/src/demo/jungle.c +++ b/src/demo/jungle.c @@ -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; } } diff --git a/src/demo/whiteout.c b/src/demo/whiteout.c index 81a90b1ed..8720ccda4 100644 --- a/src/demo/whiteout.c +++ b/src/demo/whiteout.c @@ -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; diff --git a/src/lib/fade.c b/src/lib/fade.c index eb7b12c7e..eb85d9ed9 100644 --- a/src/lib/fade.c +++ b/src/lib/fade.c @@ -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; diff --git a/src/lib/notcurses.c b/src/lib/notcurses.c index ef65ddf97..376e00334 100644 --- a/src/lib/notcurses.c +++ b/src/lib/notcurses.c @@ -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)); } diff --git a/src/lib/render.c b/src/lib/render.c index 9f0b7215b..f6582da49 100644 --- a/src/lib/render.c +++ b/src/lib/render.c @@ -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; diff --git a/src/lib/terminfo.c b/src/lib/terminfo.c index 198b18ecd..016dea7cb 100644 --- a/src/lib/terminfo.c +++ b/src/lib/terminfo.c @@ -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 { diff --git a/src/tests/cell.cpp b/src/tests/cell.cpp index d7ea49daf..cf3a7ed90 100644 --- a/src/tests/cell.cpp +++ b/src/tests/cell.cpp @@ -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 diff --git a/src/tests/palette.cpp b/src/tests/palette.cpp index 83702d0eb..ba2ca4c1f 100644 --- a/src/tests/palette.cpp +++ b/src/tests/palette.cpp @@ -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); } diff --git a/src/tests/plane.cpp b/src/tests/plane.cpp index 4054378a5..c73b86fe7 100644 --- a/src/tests/plane.cpp +++ b/src/tests/plane.cpp @@ -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); } diff --git a/src/tests/wide.cpp b/src/tests/wide.cpp index 29b9260ae..e2b5a0cd2 100644 --- a/src/tests/wide.cpp +++ b/src/tests/wide.cpp @@ -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);