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

cell_release -> nccell_release

Browse Source
This commit is contained in:
nick black 2021-04-10 09:09:56 -04:00
parent 9dbcef9969
commit d504e972cc
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
29 changed files with 138 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
NEWS.md
View File

@ -12,6 +12,9 @@ rearrangements of Notcurses.
size of the plane and cells in pixels, as well as the maximum bitmap
size that can be displayed.
* added new function `ncdirect_stream()`, which does what you'd think.
* `cell_release()` and `cell_duplicate()` have been migrated to
`nccell_release()` and `nccell_duplicate()`, respectively. The former
forms have been deprecated, and will be removed in API3.
* 2.2.5 (2021-04-04)
* Bugfix release, no user-visible changes.

6
include/ncpp/Plane.hh
View File

@ -1088,17 +1088,17 @@ namespace ncpp
void release (Cell &cell) const noexcept
{
cell_release (plane, cell);
nccell_release (plane, cell);
}
int duplicate (Cell &target, Cell &source) const NOEXCEPT_MAYBE
{
return error_guard<int> (cell_duplicate (plane, target, source), -1);
return error_guard<int> (nccell_duplicate (plane, target, source), -1);
}
int duplicate (Cell &target, Cell const& source) const NOEXCEPT_MAYBE
{
return error_guard<int> (cell_duplicate (plane, target, source), -1);
return error_guard<int> (nccell_duplicate (plane, target, source), -1);
}
int duplicate (Cell &target, Cell *source) const

50
include/notcurses/notcurses.h
View File

@ -662,10 +662,20 @@ cell_prime(struct ncplane* n, nccell* c, const char* gcluster,
// Duplicate 'c' into 'targ'; both must be/will be bound to 'n'. Returns -1 on
// failure, and 0 on success.
API int cell_duplicate(struct ncplane* n, nccell* targ, const nccell* c);
API int nccell_duplicate(struct ncplane* n, nccell* targ, const nccell* c);
__attribute__ ((deprecated)) static inline int
cell_duplicate(struct ncplane* n, nccell* targ, const nccell* c){
return nccell_duplicate(n, targ, c);
}
// Release resources held by the nccell 'c'.
API void cell_release(struct ncplane* n, nccell* c);
API void nccell_release(struct ncplane* n, nccell* c);
__attribute__ ((deprecated)) static inline void
cell_release(struct ncplane* n, nccell* c){
nccell_release(n, c);
}
#define NCSTYLE_MASK 0x03ffu
#define NCSTYLE_STANDOUT 0x0080u
@ -2263,7 +2273,7 @@ API void ncfadectx_free(struct ncfadectx* nctx);
// load up six cells with the EGCs necessary to draw a box. returns 0 on
// success, -1 on error. on error, any cells this function might
// have loaded before the error are cell_release()d. There must be at least
// have loaded before the error are nccell_release()d. There must be at least
// six EGCs in gcluster.
static inline int
cells_load_box(struct ncplane* n, uint32_t styles, uint64_t channels,
@ -2278,15 +2288,15 @@ cells_load_box(struct ncplane* n, uint32_t styles, uint64_t channels,
if(cell_prime(n, vl, gclusters + ulen, styles, channels) > 0){
return 0;
}
cell_release(n, hl);
nccell_release(n, hl);
}
cell_release(n, lr);
nccell_release(n, lr);
}
cell_release(n, ll);
nccell_release(n, ll);
}
cell_release(n, ur);
nccell_release(n, ur);
}
cell_release(n, ul);
nccell_release(n, ul);
}
return -1;
}
@ -2305,9 +2315,9 @@ ncplane_rounded_box(struct ncplane* n, uint32_t styles, uint64_t channels,
if((ret = cells_rounded_box(n, styles, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
}
cell_release(n, &ul); cell_release(n, &ur);
cell_release(n, &ll); cell_release(n, &lr);
cell_release(n, &hl); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur);
nccell_release(n, &ll); nccell_release(n, &lr);
nccell_release(n, &hl); nccell_release(n, &vl);
return ret;
}
@ -2329,9 +2339,9 @@ ncplane_perimeter_rounded(struct ncplane* n, uint32_t stylemask,
return -1;
}
int r = ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, ctlword);
cell_release(n, &ul); cell_release(n, &ur);
cell_release(n, &ll); cell_release(n, &lr);
cell_release(n, &hl); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur);
nccell_release(n, &ll); nccell_release(n, &lr);
nccell_release(n, &hl); nccell_release(n, &vl);
return r;
}
@ -2358,9 +2368,9 @@ ncplane_double_box(struct ncplane* n, uint32_t styles, uint64_t channels,
if((ret = cells_double_box(n, styles, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
}
cell_release(n, &ul); cell_release(n, &ur);
cell_release(n, &ll); cell_release(n, &lr);
cell_release(n, &hl); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur);
nccell_release(n, &ll); nccell_release(n, &lr);
nccell_release(n, &hl); nccell_release(n, &vl);
return ret;
}
@ -2382,9 +2392,9 @@ ncplane_perimeter_double(struct ncplane* n, uint32_t stylemask,
return -1;
}
int r = ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, ctlword);
cell_release(n, &ul); cell_release(n, &ur);
cell_release(n, &ll); cell_release(n, &lr);
cell_release(n, &hl); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur);
nccell_release(n, &ll); nccell_release(n, &lr);
nccell_release(n, &hl); nccell_release(n, &vl);
return r;
}

14
src/demo/boxdemo.c
View File

@ -95,7 +95,7 @@ int box_demo(struct notcurses* nc){
nccell c = CELL_CHAR_INITIALIZER(' ');
cell_set_bg_default(&c);
ncplane_set_base_cell(n, &c);
cell_release(n, &c);
nccell_release(n, &c);
ncplane_set_fg_rgb8(n, 180, 40, 180);
ncplane_set_bg_default(n);
if(notcurses_canutf8(nc)){
@ -177,11 +177,11 @@ int box_demo(struct notcurses* nc){
DEMO_RENDER(nc);
nanosleep(&iterdelay, NULL);
}
cell_release(n, &ul);
cell_release(n, &ur);
cell_release(n, &ll);
cell_release(n, &lr);
cell_release(n, &hl);
cell_release(n, &vl);
nccell_release(n, &ul);
nccell_release(n, &ur);
nccell_release(n, &ll);
nccell_release(n, &lr);
nccell_release(n, &hl);
nccell_release(n, &vl);
return 0;
}

2
src/demo/demo.c
View File

@ -222,7 +222,7 @@ ext_demos(struct notcurses* nc, const char* spec){
cell_set_fg_rgb8(&c, 0, 0, 0);
cell_set_bg_rgb8(&c, 0, 0, 0);
ncplane_set_base_cell(n, &c);
cell_release(n, &c);
nccell_release(n, &c);
hud_schedule(demos[idx].name);
ret = demos[idx].fxn(nc);

2
src/demo/eagle.c
View File

@ -118,7 +118,7 @@ draw_eagle(struct ncplane* n, const char* sprite){
cell_set_fg_alpha(&bgc, CELL_ALPHA_TRANSPARENT);
cell_set_bg_alpha(&bgc, CELL_ALPHA_TRANSPARENT);
ncplane_set_base_cell(n, &bgc);
cell_release(n, &bgc);
nccell_release(n, &bgc);
size_t s;
int sbytes;
for(s = 0 ; sprite[s] ; ++s){

4
src/demo/fallin.c
View File

@ -163,13 +163,13 @@ int fallin_demo(struct notcurses* nc){
// 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){
cell_release(n, &c);
nccell_release(n, &c);
goto err;
}
}
}
usemap[usey * dimx + usex] = true;
cell_release(n, &c);
nccell_release(n, &c);
}
}
// shuffle the new ncplane into the array

18
src/demo/grid.c
View File

@ -23,15 +23,15 @@ release_cells(struct ncplane* n,
nccell* ul, nccell* uc, nccell* ur,
nccell* cl, nccell* cc, nccell* cr,
nccell* ll, nccell* lc, nccell* lr){
cell_release(n, ul);
cell_release(n, uc);
cell_release(n, ur);
cell_release(n, cl);
cell_release(n, cc);
cell_release(n, cr);
cell_release(n, ll);
cell_release(n, lc);
cell_release(n, lr);
nccell_release(n, ul);
nccell_release(n, uc);
nccell_release(n, ur);
nccell_release(n, cl);
nccell_release(n, cc);
nccell_release(n, cr);
nccell_release(n, ll);
nccell_release(n, lc);
nccell_release(n, lr);
}
static int

2
src/demo/highcon.c
View File

@ -132,6 +132,6 @@ int highcontrast_demo(struct notcurses* nc){
ret = 0;
err:
cell_release(n, &c);
nccell_release(n, &c);
return ret;
}

20
src/demo/hud.c
View File

@ -170,13 +170,13 @@ about_toggle(struct notcurses* nc){
channels_set_bg_rgb(&channels, 0);
if(cells_rounded_box(n, NCSTYLE_NONE, channels, &ul, &ur, &ll, &lr, &hl, &vl) == 0){
if(ncplane_perimeter(n, &ul, &ur, &ll, &lr, &hl, &vl, 0) == 0){
cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
about = n;
return;
}
cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
}
}
ncplane_destroy(n);
@ -340,12 +340,12 @@ hud_refresh(struct ncplane* n){
cell_set_bg_alpha(&hl, CELL_ALPHA_BLEND);
cell_set_bg_alpha(&vl, CELL_ALPHA_BLEND);
if(ncplane_perimeter(n, &ul, &ur, &ll, &lr, &hl, &vl, 0)){
cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
return -1;
}
cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
return 0;
}
@ -372,7 +372,7 @@ hud_print_finished(elem* list){
ncplane_set_bg_alpha(hud, CELL_ALPHA_BLEND);
ncplane_set_fg_rgb(hud, 0xffffff);
ncplane_set_fg_alpha(hud, CELL_ALPHA_OPAQUE);
cell_release(hud, &c);
nccell_release(hud, &c);
if(ncplane_printf_yx(hud, line, 1, "%d", e->frames) < 0){
return -1;
}
@ -587,7 +587,7 @@ int demo_render(struct notcurses* nc){
ncplane_set_bg_alpha(hud, CELL_ALPHA_BLEND);
ncplane_set_fg_rgb(hud, 0x80d0ff);
ncplane_set_fg_alpha(hud, CELL_ALPHA_OPAQUE);
cell_release(hud, &c);
nccell_release(hud, &c);
ncplane_on_styles(hud, NCSTYLE_BOLD);
if(ncplane_printf_yx(hud, 1, 1, "%d", elems->frames) < 0){
return -1;

6
src/demo/intro.c
View File

@ -164,9 +164,9 @@ int intro(struct notcurses* nc){
NCBOXGRAD_TOP | NCBOXGRAD_BOTTOM | NCBOXGRAD_RIGHT | NCBOXGRAD_LEFT)){
return -1;
}
cell_release(ncp, &ul); cell_release(ncp, &ur);
cell_release(ncp, &ll); cell_release(ncp, &lr);
cell_release(ncp, &hl); cell_release(ncp, &vl);
nccell_release(ncp, &ul); nccell_release(ncp, &ur);
nccell_release(ncp, &ll); nccell_release(ncp, &lr);
nccell_release(ncp, &hl); nccell_release(ncp, &vl);
const char s1[] = " Die Welt ist alles, was der Fall ist. ";
const char str[] = " Wovon man nicht sprechen kann, darüber muss man schweigen. ";
if(ncplane_set_fg_rgb8(ncp, 192, 192, 192)){

2
src/demo/jungle.c
View File

@ -26640,7 +26640,7 @@ int jungle_demo(struct notcurses* nc){
}
}
}
cell_release(n, &c);
nccell_release(n, &c);
free(buf);
int iter = 0;
int64_t iterns = NANOSECS_IN_SEC / 30;

2
src/demo/mojibake.c
View File

@ -3543,7 +3543,7 @@ makegroup(struct ncplane* title, int y, const char* emoji, const char* name){
break;
}
int w = ncplane_putc_yx(n, y, x, &c);
cell_release(n, &c);
nccell_release(n, &c);
if(w < 0){
ncplane_destroy(n);
return NULL;

4
src/demo/normal.c
View File

@ -172,7 +172,7 @@ int normal_demo(struct notcurses* nc){
cell_set_fg_rgb8(&c, 0x0, 0x0, 0x0);
cell_set_bg_rgb8(&c, 0x0, 0x0, 0x0);
ncplane_set_base_cell(nstd, &c);
cell_release(nstd, &c);
nccell_release(nstd, &c);
struct ncplane* n = NULL;
struct ncvisual_options vopts = {
.n = nstd,
@ -250,7 +250,7 @@ int normal_demo(struct notcurses* nc){
cell_set_fg_rgb8(&c, 0, 0, 0);
cell_set_bg_rgb8(&c, 0, 0, 0);
ncplane_set_base_cell(nstd, &c);
cell_release(nstd, &c);
nccell_release(nstd, &c);
r = rotate_visual(nc, n, dy, dx);
return r;

2
src/demo/reel.c
View File

@ -81,7 +81,7 @@ tabletdraw(struct ncplane* w, int maxy, tabletctx* tctx, unsigned rgb){
return -1;
}
}
cell_release(w, &c);
nccell_release(w, &c);
}
return y;
}

4
src/demo/unicodeblocks.c
View File

@ -97,8 +97,8 @@ draw_block(struct ncplane* nn, uint32_t blockstart){
if(ncplane_box_sized(nn, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, control)){
return -1;
}
cell_release(nn, &ul); cell_release(nn, &ur); cell_release(nn, &hl);
cell_release(nn, &ll); cell_release(nn, &lr); cell_release(nn, &vl);
nccell_release(nn, &ul); nccell_release(nn, &ur); nccell_release(nn, &hl);
nccell_release(nn, &ll); nccell_release(nn, &lr); nccell_release(nn, &vl);
int chunk;
for(chunk = 0 ; chunk < BLOCKSIZE / CHUNKSIZE ; ++chunk){
int z;

4
src/demo/whiteout.c
View File

@ -64,7 +64,7 @@ lighten(struct ncplane* n, nccell* c, int distance, int y, int x){
static inline int
lightup_surrounding_cells(struct ncplane* n, nccell* lightup, int y, int x){
lighten(n, lightup, 0, y, x);
cell_release(n, lightup);
nccell_release(n, lightup);
return 0;
}
@ -199,7 +199,7 @@ message(struct ncplane* n, int maxy, int maxx, int num, int total,
ncplane_putegc_yx(n, 0, 3, "╔", NULL);
cell_load(n, &hl, "═");
ncplane_hline(n, &hl, 20 - 4 - 1);
cell_release(n, &hl);
nccell_release(n, &hl);
ncplane_putegc_yx(n, 0, 19, "╗", NULL);
ncplane_putegc_yx(n, 1, 19, "║", NULL);
ncplane_putegc_yx(n, 2, 19, "╨", NULL);

6
src/lib/fill.c
View File

@ -33,7 +33,7 @@ ncplane_polyfill_recurse(ncplane* n, int y, int x, const nccell* c, const char*
if(strcmp(glust, filltarg)){
return 0;
}
if(cell_duplicate(n, cur, c) < 0){
if(nccell_duplicate(n, cur, c) < 0){
return -1;
}
int r, ret = 1;
@ -399,7 +399,7 @@ rotate_2x1_cw(ncplane* src, ncplane* dst, int srcy, int srcx, int dsty, int dstx
return -1;
}
if(ncplane_at_yx_cell(src, srcy, srcx + 1, &c2) < 0){
cell_release(src, &c1);
nccell_release(src, &c1);
return -1;
}
// there can be at most 4 colors and 4 transparencies:
@ -440,7 +440,7 @@ rotate_2x1_ccw(ncplane* src, ncplane* dst, int srcy, int srcx, int dsty, int dst
return -1;
}
if(ncplane_at_yx_cell(src, srcy, srcx + 1, &c2) < 0){
cell_release(src, &c1);
nccell_release(src, &c1);
return -1;
}
uint32_t c1b = cell_bchannel_common(&c1);

6
src/lib/menu.c
View File

@ -307,7 +307,7 @@ write_header(ncmenu* ncm){
if(ncplane_putc_yx(ncm->ncp, ypos, xoff + ncm->sections[i].shortcut_offset, &cl) < 0){
return -1;
}
cell_release(ncm->ncp, &cl);
nccell_release(ncm->ncp, &cl);
}
xoff += ncstrwidth(ncm->sections[i].name);
}
@ -386,7 +386,7 @@ ncmenu* ncmenu_create(ncplane* n, const ncmenu_options* opts){
cell_set_fg_alpha(&c, CELL_ALPHA_TRANSPARENT);
cell_set_bg_alpha(&c, CELL_ALPHA_TRANSPARENT);
ncplane_set_base_cell(ret->ncp, &c);
cell_release(ret->ncp, &c);
nccell_release(ret->ncp, &c);
if(write_header(ret) == 0){
return ret;
}
@ -487,7 +487,7 @@ int ncmenu_unroll(ncmenu* n, int sectionidx){
if(ncplane_putc_yx(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
return -1;
}
cell_release(n->ncp, &cl);
nccell_release(n->ncp, &cl);
}
}else{
n->ncp->channels = n->headerchannels;

22
src/lib/notcurses.c
View File

@ -161,7 +161,7 @@ int ncplane_at_yx_cell(ncplane* n, int y, int x, nccell* c){
if(y < n->leny && x < n->lenx){
if(y >= 0 && x >= 0){
nccell* targ = ncplane_cell_ref_yx(n, y, x);
if(cell_duplicate(n, c, targ) == 0){
if(nccell_duplicate(n, c, targ) == 0){
return strlen(cell_extended_gcluster(n, targ));
}
}
@ -1270,7 +1270,7 @@ int ncplane_set_base_cell(ncplane* ncp, const nccell* c){
if(cell_wide_right_p(c)){
return -1;
}
return cell_duplicate(ncp, &ncp->basecell, c);
return nccell_duplicate(ncp, &ncp->basecell, c);
}
int ncplane_set_base(ncplane* ncp, const char* egc, uint32_t stylemask, uint64_t channels){
@ -1278,7 +1278,7 @@ int ncplane_set_base(ncplane* ncp, const char* egc, uint32_t stylemask, uint64_t
}
int ncplane_base(ncplane* ncp, nccell* c){
return cell_duplicate(ncp, c, &ncp->basecell);
return nccell_duplicate(ncp, c, &ncp->basecell);
}
const char* cell_extended_gcluster(const ncplane* n, const nccell* c){
@ -1390,7 +1390,7 @@ void ncplane_cursor_yx(const ncplane* n, int* y, int* x){
static inline void
cell_obliterate(ncplane* n, nccell* c){
cell_release(n, c);
nccell_release(n, c);
cell_init(c);
}
@ -1401,7 +1401,7 @@ void scroll_down(ncplane* n){
n->logrow = (n->logrow + 1) % n->leny;
nccell* row = n->fb + nfbcellidx(n, n->y, 0);
for(int clearx = 0 ; clearx < n->lenx ; ++clearx){
cell_release(n, &row[clearx]);
nccell_release(n, &row[clearx]);
}
memset(row, 0, sizeof(*row) * n->lenx);
}else{
@ -1477,7 +1477,7 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
if(cell_wide_left_p(candidate)){
cell_obliterate(n, &n->fb[nfbcellidx(n, n->y, n->x + 1)]);
}
cell_release(n, candidate);
nccell_release(n, candidate);
candidate->channels = targ->channels;
candidate->stylemask = targ->stylemask;
candidate->width = targ->width;
@ -1685,7 +1685,7 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len,
int deltbb = bb2 - bb1;
int ret;
nccell dupc = CELL_TRIVIAL_INITIALIZER;
if(cell_duplicate(n, &dupc, c) < 0){
if(nccell_duplicate(n, &dupc, c) < 0){
return -1;
}
bool fgdef = false, bgdef = false;
@ -1712,7 +1712,7 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len,
break;
}
}
cell_release(n, &dupc);
nccell_release(n, &dupc);
return ret;
}
@ -1738,7 +1738,7 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len,
int ret, ypos, xpos;
ncplane_cursor_yx(n, &ypos, &xpos);
nccell dupc = CELL_TRIVIAL_INITIALIZER;
if(cell_duplicate(n, &dupc, c) < 0){
if(nccell_duplicate(n, &dupc, c) < 0){
return -1;
}
bool fgdef = false, bgdef = false;
@ -1768,7 +1768,7 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len,
break;
}
}
cell_release(n, &dupc);
nccell_release(n, &dupc);
return ret;
}
@ -1954,7 +1954,7 @@ void ncplane_erase(ncplane* n){
if(n->sprite){
sprixel_hide(n->sprite);
}
// we must preserve the background, but a pure cell_duplicate() would be
// we must preserve the background, but a pure nccell_duplicate() would be
// wiped out by the egcpool_dump(). do a duplication (to get the stylemask
// and channels), and then reload.
char* egc = cell_strdup(n, &n->basecell);

4
src/lib/progbar.c
View File

@ -151,13 +151,13 @@ progbar_redraw(ncprogbar* n){
if(horizontal){
for(int freepos = 0 ; freepos < dimy ; ++freepos){
nccell* c = ncplane_cell_ref_yx(ncp, freepos, pos);
cell_release(ncp, c);
nccell_release(ncp, c);
cell_init(c);
}
}else{
for(int freepos = 0 ; freepos < dimx ; ++freepos){
nccell* c = ncplane_cell_ref_yx(ncp, pos, freepos);
cell_release(ncp, c);
nccell_release(ncp, c);
cell_init(c);
}
}

4
src/lib/reel.c
View File

@ -161,8 +161,8 @@ draw_borders(ncplane* n, unsigned mask, uint64_t channel, direction_e direction)
ncplane_putc(n, &lr);
}
}
cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
return ret;
}

4
src/lib/render.c
View File

@ -171,12 +171,12 @@ update_raster_stats(const struct timespec* time1, const struct timespec* time0,
}
}
void cell_release(ncplane* n, nccell* c){
void nccell_release(ncplane* n, nccell* c){
pool_release(&n->pool, c);
}
// Duplicate one cell onto another when they share a plane. Convenience wrapper.
int cell_duplicate(ncplane* n, nccell* targ, const nccell* c){
int nccell_duplicate(ncplane* n, nccell* targ, const nccell* c){
if(cell_duplicate_far(&n->pool, targ, n, c) < 0){
logerror(ncplane_notcurses(n), "Failed duplicating cell\n");
return -1;

8
src/tests/cell.cpp
View File

@ -39,7 +39,7 @@ TEST_CASE("Cell") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(1 == cell_load(n_, &c, " "));
CHECK(cell_simple_p(&c));
cell_release(n_, &c);
nccell_release(n_, &c);
}
SUBCASE("MultibyteWidth") {
@ -75,7 +75,7 @@ TEST_CASE("Cell") {
CHECK(1 == cell_load(n_, &c, "i"));
cell_set_fg_rgb8(&c, 255, 255, 255);
ncplane_set_base_cell(n_, &c);
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
cell_off_styles(&c, NCSTYLE_ITALIC);
}
@ -88,7 +88,7 @@ TEST_CASE("Cell") {
CHECK(1 == cell_load(n_, &c, "b"));
cell_set_fg_rgb8(&c, 255, 255, 255);
ncplane_set_base_cell(n_, &c);
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
cell_off_styles(&c, NCSTYLE_BOLD);
}
@ -101,7 +101,7 @@ TEST_CASE("Cell") {
CHECK(1 == cell_load(n_, &c, "u"));
cell_set_fg_rgb8(&c, 255, 255, 255);
ncplane_set_base_cell(n_, &c);
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
cell_off_styles(&c, NCSTYLE_UNDERLINE);
}

4
src/tests/fills.cpp
View File

@ -568,9 +568,9 @@ TEST_CASE("Fills") {
nccell c2 = CELL_TRIVIAL_INITIALIZER;
CHECK(0 < ncplane_at_yx_cell(p2, y - 1, x - 1, &c2));
CHECK(0 == cellcmp(p1, &c1, p2, &c2));
cell_release(p2, &c2);
nccell_release(p2, &c2);
}
cell_release(p1, &c1);
nccell_release(p1, &c1);
}
}
ncplane_destroy(p1);

8
src/tests/palette.cpp
View File

@ -68,7 +68,7 @@ TEST_CASE("Palette256") {
CHECK(0 == cell_set_fg_palindex(&c, 0x20));
CHECK(0 == cell_set_bg_palindex(&c, 0x40));
CHECK(1 == ncplane_putc_yx(n_, 0, 0, &c));
cell_release(n_, &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));
@ -77,7 +77,7 @@ TEST_CASE("Palette256") {
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
CHECK(0x20 == cell_fg_palindex(&r));
CHECK(0x40 == cell_bg_palindex(&r));
cell_release(n_, &r);
nccell_release(n_, &r);
}
SUBCASE("RenderCAttrs") {
@ -88,7 +88,7 @@ TEST_CASE("Palette256") {
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));
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
nccell r = CELL_TRIVIAL_INITIALIZER;
CHECK(nullptr != notcurses_at_yx(nc_, 0, 0, &r.stylemask, &r.channels));
@ -98,7 +98,7 @@ TEST_CASE("Palette256") {
CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
CHECK(0x20 == cell_fg_palindex(&r));
CHECK(0x40 == cell_bg_palindex(&r));
cell_release(n_, &r);
nccell_release(n_, &r);
}
// common teardown

36
src/tests/plane.cpp
View File

@ -183,7 +183,7 @@ TEST_CASE("Plane") {
CHECK(yidx == posy);
CHECK(x - 1 == posx);
}
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
}
@ -202,7 +202,7 @@ TEST_CASE("Plane") {
CHECK(y - 2 == posy);
CHECK(xidx == posx - 1);
}
cell_release(n_, &c);
nccell_release(n_, &c);
CHECK(0 == notcurses_render(nc_));
}
@ -319,9 +319,9 @@ TEST_CASE("Plane") {
REQUIRE(2 == u1);
REQUIRE(3 == u2);
REQUIRE(1 == u3);
cell_release(n_, &cell1);
cell_release(n_, &cell2);
cell_release(n_, &cell3);
nccell_release(n_, &cell1);
nccell_release(n_, &cell2);
nccell_release(n_, &cell3);
}
SUBCASE("CellDuplicateCombining") {
@ -340,15 +340,15 @@ TEST_CASE("Plane") {
nccell cell4 = CELL_TRIVIAL_INITIALIZER;
nccell cell5 = CELL_TRIVIAL_INITIALIZER;
nccell cell6 = CELL_TRIVIAL_INITIALIZER;
CHECK(0 == cell_duplicate(n_, &cell4, &cell1));
CHECK(0 == cell_duplicate(n_, &cell5, &cell2));
CHECK(0 == cell_duplicate(n_, &cell6, &cell3));
cell_release(n_, &cell1);
cell_release(n_, &cell2);
cell_release(n_, &cell3);
cell_release(n_, &cell4);
cell_release(n_, &cell5);
cell_release(n_, &cell6);
CHECK(0 == nccell_duplicate(n_, &cell4, &cell1));
CHECK(0 == nccell_duplicate(n_, &cell5, &cell2));
CHECK(0 == nccell_duplicate(n_, &cell6, &cell3));
nccell_release(n_, &cell1);
nccell_release(n_, &cell2);
nccell_release(n_, &cell3);
nccell_release(n_, &cell4);
nccell_release(n_, &cell5);
nccell_release(n_, &cell6);
}
SUBCASE("CellMultiColumn") {
@ -364,8 +364,8 @@ TEST_CASE("Plane") {
REQUIRE(strlen(w2) == u2);
CHECK(ncstrwidth(w1) == 1 + cell_double_wide_p(&c1));
CHECK_FALSE(cell_double_wide_p(&c2));
cell_release(n_, &c1);
cell_release(n_, &c2);
nccell_release(n_, &c1);
nccell_release(n_, &c2);
}
// verifies that the initial userptr is what we provided, that it is a nullptr
@ -558,7 +558,7 @@ TEST_CASE("Plane") {
CHECK(0 == testcell.gcluster);
CHECK(0 == testcell.stylemask);
CHECK(0 == testcell.channels);
cell_release(n_, &testcell);
nccell_release(n_, &testcell);
int dimy, dimx;
ncplane_dim_yx(n_, &dimy, &dimx);
REQUIRE(0 == ncplane_cursor_move_yx(n_, 1, dimx - strlen(STR2)));
@ -596,7 +596,7 @@ TEST_CASE("Plane") {
CHECK(0 == testcell.gcluster);
CHECK(0 == testcell.stylemask);
CHECK(0 == testcell.channels);
cell_release(n_, &testcell);
nccell_release(n_, &testcell);
int dimy, dimx;
ncplane_dim_yx(n_, &dimy, &dimx);
REQUIRE(0 == ncplane_cursor_move_yx(n_, 1, dimx - mbstowcs(nullptr, STR2, 0)));

6
src/tests/rotate.cpp
View File

@ -78,9 +78,9 @@ TEST_CASE("Rotate") {
CHECK(-1 < cell_prime(testn, &vl, "█", 0, lr));
CHECK(0 == ncplane_perimeter(testn, &tl, &tr, &bl, &br, &hl, &vl, 0));
RotateCW(nc_, testn);
cell_release(testn, &tl); cell_release(testn, &tr);
cell_release(testn, &bl); cell_release(testn, &br);
cell_release(testn, &hl); cell_release(testn, &vl);
nccell_release(testn, &tl); nccell_release(testn, &tr);
nccell_release(testn, &bl); nccell_release(testn, &br);
nccell_release(testn, &hl); nccell_release(testn, &vl);
CHECK(0 == ncplane_destroy(testn));
}

10
src/tests/wide.cpp
View File

@ -121,7 +121,7 @@ TEST_CASE("Wide") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(0 < cell_load(n_, &c, w));
CHECK(0 < ncplane_putc_yx(n_, 1, 0, &c));
cell_release(n_, &c);
nccell_release(n_, &c);
ncplane_at_yx_cell(n_, 0, 0, &c);
CHECK(0 == strcmp(cell_extended_gcluster(n_, &c), FROG));
ncplane_at_yx_cell(n_, 0, 1, &c);
@ -242,14 +242,14 @@ TEST_CASE("Wide") {
nccell c = CELL_TRIVIAL_INITIALIZER;
CHECK(0 < ncplane_at_yx_cell(ncp, 1, 0, &c));
CHECK(!strcmp(cell_extended_gcluster(ncp, &c), "│"));
cell_release(ncp, &c);
nccell_release(ncp, &c);
char* egc = notcurses_at_yx(nc_, 1, 0, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp(egc, "│"));
free(egc);
CHECK(0 < ncplane_at_yx_cell(ncp, 1, 3, &c));
CHECK(!strcmp(cell_extended_gcluster(ncp, &c), "│"));
cell_release(ncp, &c);
nccell_release(ncp, &c);
egc = notcurses_at_yx(nc_, 1, 3, &c.stylemask, &c.channels);
REQUIRE(egc);
CHECK(!strcmp(egc, "│"));
@ -436,8 +436,8 @@ TEST_CASE("Wide") {
CHECK(0 == ncplane_at_yx_cell(n_, 1, 2, &cr));
CHECK(cell_simple_p(&cr));
CHECK(0 == cr.gcluster);
cell_release(n_, &cl);
cell_release(n_, &cr);
nccell_release(n_, &cl);
nccell_release(n_, &cr);
CHECK(chanright == chanleft);
ncplane_destroy(p);
}