From 3eb004b61d8ce9836a2e5c1d819006ca3af27ea9 Mon Sep 17 00:00:00 2001 From: nick black Date: Thu, 29 Apr 2021 01:18:37 -0400 Subject: [PATCH] s/channels/ncchannels/g #1570 --- NEWS.md | 3 + USAGE.md | 126 +++++----- doc/man/man3/notcurses_channels.3.md | 40 ++-- include/notcurses/notcurses.h | 340 +++++++++++++++++++-------- src/demo/animate.c | 4 +- src/demo/demo.c | 4 +- src/demo/hud.c | 58 ++--- src/demo/intro.c | 8 +- src/demo/keller.c | 4 +- src/demo/luigi.c | 8 +- src/demo/mojibake.c | 2 +- src/demo/normal.c | 8 +- src/demo/outro.c | 6 +- src/demo/reel.c | 16 +- src/demo/sliding.c | 4 +- src/demo/trans.c | 4 +- src/demo/unicodeblocks.c | 10 +- src/demo/view.c | 6 +- src/demo/whiteout.c | 14 +- src/demo/xray.c | 8 +- src/demo/yield.c | 4 +- src/demo/zoo.c | 12 +- src/fetch/main.c | 6 +- src/input/input.cpp | 4 +- src/lib/blit.c | 8 +- src/lib/direct.c | 88 +++---- src/lib/fade.c | 20 +- src/lib/fill.c | 10 +- src/lib/internal.h | 44 ++-- src/lib/menu.c | 4 +- src/lib/notcurses.c | 56 ++--- src/lib/plot.c | 16 +- src/lib/render.c | 8 +- src/lib/selector.c | 10 +- src/player/play.cpp | 8 +- src/poc/dirlines.c | 16 +- src/poc/menu.c | 16 +- src/poc/multiselect.c | 4 +- src/poc/progbar.c | 4 +- src/poc/selector.c | 4 +- src/poc/textplay.c | 4 +- src/poc/tree.c | 6 +- src/pocpp/reel.cpp | 6 +- src/tests/bitmap.cpp | 4 +- src/tests/blit.cpp | 4 +- src/tests/cell.cpp | 20 +- src/tests/fills.cpp | 98 ++++---- src/tests/notcurses.cpp | 38 +-- src/tests/plane.cpp | 44 ++-- src/tests/plot.cpp | 20 +- src/tests/reel.cpp | 2 +- src/tests/resize.cpp | 16 +- src/tests/rotate.cpp | 36 +-- src/tests/stacking.cpp | 16 +- src/tests/visual.cpp | 36 +-- src/tests/wide.cpp | 8 +- src/tetris/background.h | 10 +- src/tetris/newpiece.h | 4 +- 58 files changed, 766 insertions(+), 621 deletions(-) diff --git a/NEWS.md b/NEWS.md index c716d160d..6540aee1d 100644 --- a/NEWS.md +++ b/NEWS.md @@ -11,6 +11,9 @@ rearrangements of Notcurses. * All functions prefixed with `channel_` have been deprecated in favor of versions prefixed with `ncchannel_`, which the former now wrap. The old versions will be removed in ABI3. + * All functions prefixed with `channels_` have been deprecated in favor of + versions prefixed with `ncchannels_`, which the former now wrap. The old + versions will be removed in ABI3. * `SIGINT`, `SIGQUIT`, and `SIGTERM` are now masked for the calling thread when writing starts, and unmasked when writing has ended. This prevents the writing thread from handling these signals in the middle of a write, diff --git a/USAGE.md b/USAGE.md index c1c1dc468..c6b1b19c8 100644 --- a/USAGE.md +++ b/USAGE.md @@ -1587,37 +1587,37 @@ int ncplane_set_bchannel(struct ncplane* n, uint32_t channel); // Extract the 32-bit working background channel from an ncplane. static inline unsigned ncplane_bchannel(const struct ncplane* nc){ - return channels_bchannel(ncplane_channels(nc)); + return ncchannels_bchannel(ncplane_channels(nc)); } // Extract the 32-bit working foreground channel from an ncplane. static inline unsigned ncplane_fchannel(const struct ncplane* nc){ - return channels_fchannel(ncplane_channels(nc)); + return ncchannels_fchannel(ncplane_channels(nc)); } // Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs. static inline unsigned ncplane_fg_rgb(const struct ncplane* nc){ - return channels_fg_rgb(ncplane_channels(nc)); + return ncchannels_fg_rgb(ncplane_channels(nc)); } // Extract 24 bits of working background RGB from an ncplane, shifted to LSBs. static inline unsigned ncplane_bg_rgb(const struct ncplane* nc){ - return channels_bg_rgb(ncplane_channels(nc)); + return ncchannels_bg_rgb(ncplane_channels(nc)); } // Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs. static inline unsigned ncplane_fg_alpha(const struct ncplane* nc){ - return channels_fg_alpha(ncplane_channels(nc)); + return ncchannels_fg_alpha(ncplane_channels(nc)); } // Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs. static inline unsigned ncplane_bg_alpha(const struct ncplane* nc){ - return channels_bg_alpha(ncplane_channels(nc)); + return ncchannels_bg_alpha(ncplane_channels(nc)); } // Set the alpha parameters for ncplane 'n'. @@ -1627,13 +1627,13 @@ int ncplane_set_bg_alpha(struct ncplane* n, unsigned alpha); // Extract 24 bits of foreground RGB from 'n', split into subcomponents. static inline unsigned ncplane_fg_rgb8(const struct ncplane* n, unsigned* r, unsigned* g, unsigned* - return channels_fg_rgb8(ncplane_channels(n), r, g, b); + return ncchannels_fg_rgb8(ncplane_channels(n), r, g, b); } // Extract 24 bits of background RGB from 'n', split into subcomponents. static inline unsigned ncplane_bg_rgb8(const struct ncplane* n, unsigned* r, unsigned* g, unsigned* - return channels_bg_rgb8(ncplane_channels(n), r, g, b); + return ncchannels_bg_rgb8(ncplane_channels(n), r, g, b); } // Set the current fore/background color using RGB specifications. If the @@ -2000,103 +2000,103 @@ all implemented in terms of the lower-level [Channels API](#channels). // Extract the 32-bit background channel from a cell. static inline uint32_t nccell_bchannel(const nccell* cl){ - return channels_bchannel(cl->channels); + return ncchannels_bchannel(cl->channels); } // Extract the 32-bit foreground channel from a cell. static inline uint32_t nccell_fchannel(const nccell* cl){ - return channels_fchannel(cl->channels); + return ncchannels_fchannel(cl->channels); } // Extract 24 bits of foreground RGB from 'cl', shifted to LSBs. static inline uint32_t nccell_fg_rgb(const nccell* cl){ - return channels_fg_rgb(cl->channels); + return ncchannels_fg_rgb(cl->channels); } // Extract 24 bits of background RGB from 'cl', shifted to LSBs. static inline uint32_t nccell_bg_rgb(const nccell* cl){ - return channels_bg_rgb(cl->channels); + return ncchannels_bg_rgb(cl->channels); } // Extract 2 bits of foreground alpha from 'cl', shifted to LSBs. static inline unsigned nccell_fg_alpha(const nccell* cl){ - return channels_fg_alpha(cl->channels); + return ncchannels_fg_alpha(cl->channels); } // Extract 2 bits of background alpha from 'cl', shifted to LSBs. static inline unsigned nccell_bg_alpha(const nccell* cl){ - return channels_bg_alpha(cl->channels); + return ncchannels_bg_alpha(cl->channels); } // Extract 24 bits of foreground RGB from 'cl', split into subcell. static inline uint32_t nccell_fg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){ - return channels_fg_rgb8(cl->channels, r, g, b); + return ncchannels_fg_rgb8(cl->channels, r, g, b); } // Extract 24 bits of background RGB from 'cl', split into subcell. static inline uint32_t nccell_bg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){ - return channels_bg_rgb8(cl->channels, r, g, b); + return ncchannels_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 nccell_set_fg_rgb8(nccell* cl, int r, int g, int b){ - return channels_set_fg_rgb8(&cl->channels, r, g, b); + return ncchannels_set_fg_rgb8(&cl->channels, r, g, b); } // Same, but clipped to [0..255]. static inline void nccell_set_fg_rgb8_clipped(nccell* cl, int r, int g, int b){ - channels_set_fg_rgb8_clipped(&cl->channels, r, g, b); + ncchannels_set_fg_rgb8_clipped(&cl->channels, r, g, b); } // Same, but with an assembled 24-bit RGB value. static inline int nccell_set_fg_rgb(nccell* c, uint32_t channel){ - return channels_set_fg_rgb(&c->channels, channel); + return ncchannels_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 nccell_set_bg_rgb8(nccell* cl, int r, int g, int b){ - return channels_set_bg_rgb8(&cl->channels, r, g, b); + return ncchannels_set_bg_rgb8(&cl->channels, r, g, b); } // Same, but clipped to [0..255]. static inline void nccell_set_bg_rgb8_clipped(nccell* cl, int r, int g, int b){ - channels_set_bg_rgb8_clipped(&cl->channels, r, g, b); + ncchannels_set_bg_rgb8_clipped(&cl->channels, r, g, b); } // Same, but with an assembled 24-bit RGB value. static inline int nccell_set_bg_rgb(nccell* c, uint32_t channel){ - return channels_set_bg_rgb(&c->channels, channel); + return ncchannels_set_bg_rgb(&c->channels, channel); } static inline int nccell_set_fg_alpha(nccell* c, unsigned alpha){ - return channels_set_fg_alpha(&c->channels, alpha); + return ncchannels_set_fg_alpha(&c->channels, alpha); } static inline int nccell_set_bg_alpha(nccell* c, unsigned alpha){ - return channels_set_bg_alpha(&c->channels, alpha); + return ncchannels_set_bg_alpha(&c->channels, alpha); } // Is the foreground using the "default foreground color"? static inline bool nccell_fg_default_p(const nccell* cl){ - return channels_fg_default_p(cl->channels); + return ncchannels_fg_default_p(cl->channels); } // Is the background using the "default background color"? The "default @@ -2104,19 +2104,19 @@ nccell_fg_default_p(const nccell* cl){ // terminal-effected transparency. static inline bool nccell_bg_default_p(const nccell* cl){ - return channels_bg_default_p(cl->channels); + return ncchannels_bg_default_p(cl->channels); } // Use the default color for the foreground. static inline void nccell_set_fg_default(nccell* c){ - channels_set_fg_default(&c->channels); + ncchannels_set_fg_default(&c->channels); } // Use the default color for the background. static inline void nccell_set_bg_default(nccell* c){ - channels_set_bg_default(&c->channels); + ncchannels_set_bg_default(&c->channels); } ``` @@ -2866,57 +2866,57 @@ channel_set_default(unsigned* channel){ // Extract the 32-bit background channel from a channel pair. static inline unsigned -channels_bchannel(uint64_t channels){ +ncchannels_bchannel(uint64_t channels){ return channels & 0xfffffffflu; } // Extract the 32-bit foreground channel from a channel pair. static inline unsigned -channels_fchannel(uint64_t channels){ - return channels_bchannel(channels >> 32u); +ncchannels_fchannel(uint64_t channels){ + return ncchannels_bchannel(channels >> 32u); } // Extract 24 bits of foreground RGB from 'channels', shifted to LSBs. static inline unsigned -channels_fg_rgb(uint64_t channels){ - return channels_fchannel(channels) & CELL_BG_MASK; +ncchannels_fg_rgb(uint64_t channels){ + return ncchannels_fchannel(channels) & CELL_BG_MASK; } // Extract 24 bits of background RGB from 'channels', shifted to LSBs. static inline unsigned -channels_bg_rgb(uint64_t channels){ - return channels_bchannel(channels) & CELL_BG_MASK; +ncchannels_bg_rgb(uint64_t channels){ + return ncchannels_bchannel(channels) & CELL_BG_MASK; } // Extract 2 bits of foreground alpha from 'channels', shifted to LSBs. static inline unsigned -channels_fg_alpha(uint64_t channels){ - return channel_alpha(channels_fchannel(channels)); +ncchannels_fg_alpha(uint64_t channels){ + return ncchannel_alpha(channels_fchannel(channels)); } // Extract 2 bits of background alpha from 'channels', shifted to LSBs. static inline unsigned -channels_bg_alpha(uint64_t channels){ - return channel_alpha(channels_bchannel(channels)); +ncchannels_bg_alpha(uint64_t channels){ + return ncchannel_alpha(channels_bchannel(channels)); } // Extract 24 bits of foreground RGB from 'channels', split into subchannels. static inline unsigned -channels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ - return channel_rgb8(channels_fchannel(channels), r, g, b); +ncchannels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannel_rgb8(channels_fchannel(channels), r, g, b); } // Extract 24 bits of background RGB from 'channels', split into subchannels. static inline unsigned -channels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ - return channel_rgb8(channels_bchannel(channels), r, g, b); +ncchannels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannel_rgb8(channels_bchannel(channels), r, g, b); } // Set the r, g, and b channels for the foreground component of this 64-bit // 'channels' variable, and mark it as not using the default color. static inline int -channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ - unsigned channel = channels_fchannel(*channels); +ncchannels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ + unsigned channel = ncchannels_fchannel(*channels); if(channel_set_rgb8(&channel, r, g, b) < 0){ return -1; } @@ -2927,8 +2927,8 @@ channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ // Set the r, g, and b channels for the background component of this 64-bit // 'channels' variable, and mark it as not using the default color. static inline int -channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ - unsigned channel = channels_bchannel(*channels); +ncchannels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ + unsigned channel = ncchannels_bchannel(*channels); if(channel_set_rgb8(&channel, r, g, b) < 0){ return -1; } @@ -2938,8 +2938,8 @@ channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ // Same, but set an assembled 32 bit channel at once. static inline int -channels_set_fg_rgb(uint64_t* channels, unsigned rgb){ - unsigned channel = channels_fchannel(*channels); +ncchannels_set_fg_rgb(uint64_t* channels, unsigned rgb){ + unsigned channel = ncchannels_fchannel(*channels); if(channel_set(&channel, rgb) < 0){ return -1; } @@ -2948,8 +2948,8 @@ channels_set_fg_rgb(uint64_t* channels, unsigned rgb){ } static inline int -channels_set_bg_rgb(uint64_t* channels, unsigned rgb){ - unsigned channel = channels_bchannel(*channels); +ncchannels_set_bg_rgb(uint64_t* channels, unsigned rgb){ + unsigned channel = ncchannels_bchannel(*channels); if(channel_set(&channel, rgb) < 0){ return -1; } @@ -2959,8 +2959,8 @@ channels_set_bg_rgb(uint64_t* channels, unsigned rgb){ // Set the 2-bit alpha component of the foreground channel. static inline int -channels_set_fg_alpha(uint64_t* channels, unsigned alpha){ - unsigned channel = channels_fchannel(*channels); +ncchannels_set_fg_alpha(uint64_t* channels, unsigned alpha){ + unsigned channel = ncchannels_fchannel(*channels); if(channel_set_alpha(&channel, alpha) < 0){ return -1; } @@ -2970,11 +2970,11 @@ channels_set_fg_alpha(uint64_t* channels, unsigned alpha){ // Set the 2-bit alpha component of the background channel. static inline int -channels_set_bg_alpha(uint64_t* channels, unsigned alpha){ +ncchannels_set_bg_alpha(uint64_t* channels, unsigned alpha){ if(alpha == CELL_ALPHA_HIGHCONTRAST){ // forbidden for background alpha return -1; } - unsigned channel = channels_bchannel(*channels); + unsigned channel = ncchannels_bchannel(*channels); if(channel_set_alpha(&channel, alpha) < 0){ return -1; } @@ -2984,22 +2984,22 @@ channels_set_bg_alpha(uint64_t* channels, unsigned alpha){ // Is the foreground using the "default foreground color"? static inline bool -channels_fg_default_p(uint64_t channels){ - return channel_default_p(channels_fchannel(channels)); +ncchannels_fg_default_p(uint64_t channels){ + return channel_default_p(ncchannels_fchannel(channels)); } // 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 -channels_bg_default_p(uint64_t channels){ - return channel_default_p(channels_bchannel(channels)); +ncchannels_bg_default_p(uint64_t channels){ + return channel_default_p(ncchannels_bchannel(channels)); } // Mark the foreground channel as using its default color. static inline uint64_t -channels_set_fg_default(uint64_t* channels){ - unsigned channel = channels_fchannel(*channels); +ncchannels_set_fg_default(uint64_t* channels){ + unsigned channel = ncchannels_fchannel(*channels); channel_set_default(&channel); *channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu); return *channels; @@ -3007,8 +3007,8 @@ channels_set_fg_default(uint64_t* channels){ // Mark the foreground channel as using its default color. static inline uint64_t -channels_set_bg_default(uint64_t* channels){ - unsigned channel = channels_bchannel(*channels); +ncchannels_set_bg_default(uint64_t* channels){ + unsigned channel = ncchannels_bchannel(*channels); channel_set_default(&channel); *channels = (*channels & 0xffffffff00000000llu) | channel; return *channels; diff --git a/doc/man/man3/notcurses_channels.3.md b/doc/man/man3/notcurses_channels.3.md index 5b6872a2a..a90e70bd6 100644 --- a/doc/man/man3/notcurses_channels.3.md +++ b/doc/man/man3/notcurses_channels.3.md @@ -43,45 +43,45 @@ notcurses_channels - operations on notcurses channels **uint32_t ncchannel_set_default(uint32_t* ***channel***);** -**unsigned channels_fg_rgb(uint64_t ***channels***);** +**unsigned ncchannels_fg_rgb(uint64_t ***channels***);** -**unsigned channels_bg_rgb(uint64_t ***channels***);** +**unsigned ncchannels_bg_rgb(uint64_t ***channels***);** -**int channels_set_fg_rgb(uint64_t* ***channels***, unsigned ***rgb***);** +**int ncchannels_set_fg_rgb(uint64_t* ***channels***, unsigned ***rgb***);** -**int channels_set_bg_rgb(uint64_t* ***channels***, unsigned ***rgb***);** +**int ncchannels_set_bg_rgb(uint64_t* ***channels***, unsigned ***rgb***);** -**unsigned channels_fg_alpha(uint64_t ***channels***);** +**unsigned ncchannels_fg_alpha(uint64_t ***channels***);** -**unsigned channels_bg_alpha(uint64_t ***channels***);** +**unsigned ncchannels_bg_alpha(uint64_t ***channels***);** -**int channels_set_fg_alpha(uint64_t* ***channels***, int ***alpha***);** +**int ncchannels_set_fg_alpha(uint64_t* ***channels***, int ***alpha***);** -**int channels_set_bg_alpha(uint64_t* ***channels***, int ***alpha***);** +**int ncchannels_set_bg_alpha(uint64_t* ***channels***, int ***alpha***);** -**unsigned channels_fg_palindex(uint64_t ***channels***);** +**unsigned ncchannels_fg_palindex(uint64_t ***channels***);** -**unsigned channels_bg_palindex(uint64_t ***channels***);** +**unsigned ncchannels_bg_palindex(uint64_t ***channels***);** -**int channels_set_fg_palindex(uint64_t* ***channels***, int ***idx***);** +**int ncchannels_set_fg_palindex(uint64_t* ***channels***, int ***idx***);** -**int channels_set_bg_palindex(uint64_t* ***channels***, int ***idx***);** +**int ncchannels_set_bg_palindex(uint64_t* ***channels***, int ***idx***);** -**unsigned channels_fg_rgb8(uint64_t ***channels***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);** +**unsigned ncchannels_fg_rgb8(uint64_t ***channels***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);** -**unsigned channels_bg_rgb8(uint64_t ***channels***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);** +**unsigned ncchannels_bg_rgb8(uint64_t ***channels***, unsigned* ***r***, unsigned* ***g***, unsigned* ***b***);** -**int channels_set_fg_rgb8(uint64_t* ***channels***, int ***r***, int ***g***, int ***b***);** +**int ncchannels_set_fg_rgb8(uint64_t* ***channels***, int ***r***, int ***g***, int ***b***);** -**int channels_set_bg_rgb8(uint64_t* ***channels***, int ***r***, int ***g***, int ***b***);** +**int ncchannels_set_bg_rgb8(uint64_t* ***channels***, int ***r***, int ***g***, int ***b***);** -**bool channels_fg_default_p(uint64_t ***channels***);** +**bool ncchannels_fg_default_p(uint64_t ***channels***);** -**bool channels_bg_default_p(uint64_t ***channels***);** +**bool ncchannels_bg_default_p(uint64_t ***channels***);** -**uint64_t channels_set_fg_default(uint64_t* ***channels***);** +**uint64_t ncchannels_set_fg_default(uint64_t* ***channels***);** -**uint64_t channels_set_bg_default(uint64_t* ***channels***);** +**uint64_t ncchannels_set_bg_default(uint64_t* ***channels***);** # DESCRIPTION diff --git a/include/notcurses/notcurses.h b/include/notcurses/notcurses.h index 9b74dcd3c..a6716bd72 100644 --- a/include/notcurses/notcurses.h +++ b/include/notcurses/notcurses.h @@ -285,87 +285,87 @@ ncchannel_set_default(unsigned* channel){ // Extract the 32-bit background channel from a channel pair. static inline uint32_t -channels_bchannel(uint64_t channels){ +ncchannels_bchannel(uint64_t channels){ return channels & 0xfffffffflu; } // Extract the 32-bit foreground channel from a channel pair. static inline uint32_t -channels_fchannel(uint64_t channels){ - return channels_bchannel(channels >> 32u); +ncchannels_fchannel(uint64_t channels){ + return ncchannels_bchannel(channels >> 32u); } // Set the 32-bit background channel of a channel pair. static inline uint64_t -channels_set_bchannel(uint64_t* channels, uint32_t channel){ +ncchannels_set_bchannel(uint64_t* channels, uint32_t channel){ return *channels = (*channels & 0xffffffff00000000llu) | channel; } // Set the 32-bit foreground channel of a channel pair. static inline uint64_t -channels_set_fchannel(uint64_t* channels, uint32_t channel){ +ncchannels_set_fchannel(uint64_t* channels, uint32_t channel){ return *channels = (*channels & 0xfffffffflu) | ((uint64_t)channel << 32u); } static inline uint64_t -channels_combine(uint32_t fchan, uint32_t bchan){ +ncchannels_combine(uint32_t fchan, uint32_t bchan){ uint64_t channels = 0; - channels_set_fchannel(&channels, fchan); - channels_set_bchannel(&channels, bchan); + ncchannels_set_fchannel(&channels, fchan); + ncchannels_set_bchannel(&channels, bchan); return channels; } static inline unsigned -channels_fg_palindex(uint64_t channels){ - return ncchannel_palindex(channels_fchannel(channels)); +ncchannels_fg_palindex(uint64_t channels){ + return ncchannel_palindex(ncchannels_fchannel(channels)); } static inline unsigned -channels_bg_palindex(uint64_t channels){ - return ncchannel_palindex(channels_bchannel(channels)); +ncchannels_bg_palindex(uint64_t channels){ + return ncchannel_palindex(ncchannels_bchannel(channels)); } // Extract 24 bits of foreground RGB from 'channels', shifted to LSBs. static inline unsigned -channels_fg_rgb(uint64_t channels){ - return channels_fchannel(channels) & CELL_BG_RGB_MASK; +ncchannels_fg_rgb(uint64_t channels){ + return ncchannels_fchannel(channels) & CELL_BG_RGB_MASK; } // Extract 24 bits of background RGB from 'channels', shifted to LSBs. static inline unsigned -channels_bg_rgb(uint64_t channels){ - return channels_bchannel(channels) & CELL_BG_RGB_MASK; +ncchannels_bg_rgb(uint64_t channels){ + return ncchannels_bchannel(channels) & CELL_BG_RGB_MASK; } // Extract 2 bits of foreground alpha from 'channels', shifted to LSBs. static inline unsigned -channels_fg_alpha(uint64_t channels){ - return ncchannel_alpha(channels_fchannel(channels)); +ncchannels_fg_alpha(uint64_t channels){ + return ncchannel_alpha(ncchannels_fchannel(channels)); } // Extract 2 bits of background alpha from 'channels', shifted to LSBs. static inline unsigned -channels_bg_alpha(uint64_t channels){ - return ncchannel_alpha(channels_bchannel(channels)); +ncchannels_bg_alpha(uint64_t channels){ + return ncchannel_alpha(ncchannels_bchannel(channels)); } // Extract 24 bits of foreground RGB from 'channels', split into subchannels. static inline unsigned -channels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ - return ncchannel_rgb8(channels_fchannel(channels), r, g, b); +ncchannels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannel_rgb8(ncchannels_fchannel(channels), r, g, b); } // Extract 24 bits of background RGB from 'channels', split into subchannels. static inline unsigned -channels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ - return ncchannel_rgb8(channels_bchannel(channels), r, g, b); +ncchannels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannel_rgb8(ncchannels_bchannel(channels), r, g, b); } // Set the r, g, and b channels for the foreground component of this 64-bit // 'channels' variable, and mark it as not using the default color. static inline int -channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ + uint32_t channel = ncchannels_fchannel(*channels); if(ncchannel_set_rgb8(&channel, r, g, b) < 0){ return -1; } @@ -375,16 +375,16 @@ channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ // Same, but clips to [0..255]. static inline void -channels_set_fg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ + uint32_t channel = ncchannels_fchannel(*channels); ncchannel_set_rgb8_clipped(&channel, r, g, b); *channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu); } // Set the 2-bit alpha component of the foreground channel. static inline int -channels_set_fg_alpha(uint64_t* channels, unsigned alpha){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_alpha(uint64_t* channels, unsigned alpha){ + uint32_t channel = ncchannels_fchannel(*channels); if(ncchannel_set_alpha(&channel, alpha) < 0){ return -1; } @@ -393,8 +393,8 @@ channels_set_fg_alpha(uint64_t* channels, unsigned alpha){ } static inline int -channels_set_fg_palindex(uint64_t* channels, int idx){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_palindex(uint64_t* channels, int idx){ + uint32_t channel = ncchannels_fchannel(*channels); if(ncchannel_set_palindex(&channel, idx) < 0){ return -1; } @@ -404,8 +404,8 @@ channels_set_fg_palindex(uint64_t* channels, int idx){ // Same, but set an assembled 24 bit channel at once. static inline int -channels_set_fg_rgb(uint64_t* channels, unsigned rgb){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_rgb(uint64_t* channels, unsigned rgb){ + uint32_t channel = ncchannels_fchannel(*channels); if(ncchannel_set(&channel, rgb) < 0){ return -1; } @@ -416,90 +416,90 @@ channels_set_fg_rgb(uint64_t* channels, unsigned rgb){ // Set the r, g, and b channels for the background component of this 64-bit // 'channels' variable, and mark it as not using the default color. static inline int -channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ - uint32_t channel = channels_bchannel(*channels); +ncchannels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ + uint32_t channel = ncchannels_bchannel(*channels); if(ncchannel_set_rgb8(&channel, r, g, b) < 0){ return -1; } - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); return 0; } // Same, but clips to [0..255]. static inline void -channels_set_bg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ - uint32_t channel = channels_bchannel(*channels); +ncchannels_set_bg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ + uint32_t channel = ncchannels_bchannel(*channels); ncchannel_set_rgb8_clipped(&channel, r, g, b); - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); } // Set the 2-bit alpha component of the background channel. static inline int -channels_set_bg_alpha(uint64_t* channels, unsigned alpha){ +ncchannels_set_bg_alpha(uint64_t* channels, unsigned alpha){ if(alpha == CELL_ALPHA_HIGHCONTRAST){ // forbidden for background alpha return -1; } - uint32_t channel = channels_bchannel(*channels); + uint32_t channel = ncchannels_bchannel(*channels); if(ncchannel_set_alpha(&channel, alpha) < 0){ return -1; } - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); return 0; } // 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 -channels_set_bg_palindex(uint64_t* channels, int idx){ - uint32_t channel = channels_bchannel(*channels); +ncchannels_set_bg_palindex(uint64_t* channels, int idx){ + uint32_t channel = ncchannels_bchannel(*channels); if(ncchannel_set_palindex(&channel, idx) < 0){ return -1; } - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); return 0; } // Same, but set an assembled 24 bit channel at once. static inline int -channels_set_bg_rgb(uint64_t* channels, unsigned rgb){ - uint32_t channel = channels_bchannel(*channels); +ncchannels_set_bg_rgb(uint64_t* channels, unsigned rgb){ + uint32_t channel = ncchannels_bchannel(*channels); if(ncchannel_set(&channel, rgb) < 0){ return -1; } - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); return 0; } // Is the foreground using the "default foreground color"? static inline bool -channels_fg_default_p(uint64_t channels){ - return ncchannel_default_p(channels_fchannel(channels)); +ncchannels_fg_default_p(uint64_t channels){ + return ncchannel_default_p(ncchannels_fchannel(channels)); } // Is the foreground using indexed palette color? static inline bool -channels_fg_palindex_p(uint64_t channels){ - return ncchannel_palindex_p(channels_fchannel(channels)); +ncchannels_fg_palindex_p(uint64_t channels){ + return ncchannel_palindex_p(ncchannels_fchannel(channels)); } // 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 -channels_bg_default_p(uint64_t channels){ - return ncchannel_default_p(channels_bchannel(channels)); +ncchannels_bg_default_p(uint64_t channels){ + return ncchannel_default_p(ncchannels_bchannel(channels)); } // Is the background using indexed palette color? static inline bool -channels_bg_palindex_p(uint64_t channels){ - return ncchannel_palindex_p(channels_bchannel(channels)); +ncchannels_bg_palindex_p(uint64_t channels){ + return ncchannel_palindex_p(ncchannels_bchannel(channels)); } // Mark the foreground channel as using its default color. static inline uint64_t -channels_set_fg_default(uint64_t* channels){ - uint32_t channel = channels_fchannel(*channels); +ncchannels_set_fg_default(uint64_t* channels){ + uint32_t channel = ncchannels_fchannel(*channels); ncchannel_set_default(&channel); *channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu); return *channels; @@ -507,10 +507,10 @@ channels_set_fg_default(uint64_t* channels){ // Mark the background channel as using its default color. static inline uint64_t -channels_set_bg_default(uint64_t* channels){ - uint32_t channel = channels_bchannel(*channels); +ncchannels_set_bg_default(uint64_t* channels){ + uint32_t channel = ncchannels_bchannel(*channels); ncchannel_set_default(&channel); - channels_set_bchannel(channels, channel); + ncchannels_set_bchannel(channels, channel); return *channels; } @@ -707,23 +707,23 @@ nccell_off_styles(nccell* c, unsigned stylebits){ // Use the default color for the foreground. static inline void nccell_set_fg_default(nccell* c){ - channels_set_fg_default(&c->channels); + ncchannels_set_fg_default(&c->channels); } // Use the default color for the background. static inline void nccell_set_bg_default(nccell* c){ - channels_set_bg_default(&c->channels); + ncchannels_set_bg_default(&c->channels); } static inline int nccell_set_fg_alpha(nccell* c, int alpha){ - return channels_set_fg_alpha(&c->channels, alpha); + return ncchannels_set_fg_alpha(&c->channels, alpha); } static inline int nccell_set_bg_alpha(nccell* c, int alpha){ - return channels_set_bg_alpha(&c->channels, alpha); + return ncchannels_set_bg_alpha(&c->channels, alpha); } // Is the cell part of a multicolumn element? @@ -1980,111 +1980,111 @@ API void ncplane_erase(struct ncplane* n); // Extract 24 bits of foreground RGB from 'cl', shifted to LSBs. static inline uint32_t nccell_fg_rgb(const nccell* cl){ - return channels_fg_rgb(cl->channels); + return ncchannels_fg_rgb(cl->channels); } // Extract 24 bits of background RGB from 'cl', shifted to LSBs. static inline uint32_t nccell_bg_rgb(const nccell* cl){ - return channels_bg_rgb(cl->channels); + return ncchannels_bg_rgb(cl->channels); } // Extract 2 bits of foreground alpha from 'cl', shifted to LSBs. static inline uint32_t nccell_fg_alpha(const nccell* cl){ - return channels_fg_alpha(cl->channels); + return ncchannels_fg_alpha(cl->channels); } // Extract 2 bits of background alpha from 'cl', shifted to LSBs. static inline uint32_t nccell_bg_alpha(const nccell* cl){ - return channels_bg_alpha(cl->channels); + return ncchannels_bg_alpha(cl->channels); } // 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){ - return channels_fg_rgb8(cl->channels, r, g, b); + return ncchannels_fg_rgb8(cl->channels, r, g, b); } // Extract 24 bits of background RGB from 'cl', split into components. static inline uint32_t nccell_bg_rgb8(const nccell* cl, unsigned* r, unsigned* g, unsigned* b){ - return channels_bg_rgb8(cl->channels, r, g, b); + return ncchannels_bg_rgb8(cl->channels, r, g, b); } // Set the r, g, and b cell for the foreground component of this 64-bit // 'cl' variable, and mark it as not using the default color. static inline int nccell_set_fg_rgb8(nccell* cl, int r, int g, int b){ - return channels_set_fg_rgb8(&cl->channels, r, g, b); + return ncchannels_set_fg_rgb8(&cl->channels, r, g, b); } // Same, but clipped to [0..255]. static inline void nccell_set_fg_rgb8_clipped(nccell* cl, int r, int g, int b){ - channels_set_fg_rgb8_clipped(&cl->channels, r, g, b); + ncchannels_set_fg_rgb8_clipped(&cl->channels, r, g, b); } // Same, but with an assembled 24-bit RGB value. static inline int nccell_set_fg_rgb(nccell* c, uint32_t channel){ - return channels_set_fg_rgb(&c->channels, channel); + return ncchannels_set_fg_rgb(&c->channels, 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 nccell_set_fg_palindex(nccell* cl, int idx){ - return channels_set_fg_palindex(&cl->channels, idx); + return ncchannels_set_fg_palindex(&cl->channels, idx); } static inline uint32_t nccell_fg_palindex(const nccell* cl){ - return channels_fg_palindex(cl->channels); + return ncchannels_fg_palindex(cl->channels); } // 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 nccell_set_bg_rgb8(nccell* cl, int r, int g, int b){ - return channels_set_bg_rgb8(&cl->channels, r, g, b); + return ncchannels_set_bg_rgb8(&cl->channels, r, g, b); } // Same, but clipped to [0..255]. static inline void nccell_set_bg_rgb8_clipped(nccell* cl, int r, int g, int b){ - channels_set_bg_rgb8_clipped(&cl->channels, r, g, b); + ncchannels_set_bg_rgb8_clipped(&cl->channels, r, g, b); } // Same, but with an assembled 24-bit RGB value. A value over 0xffffff // will be rejected, with a non-zero return value. static inline int nccell_set_bg_rgb(nccell* c, uint32_t channel){ - return channels_set_bg_rgb(&c->channels, channel); + return ncchannels_set_bg_rgb(&c->channels, 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 nccell_set_bg_palindex(nccell* cl, int idx){ - return channels_set_bg_palindex(&cl->channels, idx); + return ncchannels_set_bg_palindex(&cl->channels, idx); } static inline uint32_t nccell_bg_palindex(const nccell* cl){ - return channels_bg_palindex(cl->channels); + return ncchannels_bg_palindex(cl->channels); } // Is the foreground using the "default foreground color"? static inline bool nccell_fg_default_p(const nccell* cl){ - return channels_fg_default_p(cl->channels); + return ncchannels_fg_default_p(cl->channels); } static inline bool nccell_fg_palindex_p(const nccell* cl){ - return channels_fg_palindex_p(cl->channels); + return ncchannels_fg_palindex_p(cl->channels); } // Is the background using the "default background color"? The "default @@ -2092,24 +2092,24 @@ nccell_fg_palindex_p(const nccell* cl){ // terminal-effected transparency. static inline bool nccell_bg_default_p(const nccell* cl){ - return channels_bg_default_p(cl->channels); + return ncchannels_bg_default_p(cl->channels); } static inline bool nccell_bg_palindex_p(const nccell* cl){ - return channels_bg_palindex_p(cl->channels); + return ncchannels_bg_palindex_p(cl->channels); } // Extract the 32-bit working background channel from an ncplane. static inline uint32_t ncplane_bchannel(const struct ncplane* n){ - return channels_bchannel(ncplane_channels(n)); + return ncchannels_bchannel(ncplane_channels(n)); } // Extract the 32-bit working foreground channel from an ncplane. static inline uint32_t ncplane_fchannel(const struct ncplane* n){ - return channels_fchannel(ncplane_channels(n)); + return ncchannels_fchannel(ncplane_channels(n)); } API void ncplane_set_channels(struct ncplane* n, uint64_t channels); @@ -2127,49 +2127,49 @@ API void ncplane_off_styles(struct ncplane* n, unsigned stylebits); // Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs. static inline uint32_t ncplane_fg_rgb(const struct ncplane* n){ - return channels_fg_rgb(ncplane_channels(n)); + return ncchannels_fg_rgb(ncplane_channels(n)); } // Extract 24 bits of working background RGB from an ncplane, shifted to LSBs. static inline uint32_t ncplane_bg_rgb(const struct ncplane* n){ - return channels_bg_rgb(ncplane_channels(n)); + return ncchannels_bg_rgb(ncplane_channels(n)); } // Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs. static inline uint32_t ncplane_fg_alpha(const struct ncplane* n){ - return channels_fg_alpha(ncplane_channels(n)); + return ncchannels_fg_alpha(ncplane_channels(n)); } // Is the plane's foreground using the "default foreground color"? static inline bool ncplane_fg_default_p(const struct ncplane* n){ - return channels_fg_default_p(ncplane_channels(n)); + return ncchannels_fg_default_p(ncplane_channels(n)); } // Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs. static inline uint32_t ncplane_bg_alpha(const struct ncplane* n){ - return channels_bg_alpha(ncplane_channels(n)); + return ncchannels_bg_alpha(ncplane_channels(n)); } // Is the plane's background using the "default background color"? static inline bool ncplane_bg_default_p(const struct ncplane* n){ - return channels_bg_default_p(ncplane_channels(n)); + return ncchannels_bg_default_p(ncplane_channels(n)); } // Extract 24 bits of foreground RGB from 'n', split into components. static inline uint32_t ncplane_fg_rgb8(const struct ncplane* n, unsigned* r, unsigned* g, unsigned* b){ - return channels_fg_rgb8(ncplane_channels(n), r, g, b); + return ncchannels_fg_rgb8(ncplane_channels(n), r, g, b); } // Extract 24 bits of background RGB from 'n', split into components. static inline uint32_t ncplane_bg_rgb8(const struct ncplane* n, unsigned* r, unsigned* g, unsigned* b){ - return channels_bg_rgb8(ncplane_channels(n), r, g, b); + return ncchannels_bg_rgb8(ncplane_channels(n), r, g, b); } // Set an entire 32-bit channel of the plane @@ -4038,24 +4038,166 @@ channel_set_palindex(uint32_t* channel, int idx){ return ncchannel_set_palindex(channel, idx); } -// Is this channel using the "default color" rather than RGB/palette-indexed? __attribute__ ((deprecated)) static inline bool channel_default_p(unsigned channel){ return ncchannel_default_p(channel); } -// Is this channel using palette-indexed color rather than RGB? __attribute__ ((deprecated)) static inline bool channel_palindex_p(unsigned channel){ return ncchannel_palindex_p(channel); } -// Mark the channel as using its default color, which also marks it opaque. __attribute__ ((deprecated)) static inline unsigned channel_set_default(unsigned* channel){ return ncchannel_set_default(channel); } +__attribute__ ((deprecated)) static inline uint32_t +channels_bchannel(uint64_t channels){ + return ncchannels_bchannel(channels); +} + +__attribute__ ((deprecated)) static inline uint32_t +channels_fchannel(uint64_t channels){ + return ncchannels_fchannel(channels); +} + +__attribute__ ((deprecated)) static inline uint64_t +channels_set_bchannel(uint64_t* channels, uint32_t channel){ + return ncchannels_set_bchannel(channels, channel); +} + +__attribute__ ((deprecated)) static inline uint64_t +channels_set_fchannel(uint64_t* channels, uint32_t channel){ + return ncchannels_set_fchannel(channels, channel); +} + +__attribute__ ((deprecated)) static inline uint64_t +channels_combine(uint32_t fchan, uint32_t bchan){ + return ncchannels_combine(fchan, bchan); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_fg_palindex(uint64_t channels){ + return ncchannels_fg_palindex(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_bg_palindex(uint64_t channels){ + return ncchannels_bg_palindex(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_fg_rgb(uint64_t channels){ + return ncchannels_fg_rgb(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_bg_rgb(uint64_t channels){ + return ncchannels_bg_rgb(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_fg_alpha(uint64_t channels){ + return ncchannels_fg_alpha(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_bg_alpha(uint64_t channels){ + return ncchannels_bg_alpha(channels); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannels_fg_rgb8(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline unsigned +channels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){ + return ncchannels_bg_rgb8(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline int +channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){ + return ncchannels_set_fg_rgb8(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline void +channels_set_fg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ + ncchannels_set_fg_rgb8_clipped(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline int +channels_set_fg_alpha(uint64_t* channels, unsigned alpha){ + return ncchannels_set_fg_alpha(channels, alpha); +} + +__attribute__ ((deprecated)) static inline int +channels_set_fg_palindex(uint64_t* channels, int idx){ + return ncchannels_set_bg_palindex(channels, idx); +} + +__attribute__ ((deprecated)) static inline int +channels_set_fg_rgb(uint64_t* channels, unsigned rgb){ + return ncchannels_set_fg_rgb(channels, rgb); +} + +__attribute__ ((deprecated)) static inline int +channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){ + return ncchannels_set_bg_rgb8(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline void +channels_set_bg_rgb8_clipped(uint64_t* channels, int r, int g, int b){ + ncchannels_set_bg_rgb8_clipped(channels, r, g, b); +} + +__attribute__ ((deprecated)) static inline int +channels_set_bg_alpha(uint64_t* channels, unsigned alpha){ + return ncchannels_set_bg_alpha(channels, alpha); +} + +__attribute__ ((deprecated)) static inline int +channels_set_bg_palindex(uint64_t* channels, int idx){ + return ncchannels_set_bg_palindex(channels, idx); +} + +__attribute__ ((deprecated)) static inline int +channels_set_bg_rgb(uint64_t* channels, unsigned rgb){ + return ncchannels_set_bg_rgb(channels, rgb); +} + +__attribute__ ((deprecated)) static inline bool +channels_fg_default_p(uint64_t channels){ + return ncchannels_fg_default_p(channels); +} + +__attribute__ ((deprecated)) static inline bool +channels_fg_palindex_p(uint64_t channels){ + return ncchannels_fg_palindex_p(channels); +} + +__attribute__ ((deprecated)) static inline bool +channels_bg_default_p(uint64_t channels){ + return ncchannels_bg_default_p(channels); +} + +__attribute__ ((deprecated)) static inline bool +channels_bg_palindex_p(uint64_t channels){ + return ncchannels_bg_palindex_p(channels); +} + +__attribute__ ((deprecated)) static inline uint64_t +channels_set_fg_default(uint64_t* channels){ + return ncchannels_set_fg_default(channels); +} + +__attribute__ ((deprecated)) static inline uint64_t +channels_set_bg_default(uint64_t* channels){ + return ncchannels_set_bg_default(channels); +} + typedef ncpalette palette256; typedef nccell cell; // FIXME backwards-compat, remove in ABI3 diff --git a/src/demo/animate.c b/src/demo/animate.c index 8a2507e4d..20ea6c505 100644 --- a/src/demo/animate.c +++ b/src/demo/animate.c @@ -166,7 +166,7 @@ drawcycles(struct ncplane* std, struct ncprogbar* left, struct ncprogbar* right, get_next_head(std, ncprogbar_plane(left), ncprogbar_plane(right), &endy, &endx, &endphase); free(ncplane_at_yx(std, endy, endx, NULL, channels)); - ncplane_set_bg_rgb(std, channels_bg_rgb(*channels)); + ncplane_set_bg_rgb(std, ncchannels_bg_rgb(*channels)); ncplane_set_fg_rgb(std, 0xffffff); int sbytes; if(ncplane_putegc_yx(std, endy, endx, cstr + offset, &sbytes) < 0){ @@ -228,7 +228,7 @@ animate(struct notcurses* nc, struct ncprogbar* left, struct ncprogbar* right){ }else{ get_next_end(std, ncprogbar_plane(left), ncprogbar_plane(right), &endy, &endx, &endphase); - ncplane_set_fg_rgb(std, channels_fg_rgb(channels)); + ncplane_set_fg_rgb(std, ncchannels_fg_rgb(channels)); ncplane_putwc_yx(std, endy, endx, L'▄'); } ++moves; diff --git a/src/demo/demo.c b/src/demo/demo.c index be0ac6608..5683e3cf3 100644 --- a/src/demo/demo.c +++ b/src/demo/demo.c @@ -495,8 +495,8 @@ static int scrub_stdplane(struct notcurses* nc){ struct ncplane* n = notcurses_stdplane(nc); uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0); // explicit black + opaque - channels_set_bg_rgb(&channels, 0); + ncchannels_set_fg_rgb(&channels, 0); // explicit black + opaque + ncchannels_set_bg_rgb(&channels, 0); if(ncplane_set_base(n, "", 0, channels)){ return -1; } diff --git a/src/demo/hud.c b/src/demo/hud.c index 1e3e50f92..e224d27ca 100644 --- a/src/demo/hud.c +++ b/src/demo/hud.c @@ -56,10 +56,10 @@ static struct ncplane* debug; // "debug info" modal popup static int hud_standard_bg_rgb(struct ncplane* n){ uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_fg_rgb8(&channels, 0x80, 0x80, 0x80); - channels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_bg_rgb8(&channels, 0x80, 0x80, 0x80); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb8(&channels, 0x80, 0x80, 0x80); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_rgb8(&channels, 0x80, 0x80, 0x80); if(ncplane_set_base(n, "", 0, channels) >= 0){ return -1; } @@ -114,8 +114,8 @@ debug_toggle(struct notcurses* nc){ return; } uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_rgb(&channels, 0xffffe5); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_rgb(&channels, 0xffffe5); ncplane_set_base(n, " ", 0, channels); ncplane_set_scrolling(n, true); ncplane_set_fg_rgb(n, 0x0a0a0a); @@ -159,10 +159,10 @@ about_toggle(struct notcurses* nc){ struct ncplane* n = ncplane_create(notcurses_stdplane(nc), &nopts); // let the glyphs below show through, but only dimly uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_fg_rgb8(&channels, 0x0, 0x0, 0x0); - channels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_bg_rgb8(&channels, 0x0, 0x0, 0x0); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb8(&channels, 0x0, 0x0, 0x0); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_rgb8(&channels, 0x0, 0x0, 0x0); if(ncplane_set_base(n, "", 0, channels) >= 0){ ncplane_set_fg_rgb(n, 0x11ffff); ncplane_set_bg_rgb(n, 0); @@ -178,8 +178,8 @@ about_toggle(struct notcurses* nc){ nccell lr = CELL_TRIVIAL_INITIALIZER, ll = CELL_TRIVIAL_INITIALIZER; nccell hl = CELL_TRIVIAL_INITIALIZER, vl = CELL_TRIVIAL_INITIALIZER; channels = 0; - channels_set_fg_rgb(&channels, 0xc020c0); - channels_set_bg_rgb(&channels, 0); + ncchannels_set_fg_rgb(&channels, 0xc020c0); + ncchannels_set_bg_rgb(&channels, 0); if(nccells_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){ nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl); @@ -316,13 +316,13 @@ struct ncmenu* menu_create(struct notcurses* nc){ }; uint64_t headerchannels = 0; uint64_t sectionchannels = 0; - channels_set_fg_rgb(§ionchannels, 0xffffff); - channels_set_bg_rgb(§ionchannels, 0x000000); - channels_set_fg_alpha(§ionchannels, CELL_ALPHA_HIGHCONTRAST); - channels_set_bg_alpha(§ionchannels, CELL_ALPHA_BLEND); - channels_set_fg_rgb(&headerchannels, 0xffffff); - channels_set_bg_rgb(&headerchannels, 0x7f347f); - channels_set_bg_alpha(&headerchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb(§ionchannels, 0xffffff); + ncchannels_set_bg_rgb(§ionchannels, 0x000000); + ncchannels_set_fg_alpha(§ionchannels, CELL_ALPHA_HIGHCONTRAST); + ncchannels_set_bg_alpha(§ionchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb(&headerchannels, 0xffffff); + ncchannels_set_bg_rgb(&headerchannels, 0x7f347f); + ncchannels_set_bg_alpha(&headerchannels, CELL_ALPHA_BLEND); const ncmenu_options mopts = { .sections = sections, .sectioncount = sizeof(sections) / sizeof(*sections), @@ -650,10 +650,10 @@ int fpsgraph_init(struct notcurses* nc){ } uint32_t style = 0; uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_fg_rgb(&channels, 0x201020); - channels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_bg_rgb(&channels, 0x201020); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb(&channels, 0x201020); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_rgb(&channels, 0x201020); ncplane_set_base(newp, "", style, channels); ncplot_options opts; memset(&opts, 0, sizeof(opts)); @@ -663,12 +663,12 @@ int fpsgraph_init(struct notcurses* nc){ opts.gridtype = NCBLIT_BRAILLE; opts.legendstyle = NCSTYLE_ITALIC | NCSTYLE_BOLD; opts.title = "frames per semisecond"; - channels_set_fg_rgb8(&opts.minchannels, 0x80, 0x80, 0xff); - channels_set_bg_rgb(&opts.minchannels, 0x201020); - channels_set_bg_alpha(&opts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_rgb8(&opts.maxchannels, 0x80, 0xff, 0x80); - channels_set_bg_rgb(&opts.maxchannels, 0x201020); - channels_set_bg_alpha(&opts.maxchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb8(&opts.minchannels, 0x80, 0x80, 0xff); + ncchannels_set_bg_rgb(&opts.minchannels, 0x201020); + ncchannels_set_bg_alpha(&opts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb8(&opts.maxchannels, 0x80, 0xff, 0x80); + ncchannels_set_bg_rgb(&opts.maxchannels, 0x201020); + ncchannels_set_bg_alpha(&opts.maxchannels, CELL_ALPHA_BLEND); struct ncuplot* fpsplot = ncuplot_create(newp, &opts, 0, 0); if(!fpsplot){ ncplane_destroy(newp); diff --git a/src/demo/intro.c b/src/demo/intro.c index 22f6a33bd..797517968 100644 --- a/src/demo/intro.c +++ b/src/demo/intro.c @@ -144,10 +144,10 @@ int intro(struct notcurses* nc){ } uint64_t cul, cur, cll, clr; cul = cur = cll = clr = 0; - channels_set_fg_rgb8(&cul, 200, 0, 200); channels_set_bg_rgb8(&cul, 0, 64, 0); - channels_set_fg_rgb8(&cur, 200, 0, 200); channels_set_bg_rgb8(&cur, 0, 64, 0); - channels_set_fg_rgb8(&cll, 200, 0, 200); channels_set_bg_rgb8(&cll, 0, 128, 0); - channels_set_fg_rgb8(&clr, 200, 0, 200); channels_set_bg_rgb8(&clr, 0, 128, 0); + ncchannels_set_fg_rgb8(&cul, 200, 0, 200); ncchannels_set_bg_rgb8(&cul, 0, 64, 0); + ncchannels_set_fg_rgb8(&cur, 200, 0, 200); ncchannels_set_bg_rgb8(&cur, 0, 64, 0); + ncchannels_set_fg_rgb8(&cll, 200, 0, 200); ncchannels_set_bg_rgb8(&cll, 0, 128, 0); + ncchannels_set_fg_rgb8(&clr, 200, 0, 200); ncchannels_set_bg_rgb8(&clr, 0, 128, 0); centercols = cols > 80 ? 72 : cols - 8; if(ncplane_cursor_move_yx(ncp, 5, (cols - centercols) / 2 + 1)){ return -1; diff --git a/src/demo/keller.c b/src/demo/keller.c index d620b5d29..d036abb95 100644 --- a/src/demo/keller.c +++ b/src/demo/keller.c @@ -17,8 +17,8 @@ visualize(struct notcurses* nc, struct ncvisual* ncv){ ncplane_set_fg_rgb(stdn, 0xffffff); ncplane_set_bg_rgb(stdn, 0); uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(stdn, "", 0, channels); for(size_t i = 0 ; i < sizeof(bs) / sizeof(*bs) ; ++i){ struct ncvisual_options vopts = { diff --git a/src/demo/luigi.c b/src/demo/luigi.c index e92848f83..cea3213e5 100644 --- a/src/demo/luigi.c +++ b/src/demo/luigi.c @@ -112,8 +112,8 @@ static const char* luigis[] = { static int draw_luigi(struct ncplane* n, const char* sprite){ uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(n, "", 0, channels); size_t s; int sbytes; @@ -197,8 +197,8 @@ int luigi_demo(struct notcurses* nc){ return -1; } uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); struct ncplane* wmplane = ncvisual_render(nc, wmncv, NULL); if(wmplane == NULL){ ncvisual_destroy(wmncv); diff --git a/src/demo/mojibake.c b/src/demo/mojibake.c index ad7253f93..6f15e961f 100644 --- a/src/demo/mojibake.c +++ b/src/demo/mojibake.c @@ -3572,7 +3572,7 @@ maketitle(struct ncplane* std){ return NULL; } uint64_t channels = 0; - channels_set_bg_rgb(&channels, 0x0); + ncchannels_set_bg_rgb(&channels, 0x0); if(ncplane_set_base(title, " ", 0, channels) < 0 || ncplane_set_bg_rgb(title, 0)){ ncplane_destroy(title); return NULL; diff --git a/src/demo/normal.c b/src/demo/normal.c index c5b5abd13..46beac875 100644 --- a/src/demo/normal.c +++ b/src/demo/normal.c @@ -234,10 +234,10 @@ int normal_demo(struct notcurses* nc){ ncplane_home(n); uint64_t tl, tr, bl, br; tl = tr = bl = br = 0; - channels_set_fg_rgb8(&tl, 0, 0, 0); - channels_set_fg_rgb8(&tr, 0, 0xff, 0); - channels_set_fg_rgb8(&bl, 0xff, 0, 0xff); - channels_set_fg_rgb8(&br, 0, 0, 0); + ncchannels_set_fg_rgb8(&tl, 0, 0, 0); + ncchannels_set_fg_rgb8(&tr, 0, 0xff, 0); + ncchannels_set_fg_rgb8(&bl, 0xff, 0, 0xff); + ncchannels_set_fg_rgb8(&br, 0, 0, 0); ncplane_dim_yx(n, &dy, &dx); if(ncplane_stain(n, dy - 1, dx - 1, tl, tr, bl, br) < 0){ goto err; diff --git a/src/demo/outro.c b/src/demo/outro.c index 252696a47..033f9db51 100644 --- a/src/demo/outro.c +++ b/src/demo/outro.c @@ -94,8 +94,8 @@ videothread(void* vnc){ return PTHREAD_CANCELED; } uint64_t trans_channel = 0; - channels_set_bg_alpha(&trans_channel, CELL_ALPHA_TRANSPARENT); - channels_set_fg_alpha(&trans_channel, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&trans_channel, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&trans_channel, CELL_ALPHA_TRANSPARENT); ncplane_set_base(apiap, "", 0, trans_channel); ncplane_set_fg_rgb8(apiap, 0xc0, 0x40, 0x80); ncplane_set_bg_rgb8(apiap, 0, 0, 0); @@ -130,7 +130,7 @@ outro_message(struct notcurses* nc, int* rows, int* cols){ int xs; ncplane_yx(non, NULL, &xs); uint64_t channels = 0; - channels_set_bg_rgb8(&channels, 0x58, 0x36, 0x58); + ncchannels_set_bg_rgb8(&channels, 0x58, 0x36, 0x58); if(ncplane_set_base(non, " ", 0, channels) < 0){ return NULL; } diff --git a/src/demo/reel.c b/src/demo/reel.c index cf1c4d861..c74eb35ac 100644 --- a/src/demo/reel.c +++ b/src/demo/reel.c @@ -212,18 +212,18 @@ ncreel_demo_core(struct notcurses* nc){ .focusedchan = 0, .flags = NCREEL_OPTION_INFINITESCROLL | NCREEL_OPTION_CIRCULAR, }; - channels_set_fg_rgb8(&popts.focusedchan, 58, 150, 221); - channels_set_bg_rgb8(&popts.focusedchan, 97, 214, 214); - channels_set_fg_rgb8(&popts.tabletchan, 19, 161, 14); - channels_set_bg_rgb8(&popts.borderchan, 0, 0, 0); - channels_set_fg_rgb8(&popts.borderchan, 136, 23, 152); - channels_set_bg_rgb8(&popts.borderchan, 0, 0, 0); + ncchannels_set_fg_rgb8(&popts.focusedchan, 58, 150, 221); + ncchannels_set_bg_rgb8(&popts.focusedchan, 97, 214, 214); + ncchannels_set_fg_rgb8(&popts.tabletchan, 19, 161, 14); + ncchannels_set_bg_rgb8(&popts.borderchan, 0, 0, 0); + ncchannels_set_fg_rgb8(&popts.borderchan, 136, 23, 152); + ncchannels_set_bg_rgb8(&popts.borderchan, 0, 0, 0); uint64_t bgchannels = 0; - if(channels_set_fg_alpha(&bgchannels, CELL_ALPHA_TRANSPARENT)){ + if(ncchannels_set_fg_alpha(&bgchannels, CELL_ALPHA_TRANSPARENT)){ ncplane_destroy(n); return -1; } - if(channels_set_bg_alpha(&bgchannels, CELL_ALPHA_TRANSPARENT)){ + if(ncchannels_set_bg_alpha(&bgchannels, CELL_ALPHA_TRANSPARENT)){ ncplane_destroy(n); return -1; } diff --git a/src/demo/sliding.c b/src/demo/sliding.c index fbee1ab0a..6759bd3ab 100644 --- a/src/demo/sliding.c +++ b/src/demo/sliding.c @@ -100,7 +100,7 @@ fill_chunk(struct ncplane* n, int idx){ int r = 64 + hidx * 10; int b = 64 + vidx * 30; int g = 225 - ((hidx + vidx) * 12); - channels_set_fg_rgb8(&channels, r, g, b); + ncchannels_set_fg_rgb8(&channels, r, g, b); uint32_t ul = 0, ur = 0, ll = 0, lr = 0; ncchannel_set_rgb8(&ul, r, g, b); ncchannel_set_rgb8(&lr, r, g, b); @@ -122,7 +122,7 @@ static int draw_bounding_box(struct ncplane* n, int yoff, int xoff, int chunky, int chunkx){ int ret; uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 180, 80, 180); + ncchannels_set_fg_rgb8(&channels, 180, 80, 180); //channels_set_bg_rgb8(&channels, 0, 0, 0); ncplane_cursor_move_yx(n, yoff, xoff); ret = ncplane_rounded_box(n, 0, channels, diff --git a/src/demo/trans.c b/src/demo/trans.c index 8d7bc028c..0009a6f62 100644 --- a/src/demo/trans.c +++ b/src/demo/trans.c @@ -253,8 +253,8 @@ int trans_demo(struct notcurses* nc){ struct ncplane* n = notcurses_stddim_yx(nc, &maxy, &maxx); ncplane_set_fg_rgb8(n, 255, 255, 255); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0, 128, 128); - channels_set_bg_rgb8(&channels, 90, 0, 90); + ncchannels_set_fg_rgb8(&channels, 0, 128, 128); + ncchannels_set_bg_rgb8(&channels, 90, 0, 90); int y = 1, x = 0; ncplane_cursor_move_yx(n, y, x); if(ncplane_rounded_box_sized(n, 0, channels, maxy - 1, maxx, 0)){ diff --git a/src/demo/unicodeblocks.c b/src/demo/unicodeblocks.c index 4b3eca83b..8ad5fd108 100644 --- a/src/demo/unicodeblocks.c +++ b/src/demo/unicodeblocks.c @@ -40,14 +40,14 @@ pbar_make(struct notcurses* nc, int row){ return NULL; } uint64_t channels = 0; - channels_set_bg_rgb(&channels, 0); + ncchannels_set_bg_rgb(&channels, 0); ncplane_set_base(pbar, "", 0, channels); int posy, posx, pdimy, pdimx; ncplane_yx(pbar, &posy, &posx); ncplane_dim_yx(pbar, &pdimy, &pdimx); ncplane_cursor_move_yx(std, posy - 1, posx - 1); channels = 0; - channels_set_fg_rgb8(&channels, 0, 0xde, 0xde); + ncchannels_set_fg_rgb8(&channels, 0, 0xde, 0xde); if(ncplane_rounded_box(std, 0, channels, posy + pdimy, posx + pdimx, 0)){ ncplane_destroy(pbar); return NULL; @@ -248,9 +248,9 @@ int unicodeblocks_demo(struct notcurses* nc){ return -1; } uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_fg_rgb(&channels, 0x004000); - channels_set_bg_rgb(&channels, 0x0); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_fg_rgb(&channels, 0x004000); + ncchannels_set_bg_rgb(&channels, 0x0); ncplane_set_base(header, "", 0, channels); for(sindex = 0 ; sindex < sizeof(blocks) / sizeof(*blocks) ; ++sindex){ ncplane_set_bg_rgb8(n, 0, 0, 0); diff --git a/src/demo/view.c b/src/demo/view.c index de6d2ab47..b2154c235 100644 --- a/src/demo/view.c +++ b/src/demo/view.c @@ -72,7 +72,7 @@ legend(struct ncplane* stdn, int dimy, int dimx){ struct ncplane* n = ncplane_create(stdn, &nopts); ncplane_set_bg_alpha(n, CELL_ALPHA_TRANSPARENT); uint64_t channels = 0; - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(n, " ", 0, channels); ncplane_set_styles(n, NCSTYLE_BOLD); ncplane_set_fg_rgb8(n, 0xff, 0xff, 0xff); @@ -136,8 +136,8 @@ view_images(struct notcurses* nc, struct ncplane* nstd, int dimy, int dimx){ return -1; } uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(dsplane, "", 0, channels); ncvisual_destroy(ncv2); demo_render(nc); diff --git a/src/demo/whiteout.c b/src/demo/whiteout.c index 1133aceea..28cc24c0f 100644 --- a/src/demo/whiteout.c +++ b/src/demo/whiteout.c @@ -26,9 +26,9 @@ mathplane(struct notcurses* nc){ }; struct ncplane* n = ncplane_create(stdn, &nopts); uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x2b50c8); // metallic gold, inverted - channels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_rgb(&channels, 0x2b50c8); // metallic gold, inverted + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(n, "", 0, channels); ncplane_set_fg_rgb(n, 0xd4af37); // metallic gold ncplane_set_bg_rgb(n, 0x0); @@ -168,14 +168,14 @@ static int message(struct ncplane* n, int maxy, int maxx, int num, int total, int bytes_out, int egs_out, int cols_out){ uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(n, "", 0, channels); ncplane_set_fg_rgb8(n, 255, 255, 255); ncplane_set_bg_rgb8(n, 32, 64, 32); channels = 0; - channels_set_fg_rgb8(&channels, 255, 255, 255); - channels_set_bg_rgb8(&channels, 32, 64, 32); + ncchannels_set_fg_rgb8(&channels, 255, 255, 255); + ncchannels_set_bg_rgb8(&channels, 32, 64, 32); ncplane_cursor_move_yx(n, 2, 0); if(ncplane_rounded_box(n, 0, channels, 4, 56, 0)){ return -1; diff --git a/src/demo/xray.c b/src/demo/xray.c index 7800b5374..f78594a6d 100644 --- a/src/demo/xray.c +++ b/src/demo/xray.c @@ -30,8 +30,8 @@ make_slider(struct notcurses* nc, int dimy, int dimx){ }; struct ncplane* n = ncplane_create(notcurses_stdplane(nc), &nopts); uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(n, " ", 0, channels); ncplane_set_scrolling(n, true); int r = 0x5f; @@ -99,8 +99,8 @@ int xray_demo(struct notcurses* nc){ return -1; } uint64_t stdc = 0; - channels_set_fg_alpha(&stdc, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&stdc, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&stdc, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&stdc, CELL_ALPHA_TRANSPARENT); ncplane_set_base(notcurses_stdplane(nc), "", 0, stdc); struct ncvisual_options vopts = { .y = NCALIGN_CENTER, diff --git a/src/demo/yield.c b/src/demo/yield.c index 246918704..9d49e533c 100644 --- a/src/demo/yield.c +++ b/src/demo/yield.c @@ -67,8 +67,8 @@ int yield_demo(struct notcurses* nc){ return -1; } uint64_t basechan = 0; - channels_set_bg_alpha(&basechan, CELL_ALPHA_TRANSPARENT); - channels_set_fg_alpha(&basechan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&basechan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&basechan, CELL_ALPHA_TRANSPARENT); ncplane_set_base(label, "", 0, basechan); ncplane_set_bg_alpha(label, CELL_ALPHA_TRANSPARENT); ncplane_set_fg_rgb8(label, 0xff, 0xff, 0xff); diff --git a/src/demo/zoo.c b/src/demo/zoo.c index cdad93715..ce79f69d9 100644 --- a/src/demo/zoo.c +++ b/src/demo/zoo.c @@ -75,8 +75,8 @@ multiselector_demo(struct ncplane* n, struct ncplane* under, int y){ .titlechannels = CHANNELS_RGB_INITIALIZER(0x80, 0x80, 0xff, 0, 0, 0x20), }; uint64_t bgchannels = CHANNELS_RGB_INITIALIZER(0, 0x40, 0, 0, 0x40, 0); - channels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); struct ncplane_options nopts = { .y = y, .x = 0, @@ -112,8 +112,8 @@ selector_demo(struct ncplane* n, struct ncplane* under, int dimx, int y){ .titlechannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0x80, 0, 0, 0x20), }; uint64_t bgchannels = CHANNELS_RGB_INITIALIZER(0, 0, 0x40, 0, 0, 0x40); - channels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); struct ncplane_options nopts = { .y = y, .x = dimx, @@ -392,8 +392,8 @@ reader_demo(struct notcurses* nc){ } ncplane_set_fg_rgb8(rp, 0x20, 0xe0, 0xe0); uint64_t echannels = 0; - channels_set_fg_alpha(&echannels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&echannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&echannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&echannels, CELL_ALPHA_BLEND); ncplane_set_base(rp, "", 0, echannels); ncplane_set_scrolling(rp, true); // Bring the selector left across the top, while raising the exposition diff --git a/src/fetch/main.c b/src/fetch/main.c index fc76282ae..574890405 100644 --- a/src/fetch/main.c +++ b/src/fetch/main.c @@ -484,7 +484,7 @@ infoplane_notcurses(struct notcurses* nc, const fetched_info* fi, int planeheigh } ncplane_home(infop); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0, 0xff, 0); + ncchannels_set_fg_rgb8(&channels, 0, 0xff, 0); ncplane_hline_interp(infop, &hl, planewidth / 2, ul.channels, channels); ncplane_hline_interp(infop, &hl, planewidth / 2, channels, ur.channels); nccell_release(infop, &ul); nccell_release(infop, &ur); @@ -496,8 +496,8 @@ infoplane_notcurses(struct notcurses* nc, const fetched_info* fi, int planeheigh fi->username, fi->hostname) < 0){ return -1; } - channels_set_fg_rgb8(&channels, 0, 0, 0); - channels_set_bg_rgb8(&channels, 0x50, 0x50, 0x50); + ncchannels_set_fg_rgb8(&channels, 0, 0, 0); + ncchannels_set_bg_rgb8(&channels, 0x50, 0x50, 0x50); ncplane_set_base(infop, " ", 0, channels); if(notcurses_render(nc)){ return -1; diff --git a/src/input/input.cpp b/src/input/input.cpp index 3925237d4..17b5f0c64 100644 --- a/src/input/input.cpp +++ b/src/input/input.cpp @@ -211,8 +211,8 @@ int input_demo(ncpp::NotCurses* nc) { // FIXME would be nice to switch over to exponential at some level popts.flags = NCPLOT_OPTION_LABELTICKSD | NCPLOT_OPTION_PRINTSAMPLE; popts.minchannels = popts.maxchannels = 0; - channels_set_fg_rgb8(&popts.minchannels, 0x40, 0x50, 0xb0); - channels_set_fg_rgb8(&popts.maxchannels, 0x40, 0xff, 0xd0); + ncchannels_set_fg_rgb8(&popts.minchannels, 0x40, 0x50, 0xb0); + ncchannels_set_fg_rgb8(&popts.maxchannels, 0x40, 0xff, 0xd0); popts.gridtype = static_cast(NCBLIT_8x1); plot = ncuplot_create(pplane, &popts, 0, 0); if(!plot){ diff --git a/src/lib/blit.c b/src/lib/blit.c index 36d796aac..98b1bcf16 100644 --- a/src/lib/blit.c +++ b/src/lib/blit.c @@ -577,8 +577,8 @@ sex_solver(const uint32_t rgbas[6], uint64_t* channels, unsigned blendcolors){ if(totaldiff < mindiff){ mindiff = totaldiff; best = glyph; - channels_set_fchannel(channels, l0); - channels_set_bchannel(channels, l1); + ncchannels_set_fchannel(channels, l0); + ncchannels_set_bchannel(channels, l1); } if(totaldiff == 0){ // can't beat that! break; @@ -587,8 +587,8 @@ sex_solver(const uint32_t rgbas[6], uint64_t* channels, unsigned blendcolors){ //fprintf(stderr, "solved for best: %d (%u)\n", best, mindiff); assert(best >= 0 && best < 32); if(blendcolors){ - channels_set_fg_alpha(channels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(channels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(channels, CELL_ALPHA_BLEND); } return sex[best]; } diff --git a/src/lib/direct.c b/src/lib/direct.c index 77cb7cc0a..19659d8b8 100644 --- a/src/lib/direct.c +++ b/src/lib/direct.c @@ -11,26 +11,26 @@ #include "internal.h" int ncdirect_putstr(ncdirect* nc, uint64_t channels, const char* utf8){ - if(channels_fg_default_p(channels)){ + if(ncchannels_fg_default_p(channels)){ if(ncdirect_set_fg_default(nc)){ return -1; } - }else if(channels_fg_palindex_p(channels)){ - if(ncdirect_set_fg_palindex(nc, channels_fg_palindex(channels))){ + }else if(ncchannels_fg_palindex_p(channels)){ + if(ncdirect_set_fg_palindex(nc, ncchannels_fg_palindex(channels))){ return -1; } - }else if(ncdirect_set_fg_rgb(nc, channels_fg_rgb(channels))){ + }else if(ncdirect_set_fg_rgb(nc, ncchannels_fg_rgb(channels))){ return -1; } - if(channels_bg_default_p(channels)){ + if(ncchannels_bg_default_p(channels)){ if(ncdirect_set_bg_default(nc)){ return -1; } - }else if(channels_bg_palindex_p(channels)){ - if(ncdirect_set_bg_palindex(nc, channels_bg_palindex(channels))){ + }else if(ncchannels_bg_palindex_p(channels)){ + if(ncdirect_set_bg_palindex(nc, ncchannels_bg_palindex(channels))){ return -1; } - }else if(ncdirect_set_bg_rgb(nc, channels_bg_rgb(channels))){ + }else if(ncdirect_set_bg_rgb(nc, ncchannels_bg_rgb(channels))){ return -1; } return fprintf(nc->ttyfp, "%s", utf8); @@ -412,8 +412,8 @@ ncdirect_dump_plane(ncdirect* n, const ncplane* np, int xoff){ // save the existing style and colors const bool fgdefault = ncdirect_fg_default_p(n); const bool bgdefault = ncdirect_bg_default_p(n); - const uint32_t fgrgb = channels_fg_rgb(n->channels); - const uint32_t bgrgb = channels_bg_rgb(n->channels); + const uint32_t fgrgb = ncchannels_fg_rgb(n->channels); + const uint32_t bgrgb = ncchannels_bg_rgb(n->channels); for(int y = 0 ; y < dimy ; ++y){ if(xoff){ if(ncdirect_cursor_move_yx(n, -1, xoff)){ @@ -427,15 +427,15 @@ ncdirect_dump_plane(ncdirect* n, const ncplane* np, int xoff){ if(egc == NULL){ return -1; } - if(channels_fg_alpha(channels) == CELL_ALPHA_TRANSPARENT){ + if(ncchannels_fg_alpha(channels) == CELL_ALPHA_TRANSPARENT){ ncdirect_set_fg_default(n); }else{ - ncdirect_set_fg_rgb(n, channels_fg_rgb(channels)); + ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(channels)); } - if(channels_bg_alpha(channels) == CELL_ALPHA_TRANSPARENT){ + if(ncchannels_bg_alpha(channels) == CELL_ALPHA_TRANSPARENT){ ncdirect_set_bg_default(n); }else{ - ncdirect_set_bg_rgb(n, channels_bg_rgb(channels)); + ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(channels)); } //fprintf(stderr, "%03d/%03d [%s] (%03dx%03d)\n", y, x, egc, dimy, dimx); if(fprintf(n->ttyfp, "%s", strlen(egc) == 0 ? " " : egc) < 0){ @@ -589,14 +589,14 @@ int ncdirect_render_image(ncdirect* n, const char* file, ncalign_e align, } int ncdirect_set_fg_palindex(ncdirect* nc, int pidx){ - if(channels_set_fg_palindex(&nc->channels, pidx) < 0){ + if(ncchannels_set_fg_palindex(&nc->channels, pidx) < 0){ return -1; } return term_emit(tiparm(nc->tcache.setaf, pidx), nc->ttyfp, false); } int ncdirect_set_bg_palindex(ncdirect* nc, int pidx){ - if(channels_set_bg_palindex(&nc->channels, pidx) < 0){ + if(ncchannels_set_bg_palindex(&nc->channels, pidx) < 0){ return -1; } return term_emit(tiparm(nc->tcache.setab, pidx), nc->ttyfp, false); @@ -767,10 +767,10 @@ ncdirect_style_emit(ncdirect* n, unsigned stylebits, FILE* out){ if(r == 0){ // FIXME need to handle palette-indexed colors if(!ncdirect_fg_default_p(n)){ - r |= ncdirect_set_fg_rgb(n, channels_fg_rgb(n->channels)); + r |= ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(n->channels)); } if(!ncdirect_bg_default_p(n)){ - r |= ncdirect_set_bg_rgb(n, channels_bg_rgb(n->channels)); + r |= ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(n->channels)); } } return r; @@ -857,12 +857,12 @@ int ncdirect_set_fg_default(ncdirect* nc){ } }else if(term_emit(nc->tcache.op, nc->ttyfp, false) == 0){ if(!ncdirect_bg_default_p(nc)){ - if(ncdirect_set_bg_rgb(nc, channels_bg_rgb(nc->channels))){ + if(ncdirect_set_bg_rgb(nc, ncchannels_bg_rgb(nc->channels))){ return -1; } } } - channels_set_fg_default(&nc->channels); + ncchannels_set_fg_default(&nc->channels); return 0; } @@ -876,12 +876,12 @@ int ncdirect_set_bg_default(ncdirect* nc){ } }else if(term_emit(nc->tcache.op, nc->ttyfp, false) == 0){ if(!ncdirect_fg_default_p(nc)){ - if(ncdirect_set_fg_rgb(nc, channels_fg_rgb(nc->channels))){ + if(ncdirect_set_fg_rgb(nc, ncchannels_fg_rgb(nc->channels))){ return -1; } } } - channels_set_bg_default(&nc->channels); + ncchannels_set_bg_default(&nc->channels); return 0; } @@ -890,13 +890,13 @@ int ncdirect_hline_interp(ncdirect* n, const char* egc, int len, unsigned ur, ug, ub; int r1, g1, b1, r2, g2, b2; int br1, bg1, bb1, br2, bg2, bb2; - channels_fg_rgb8(c1, &ur, &ug, &ub); + ncchannels_fg_rgb8(c1, &ur, &ug, &ub); r1 = ur; g1 = ug; b1 = ub; - channels_fg_rgb8(c2, &ur, &ug, &ub); + ncchannels_fg_rgb8(c2, &ur, &ug, &ub); r2 = ur; g2 = ug; b2 = ub; - channels_bg_rgb8(c1, &ur, &ug, &ub); + ncchannels_bg_rgb8(c1, &ur, &ug, &ub); br1 = ur; bg1 = ug; bb1 = ub; - channels_bg_rgb8(c2, &ur, &ug, &ub); + ncchannels_bg_rgb8(c2, &ur, &ug, &ub); br2 = ur; bg2 = ug; bb2 = ub; int deltr = r2 - r1; int deltg = g2 - g1; @@ -906,10 +906,10 @@ int ncdirect_hline_interp(ncdirect* n, const char* egc, int len, int deltbb = bb2 - bb1; int ret; bool fgdef = false, bgdef = false; - if(channels_fg_default_p(c1) && channels_fg_default_p(c2)){ + if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){ fgdef = true; } - if(channels_bg_default_p(c1) && channels_bg_default_p(c2)){ + if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){ bgdef = true; } for(ret = 0 ; ret < len ; ++ret){ @@ -937,13 +937,13 @@ int ncdirect_vline_interp(ncdirect* n, const char* egc, int len, unsigned ur, ug, ub; int r1, g1, b1, r2, g2, b2; int br1, bg1, bb1, br2, bg2, bb2; - channels_fg_rgb8(c1, &ur, &ug, &ub); + ncchannels_fg_rgb8(c1, &ur, &ug, &ub); r1 = ur; g1 = ug; b1 = ub; - channels_fg_rgb8(c2, &ur, &ug, &ub); + ncchannels_fg_rgb8(c2, &ur, &ug, &ub); r2 = ur; g2 = ug; b2 = ub; - channels_bg_rgb8(c1, &ur, &ug, &ub); + ncchannels_bg_rgb8(c1, &ur, &ug, &ub); br1 = ur; bg1 = ug; bb1 = ub; - channels_bg_rgb8(c2, &ur, &ug, &ub); + ncchannels_bg_rgb8(c2, &ur, &ug, &ub); br2 = ur; bg2 = ug; bb2 = ub; int deltr = (r2 - r1) / (len + 1); int deltg = (g2 - g1) / (len + 1); @@ -953,10 +953,10 @@ int ncdirect_vline_interp(ncdirect* n, const char* egc, int len, int deltbb = (bb2 - bb1) / (len + 1); int ret; bool fgdef = false, bgdef = false; - if(channels_fg_default_p(c1) && channels_fg_default_p(c2)){ + if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){ fgdef = true; } - if(channels_bg_default_p(c1) && channels_bg_default_p(c2)){ + if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){ bgdef = true; } for(ret = 0 ; ret < len ; ++ret){ @@ -968,10 +968,10 @@ int ncdirect_vline_interp(ncdirect* n, const char* egc, int len, bb1 += deltbb; uint64_t channels = 0; if(!fgdef){ - channels_set_fg_rgb8(&channels, r1, g1, b1); + ncchannels_set_fg_rgb8(&channels, r1, g1, b1); } if(!bgdef){ - channels_set_bg_rgb8(&channels, br1, bg1, bb1); + ncchannels_set_bg_rgb8(&channels, br1, bg1, bb1); } if(ncdirect_putstr(n, channels, egc) <= 0){ break; @@ -998,8 +998,8 @@ int ncdirect_box(ncdirect* n, uint64_t ul, uint64_t ur, unsigned edges; edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_LEFT); if(edges >= box_corner_needs(ctlword)){ - ncdirect_set_fg_rgb(n, channels_fg_rgb(ul)); - ncdirect_set_bg_rgb(n, channels_bg_rgb(ul)); + ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(ul)); + ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(ul)); if(fprintf(n->ttyfp, "%lc", wchars[0]) < 0){ return -1; } @@ -1028,8 +1028,8 @@ int ncdirect_box(ncdirect* n, uint64_t ul, uint64_t ur, } edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_RIGHT); if(edges >= box_corner_needs(ctlword)){ - ncdirect_set_fg_rgb(n, channels_fg_rgb(ur)); - ncdirect_set_bg_rgb(n, channels_bg_rgb(ur)); + ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(ur)); + ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(ur)); if(fprintf(n->ttyfp, "%lc", wchars[1]) < 0){ return -1; } @@ -1062,8 +1062,8 @@ int ncdirect_box(ncdirect* n, uint64_t ul, uint64_t ur, // bottom line edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_LEFT); if(edges >= box_corner_needs(ctlword)){ - ncdirect_set_fg_rgb(n, channels_fg_rgb(ll)); - ncdirect_set_bg_rgb(n, channels_bg_rgb(ll)); + ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(ll)); + ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(ll)); if(fprintf(n->ttyfp, "%lc", wchars[2]) < 0){ return -1; } @@ -1081,8 +1081,8 @@ int ncdirect_box(ncdirect* n, uint64_t ul, uint64_t ur, } edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_RIGHT); if(edges >= box_corner_needs(ctlword)){ - ncdirect_set_fg_rgb(n, channels_fg_rgb(lr)); - ncdirect_set_bg_rgb(n, channels_bg_rgb(lr)); + ncdirect_set_fg_rgb(n, ncchannels_fg_rgb(lr)); + ncdirect_set_bg_rgb(n, ncchannels_bg_rgb(lr)); if(fprintf(n->ttyfp, "%lc", wchars[3]) < 0){ return -1; } diff --git a/src/lib/fade.c b/src/lib/fade.c index eb85d9ed9..f5b842b34 100644 --- a/src/lib/fade.c +++ b/src/lib/fade.c @@ -37,7 +37,7 @@ alloc_ncplane_palette(ncplane* n, ncfadectx* pp, const struct timespec* ts){ for(x = 0 ; x < pp->cols ; ++x){ channels = n->fb[nfbcellidx(n, y, x)].channels; pp->channels[y * pp->cols + x] = channels; - channels_fg_rgb8(channels, &r, &g, &b); + ncchannels_fg_rgb8(channels, &r, &g, &b); if(r > pp->maxr){ pp->maxr = r; } @@ -47,7 +47,7 @@ alloc_ncplane_palette(ncplane* n, ncfadectx* pp, const struct timespec* ts){ if(b > pp->maxb){ pp->maxb = b; } - channels_bg_rgb8(channels, &br, &bg, &bb); + ncchannels_bg_rgb8(channels, &br, &bg, &bb); if(br > pp->maxbr){ pp->maxbr = br; } @@ -61,7 +61,7 @@ alloc_ncplane_palette(ncplane* n, ncfadectx* pp, const struct timespec* ts){ } channels = n->basecell.channels; pp->channels[y * pp->cols] = channels; - channels_fg_rgb8(channels, &r, &g, &b); + ncchannels_fg_rgb8(channels, &r, &g, &b); if(r > pp->maxr){ pp->maxr = r; } @@ -71,7 +71,7 @@ alloc_ncplane_palette(ncplane* n, ncfadectx* pp, const struct timespec* ts){ if(b > pp->maxb){ pp->maxb = b; } - channels_bg_rgb8(channels, &br, &bg, &bb); + ncchannels_bg_rgb8(channels, &br, &bg, &bb); if(br > pp->maxbr){ pp->maxbr = br; } @@ -116,9 +116,9 @@ int ncplane_fadein_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){ unsigned r, g, b; - channels_fg_rgb8(nctx->channels[nctx->cols * y + x], &r, &g, &b); + ncchannels_fg_rgb8(nctx->channels[nctx->cols * y + x], &r, &g, &b); unsigned br, bg, bb; - channels_bg_rgb8(nctx->channels[nctx->cols * y + x], &br, &bg, &bb); + ncchannels_bg_rgb8(nctx->channels[nctx->cols * y + x], &br, &bg, &bb); nccell* c = &n->fb[dimx * y + x]; if(!nccell_fg_default_p(c)){ r = r * iter / nctx->maxsteps; @@ -184,14 +184,14 @@ int ncplane_fadeout_iteration(ncplane* n, ncfadectx* nctx, int iter, for(x = 0 ; x < nctx->cols && x < dimx; ++x){ nccell* c = &n->fb[dimx * y + x]; if(!nccell_fg_default_p(c)){ - channels_fg_rgb8(nctx->channels[nctx->cols * y + x], &r, &g, &b); + ncchannels_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(!nccell_bg_default_p(c)){ - channels_bg_rgb8(nctx->channels[nctx->cols * y + x], &br, &bg, &bb); + ncchannels_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; bb = bb * (nctx->maxsteps - iter) / nctx->maxsteps; @@ -201,14 +201,14 @@ int ncplane_fadeout_iteration(ncplane* n, ncfadectx* nctx, int iter, } nccell* c = &n->basecell; if(!nccell_fg_default_p(c)){ - channels_fg_rgb8(nctx->channels[nctx->cols * y], &r, &g, &b); + ncchannels_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(!nccell_bg_default_p(c)){ - channels_bg_rgb8(nctx->channels[nctx->cols * y], &br, &bg, &bb); + ncchannels_bg_rgb8(nctx->channels[nctx->cols * y], &br, &bg, &bb); br = br * (nctx->maxsteps - iter) / nctx->maxsteps; bg = bg * (nctx->maxsteps - iter) / nctx->maxsteps; bb = bb * (nctx->maxsteps - iter) / nctx->maxsteps; diff --git a/src/lib/fill.c b/src/lib/fill.c index e662df47f..c345386c3 100644 --- a/src/lib/fill.c +++ b/src/lib/fill.c @@ -121,12 +121,12 @@ check_gradient_channel_args(uint32_t ul, uint32_t ur, uint32_t bl, uint32_t br){ // - all backgrounds must have the same alpha // - palette-indexed color must not be used bool check_gradient_args(uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br){ - if(check_gradient_channel_args(channels_fchannel(ul), channels_fchannel(ur), - channels_fchannel(bl), channels_fchannel(br))){ + if(check_gradient_channel_args(ncchannels_fchannel(ul), ncchannels_fchannel(ur), + ncchannels_fchannel(bl), ncchannels_fchannel(br))){ return true; } - if(check_gradient_channel_args(channels_bchannel(ul), channels_bchannel(ur), - channels_bchannel(bl), channels_bchannel(br))){ + if(check_gradient_channel_args(ncchannels_bchannel(ul), ncchannels_bchannel(ur), + ncchannels_bchannel(bl), ncchannels_bchannel(br))){ return true; } return false; @@ -357,7 +357,7 @@ rotate_channels(ncplane* src, const nccell* c, uint32_t* fchan, uint32_t* bchan) static int rotate_output(ncplane* dst, uint32_t tchan, uint32_t bchan){ - dst->channels = channels_combine(tchan, bchan); + dst->channels = ncchannels_combine(tchan, bchan); if(tchan != bchan){ return ncplane_putegc(dst, "▀", NULL); } diff --git a/src/lib/internal.h b/src/lib/internal.h index cc8d202c3..5a9829340 100644 --- a/src/lib/internal.h +++ b/src/lib/internal.h @@ -1200,25 +1200,25 @@ static inline void calc_gradient_channels(uint64_t* channels, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr, int y, int x, int ylen, int xlen){ - if(!channels_fg_default_p(ul)){ - channels_set_fchannel(channels, - calc_gradient_channel(channels_fchannel(ul), - channels_fchannel(ur), - channels_fchannel(ll), - channels_fchannel(lr), - y, x, ylen, xlen)); + if(!ncchannels_fg_default_p(ul)){ + ncchannels_set_fchannel(channels, + calc_gradient_channel(ncchannels_fchannel(ul), + ncchannels_fchannel(ur), + ncchannels_fchannel(ll), + ncchannels_fchannel(lr), + y, x, ylen, xlen)); }else{ - channels_set_fg_default(channels); + ncchannels_set_fg_default(channels); } - if(!channels_bg_default_p(ul)){ - channels_set_bchannel(channels, - calc_gradient_channel(channels_bchannel(ul), - channels_bchannel(ur), - channels_bchannel(ll), - channels_bchannel(lr), - y, x, ylen, xlen)); + if(!ncchannels_bg_default_p(ul)){ + ncchannels_set_bchannel(channels, + calc_gradient_channel(ncchannels_bchannel(ul), + ncchannels_bchannel(ur), + ncchannels_bchannel(ll), + ncchannels_bchannel(lr), + y, x, ylen, xlen)); }else{ - channels_set_bg_default(channels); + ncchannels_set_bg_default(channels); } } @@ -1325,7 +1325,7 @@ int ncplane_genocide(ncplane *ncp); // Extract the 32-bit background channel from a cell. static inline uint32_t cell_bchannel(const nccell* cl){ - return channels_bchannel(cl->channels); + return ncchannels_bchannel(cl->channels); } // Extract those elements of the channel which are common to both foreground @@ -1346,7 +1346,7 @@ cell_bchannel_common(const nccell* cl){ // Extract the 32-bit foreground channel from a cell. static inline uint32_t cell_fchannel(const nccell* cl){ - return channels_fchannel(cl->channels); + return ncchannels_fchannel(cl->channels); } // Extract those elements of the foreground channel which may be freely swapped @@ -1359,13 +1359,13 @@ cell_fchannel_common(const nccell* cl){ // Set the 32-bit background channel of an nccell. static inline uint64_t cell_set_bchannel(nccell* cl, uint32_t channel){ - return channels_set_bchannel(&cl->channels, channel); + return ncchannels_set_bchannel(&cl->channels, channel); } // Set the 32-bit foreground channel of an nccell. static inline uint64_t cell_set_fchannel(nccell* cl, uint32_t channel){ - return channels_set_fchannel(&cl->channels, channel); + return ncchannels_set_fchannel(&cl->channels, channel); } // Returns the result of blending two channels. 'blends' indicates how heavily @@ -1625,12 +1625,12 @@ ncdirect_channels(const ncdirect* nc){ static inline bool ncdirect_fg_default_p(const struct ncdirect* nc){ - return channels_fg_default_p(ncdirect_channels(nc)); + return ncchannels_fg_default_p(ncdirect_channels(nc)); } static inline bool ncdirect_bg_default_p(const struct ncdirect* nc){ - return channels_bg_default_p(ncdirect_channels(nc)); + return ncchannels_bg_default_p(ncdirect_channels(nc)); } int term_fg_rgb8(bool RGBflag, const char* setaf, int colors, FILE* out, diff --git a/src/lib/menu.c b/src/lib/menu.c index c46875dfb..750b7891a 100644 --- a/src/lib/menu.c +++ b/src/lib/menu.c @@ -378,10 +378,10 @@ ncmenu* ncmenu_create(ncplane* n, const ncmenu_options* opts){ ret->unrolledsection = -1; ret->headerchannels = opts->headerchannels; ret->dissectchannels = opts->headerchannels; - channels_set_fg_rgb(&ret->dissectchannels, 0xdddddd); + ncchannels_set_fg_rgb(&ret->dissectchannels, 0xdddddd); ret->sectionchannels = opts->sectionchannels; ret->disablechannels = ret->sectionchannels; - channels_set_fg_rgb(&ret->disablechannels, 0xdddddd); + ncchannels_set_fg_rgb(&ret->disablechannels, 0xdddddd); nccell c = CELL_TRIVIAL_INITIALIZER; nccell_set_fg_alpha(&c, CELL_ALPHA_TRANSPARENT); nccell_set_bg_alpha(&c, CELL_ALPHA_TRANSPARENT); diff --git a/src/lib/notcurses.c b/src/lib/notcurses.c index e8a540978..41277c2ad 100644 --- a/src/lib/notcurses.c +++ b/src/lib/notcurses.c @@ -1219,51 +1219,51 @@ void ncplane_set_channels(ncplane* n, uint64_t channels){ } void ncplane_set_fg_default(ncplane* n){ - channels_set_fg_default(&n->channels); + ncchannels_set_fg_default(&n->channels); } uint64_t ncplane_set_fchannel(ncplane* n, uint32_t channel){ - return channels_set_fchannel(&n->channels, channel); + return ncchannels_set_fchannel(&n->channels, channel); } uint64_t ncplane_set_bchannel(ncplane* n, uint32_t channel){ - return channels_set_bchannel(&n->channels, channel); + return ncchannels_set_bchannel(&n->channels, channel); } void ncplane_set_bg_default(ncplane* n){ - channels_set_bg_default(&n->channels); + ncchannels_set_bg_default(&n->channels); } void ncplane_set_bg_rgb8_clipped(ncplane* n, int r, int g, int b){ - channels_set_bg_rgb8_clipped(&n->channels, r, g, b); + ncchannels_set_bg_rgb8_clipped(&n->channels, r, g, b); } int ncplane_set_bg_rgb8(ncplane* n, int r, int g, int b){ - return channels_set_bg_rgb8(&n->channels, r, g, b); + return ncchannels_set_bg_rgb8(&n->channels, r, g, b); } void ncplane_set_fg_rgb8_clipped(ncplane* n, int r, int g, int b){ - channels_set_fg_rgb8_clipped(&n->channels, r, g, b); + ncchannels_set_fg_rgb8_clipped(&n->channels, r, g, b); } int ncplane_set_fg_rgb8(ncplane* n, int r, int g, int b){ - return channels_set_fg_rgb8(&n->channels, r, g, b); + return ncchannels_set_fg_rgb8(&n->channels, r, g, b); } int ncplane_set_fg_rgb(ncplane* n, unsigned channel){ - return channels_set_fg_rgb(&n->channels, channel); + return ncchannels_set_fg_rgb(&n->channels, channel); } int ncplane_set_bg_rgb(ncplane* n, unsigned channel){ - return channels_set_bg_rgb(&n->channels, channel); + return ncchannels_set_bg_rgb(&n->channels, channel); } int ncplane_set_fg_alpha(ncplane* n, int alpha){ - return channels_set_fg_alpha(&n->channels, alpha); + return ncchannels_set_fg_alpha(&n->channels, alpha); } int ncplane_set_bg_alpha(ncplane *n, int alpha){ - return channels_set_bg_alpha(&n->channels, alpha); + return ncchannels_set_bg_alpha(&n->channels, alpha); } int ncplane_set_fg_palindex(ncplane* n, int idx){ @@ -1272,7 +1272,7 @@ int ncplane_set_fg_palindex(ncplane* n, int idx){ } n->channels |= CELL_FGDEFAULT_MASK; n->channels |= CELL_FG_PALETTE; - channels_set_fg_alpha(&n->channels, CELL_ALPHA_OPAQUE); + ncchannels_set_fg_alpha(&n->channels, CELL_ALPHA_OPAQUE); n->stylemask &= 0xffff00ff; n->stylemask |= (idx << 8u); return 0; @@ -1284,7 +1284,7 @@ int ncplane_set_bg_palindex(ncplane* n, int idx){ } n->channels |= CELL_BGDEFAULT_MASK; n->channels |= CELL_BG_PALETTE; - channels_set_bg_alpha(&n->channels, CELL_ALPHA_OPAQUE); + ncchannels_set_bg_alpha(&n->channels, CELL_ALPHA_OPAQUE); n->stylemask &= 0xffffff00; n->stylemask |= idx; return 0; @@ -1709,13 +1709,13 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len, unsigned ur, ug, ub; int r1, g1, b1, r2, g2, b2; int br1, bg1, bb1, br2, bg2, bb2; - channels_fg_rgb8(c1, &ur, &ug, &ub); + ncchannels_fg_rgb8(c1, &ur, &ug, &ub); r1 = ur; g1 = ug; b1 = ub; - channels_fg_rgb8(c2, &ur, &ug, &ub); + ncchannels_fg_rgb8(c2, &ur, &ug, &ub); r2 = ur; g2 = ug; b2 = ub; - channels_bg_rgb8(c1, &ur, &ug, &ub); + ncchannels_bg_rgb8(c1, &ur, &ug, &ub); br1 = ur; bg1 = ug; bb1 = ub; - channels_bg_rgb8(c2, &ur, &ug, &ub); + ncchannels_bg_rgb8(c2, &ur, &ug, &ub); br2 = ur; bg2 = ug; bb2 = ub; int deltr = r2 - r1; int deltg = g2 - g1; @@ -1729,10 +1729,10 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len, return -1; } bool fgdef = false, bgdef = false; - if(channels_fg_default_p(c1) && channels_fg_default_p(c2)){ + if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){ fgdef = true; } - if(channels_bg_default_p(c1) && channels_bg_default_p(c2)){ + if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){ bgdef = true; } for(ret = 0 ; ret < len ; ++ret){ @@ -1761,13 +1761,13 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len, unsigned ur, ug, ub; int r1, g1, b1, r2, g2, b2; int br1, bg1, bb1, br2, bg2, bb2; - channels_fg_rgb8(c1, &ur, &ug, &ub); + ncchannels_fg_rgb8(c1, &ur, &ug, &ub); r1 = ur; g1 = ug; b1 = ub; - channels_fg_rgb8(c2, &ur, &ug, &ub); + ncchannels_fg_rgb8(c2, &ur, &ug, &ub); r2 = ur; g2 = ug; b2 = ub; - channels_bg_rgb8(c1, &ur, &ug, &ub); + ncchannels_bg_rgb8(c1, &ur, &ug, &ub); br1 = ur; bg1 = ug; bb1 = ub; - channels_bg_rgb8(c2, &ur, &ug, &ub); + ncchannels_bg_rgb8(c2, &ur, &ug, &ub); br2 = ur; bg2 = ug; bb2 = ub; int deltr = (r2 - r1) / (len + 1); int deltg = (g2 - g1) / (len + 1); @@ -1782,10 +1782,10 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len, return -1; } bool fgdef = false, bgdef = false; - if(channels_fg_default_p(c1) && channels_fg_default_p(c2)){ + if(ncchannels_fg_default_p(c1) && ncchannels_fg_default_p(c2)){ fgdef = true; } - if(channels_bg_default_p(c1) && channels_bg_default_p(c2)){ + if(ncchannels_bg_default_p(c1) && ncchannels_bg_default_p(c2)){ bgdef = true; } for(ret = 0 ; ret < len ; ++ret){ @@ -2539,8 +2539,8 @@ uint32_t* ncplane_as_rgba(const ncplane* nc, ncblitter_e blit, uint32_t* top = &ret[targy * lenx + targx]; uint32_t* bot = &ret[(targy + 1) * lenx + targx]; unsigned fr, fg, fb, br, bg, bb; - channels_fg_rgb8(channels, &fr, &fb, &fg); - channels_bg_rgb8(channels, &br, &bb, &bg); + ncchannels_fg_rgb8(channels, &fr, &fb, &fg); + ncchannels_bg_rgb8(channels, &br, &bb, &bg); // FIXME how do we deal with transparency? uint32_t frgba = (fr) + (fg << 16u) + (fb << 8u) + 0xff000000; uint32_t brgba = (br) + (bg << 16u) + (bb << 8u) + 0xff000000; diff --git a/src/lib/plot.c b/src/lib/plot.c index 61b429a64..e29ce5d2d 100644 --- a/src/lib/plot.c +++ b/src/lib/plot.c @@ -171,23 +171,23 @@ int redraw_plot_##T(nc##X##plot* ncp){ \ } \ utf8[bytes] = '\0'; \ nccell* c = ncplane_cell_ref_yx(ncp->ncp, dimy - y - 1, x); \ - cell_set_bchannel(c, channels_bchannel(channels)); \ - cell_set_fchannel(c, channels_fchannel(channels)); \ + cell_set_bchannel(c, ncchannels_bchannel(channels)); \ + cell_set_fchannel(c, ncchannels_fchannel(channels)); \ nccell_set_styles(c, NCSTYLE_NONE); \ if(pool_blit_direct(&ncp->ncp->pool, c, utf8, bytes, 1) <= 0){ \ return -1; \ } \ }else{ \ - const uint64_t swapbg = channels_bchannel(channels); \ - const uint64_t swapfg = channels_fchannel(channels); \ - channels_set_bchannel(&channels, swapfg); \ - channels_set_fchannel(&channels, swapbg); \ + const uint64_t swapbg = ncchannels_bchannel(channels); \ + const uint64_t swapfg = ncchannels_fchannel(channels); \ + ncchannels_set_bchannel(&channels, swapfg); \ + ncchannels_set_fchannel(&channels, swapbg); \ ncplane_set_channels(ncp->ncp, channels); \ if(ncplane_putchar_yx(ncp->ncp, dimy - y - 1, x, ' ') <= 0){ \ return -1; \ } \ - channels_set_bchannel(&channels, swapbg); \ - channels_set_fchannel(&channels, swapfg); \ + ncchannels_set_bchannel(&channels, swapbg); \ + ncchannels_set_fchannel(&channels, swapfg); \ ncplane_set_channels(ncp->ncp, channels); \ } \ } \ diff --git a/src/lib/render.c b/src/lib/render.c index 158af4fc0..890f4c498 100644 --- a/src/lib/render.c +++ b/src/lib/render.c @@ -1433,7 +1433,7 @@ int ncdirect_set_bg_rgb(ncdirect* nc, unsigned rgb){ return -1; } // FIXME need verify we're not palette, either - if(!ncdirect_bg_default_p(nc) && channels_bg_rgb(nc->channels) == rgb){ + if(!ncdirect_bg_default_p(nc) && ncchannels_bg_rgb(nc->channels) == rgb){ return 0; } if(term_bg_rgb8(nc->tcache.RGBflag, nc->tcache.setab, nc->tcache.colors, nc->ttyfp, @@ -1441,7 +1441,7 @@ int ncdirect_set_bg_rgb(ncdirect* nc, unsigned rgb){ nc->tcache.bg_collides_default)){ return -1; } - channels_set_bg_rgb(&nc->channels, rgb); + ncchannels_set_bg_rgb(&nc->channels, rgb); return 0; } @@ -1450,14 +1450,14 @@ int ncdirect_set_fg_rgb(ncdirect* nc, unsigned rgb){ return -1; } // FIXME need verify we're not palette, either - if(!ncdirect_fg_default_p(nc) && channels_fg_rgb(nc->channels) == rgb){ + if(!ncdirect_fg_default_p(nc) && ncchannels_fg_rgb(nc->channels) == rgb){ return 0; } if(term_fg_rgb8(nc->tcache.RGBflag, nc->tcache.setaf, nc->tcache.colors, nc->ttyfp, (rgb & 0xff0000u) >> 16u, (rgb & 0xff00u) >> 8u, rgb & 0xffu)){ return -1; } - channels_set_fg_rgb(&nc->channels, rgb); + ncchannels_set_fg_rgb(&nc->channels, rgb); return 0; } diff --git a/src/lib/selector.c b/src/lib/selector.c index eb8d81e5f..b9d11949c 100644 --- a/src/lib/selector.c +++ b/src/lib/selector.c @@ -174,12 +174,12 @@ ncselector_draw(ncselector* n){ } n->ncp->channels = n->opchannels; if(printidx == n->selected){ - n->ncp->channels = (uint64_t)channels_bchannel(n->opchannels) << 32u | channels_fchannel(n->opchannels); + n->ncp->channels = (uint64_t)ncchannels_bchannel(n->opchannels) << 32u | ncchannels_fchannel(n->opchannels); } ncplane_printf_yx(n->ncp, yoff, bodyoffset + (n->longop - n->items[printidx].opcolumns), "%s", n->items[printidx].option); n->ncp->channels = n->descchannels; if(printidx == n->selected){ - n->ncp->channels = (uint64_t)channels_bchannel(n->descchannels) << 32u | channels_fchannel(n->descchannels); + n->ncp->channels = (uint64_t)ncchannels_bchannel(n->descchannels) << 32u | ncchannels_fchannel(n->descchannels); } ncplane_printf_yx(n->ncp, yoff, bodyoffset + n->longop, " %s", n->items[printidx].desc); if(++printidx == n->itemcount){ @@ -652,7 +652,7 @@ ncmultiselector_draw(ncmultiselector* n){ } n->ncp->channels = n->descchannels; if(printidx == n->current){ - n->ncp->channels = (uint64_t)channels_bchannel(n->descchannels) << 32u | channels_fchannel(n->descchannels); + n->ncp->channels = (uint64_t)ncchannels_bchannel(n->descchannels) << 32u | ncchannels_fchannel(n->descchannels); } if(notcurses_canutf8(ncplane_notcurses(n->ncp))){ ncplane_putegc_yx(n->ncp, yoff, bodyoffset, n->items[printidx].selected ? "☒" : "☐", NULL); @@ -661,12 +661,12 @@ ncmultiselector_draw(ncmultiselector* n){ } n->ncp->channels = n->opchannels; if(printidx == n->current){ - n->ncp->channels = (uint64_t)channels_bchannel(n->opchannels) << 32u | channels_fchannel(n->opchannels); + n->ncp->channels = (uint64_t)ncchannels_bchannel(n->opchannels) << 32u | ncchannels_fchannel(n->opchannels); } ncplane_printf(n->ncp, " %s ", n->items[printidx].option); n->ncp->channels = n->descchannels; if(printidx == n->current){ - n->ncp->channels = (uint64_t)channels_bchannel(n->descchannels) << 32u | channels_fchannel(n->descchannels); + n->ncp->channels = (uint64_t)ncchannels_bchannel(n->descchannels) << 32u | ncchannels_fchannel(n->descchannels); } ncplane_printf(n->ncp, "%s", n->items[printidx].desc); if(++printidx == n->itemcount){ diff --git a/src/player/play.cpp b/src/player/play.cpp index 183057bb3..0d6581d67 100644 --- a/src/player/play.cpp +++ b/src/player/play.cpp @@ -61,8 +61,8 @@ auto handle_subtitle(char* subtitle, struct marshal* marsh, }; marsh->subtitle_plane = ncplane_create(vopts->n, &nopts); uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); ncplane_set_base(marsh->subtitle_plane, "", 0, channels); ncplane_set_fg_rgb(marsh->subtitle_plane, 0x00ffff); ncplane_set_fg_alpha(marsh->subtitle_plane, CELL_ALPHA_HIGHCONTRAST); @@ -366,8 +366,8 @@ int rendered_mode_player_inner(NotCurses& nc, int argc, char** argv, int dimy, dimx; std::unique_ptr stdn(nc.get_stdplane(&dimy, &dimx)); uint64_t transchan = 0; - channels_set_fg_alpha(&transchan, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&transchan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&transchan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&transchan, CELL_ALPHA_TRANSPARENT); stdn->set_base("", 0, transchan); struct ncplane_options nopts{}; // leave a line at the bottom. perhaps one day we'll put information there. diff --git a/src/poc/dirlines.c b/src/poc/dirlines.c index 91b0a6909..aa4232f1b 100644 --- a/src/poc/dirlines.c +++ b/src/poc/dirlines.c @@ -10,8 +10,8 @@ int main(void){ putchar('\n'); for(int i = 0 ; i < 15 ; ++i){ uint64_t c1 = 0, c2 = 0; - channels_set_fg_rgb8(&c1, 0x0, 0x10 * i, 0xff); - channels_set_fg_rgb8(&c2, 0x10 * i, 0x0, 0x0); + ncchannels_set_fg_rgb8(&c1, 0x0, 0x10 * i, 0xff); + ncchannels_set_fg_rgb8(&c2, 0x10 * i, 0x0, 0x0); if(ncdirect_hline_interp(n, "-", i, c1, c2) < i){ return EXIT_FAILURE; } @@ -21,8 +21,8 @@ int main(void){ } for(int i = 0 ; i < 15 ; ++i){ uint64_t c1 = 0, c2 = 0; - channels_set_fg_rgb8(&c1, 0x0, 0x10 * i, 0xff); - channels_set_fg_rgb8(&c2, 0x10 * i, 0x0, 0x0); + ncchannels_set_fg_rgb8(&c1, 0x0, 0x10 * i, 0xff); + ncchannels_set_fg_rgb8(&c2, 0x10 * i, 0x0, 0x0); if(ncdirect_vline_interp(n, "|", i, c1, c2) < i){ return EXIT_FAILURE; } @@ -37,10 +37,10 @@ int main(void){ printf("\n"); uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb8(&ul, 0xff, 0x0, 0xff); - channels_set_fg_rgb8(&ur, 0x0, 0xff, 0x0); - channels_set_fg_rgb8(&ll, 0x0, 0x0, 0xff); - channels_set_fg_rgb8(&lr, 0xff, 0x0, 0x0); + ncchannels_set_fg_rgb8(&ul, 0xff, 0x0, 0xff); + ncchannels_set_fg_rgb8(&ur, 0x0, 0xff, 0x0); + ncchannels_set_fg_rgb8(&ll, 0x0, 0x0, 0xff); + ncchannels_set_fg_rgb8(&lr, 0xff, 0x0, 0x0); if(ncdirect_rounded_box(n, ul, ur, ll, lr, 10, 10, 0) < 0){ return EXIT_FAILURE; } diff --git a/src/poc/menu.c b/src/poc/menu.c index e4688ec8c..0ba046815 100644 --- a/src/poc/menu.c +++ b/src/poc/menu.c @@ -20,8 +20,8 @@ run_menu(struct notcurses* nc, struct ncmenu* ncm){ ncplane_set_fg_rgb(selplane, 0x0); ncplane_set_bg_rgb(selplane, 0xdddddd); uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x000088); - channels_set_bg_rgb(&channels, 0x88aa00); + ncchannels_set_fg_rgb(&channels, 0x000088); + ncchannels_set_bg_rgb(&channels, 0x88aa00); if(ncplane_set_base(selplane, " ", 0, channels) < 0){ goto err; } @@ -101,10 +101,10 @@ int main(void){ memset(&mopts, 0, sizeof(mopts)); mopts.sections = sections; mopts.sectioncount = sizeof(sections) / sizeof(*sections); - channels_set_fg_rgb(&mopts.headerchannels, 0x00ff00); - channels_set_bg_rgb(&mopts.headerchannels, 0x440000); - channels_set_fg_rgb(&mopts.sectionchannels, 0xb0d700); - channels_set_bg_rgb(&mopts.sectionchannels, 0x002000); + ncchannels_set_fg_rgb(&mopts.headerchannels, 0x00ff00); + ncchannels_set_bg_rgb(&mopts.headerchannels, 0x440000); + ncchannels_set_fg_rgb(&mopts.sectionchannels, 0xb0d700); + ncchannels_set_bg_rgb(&mopts.sectionchannels, 0x002000); int dimy, dimx; struct ncplane* n = notcurses_stddim_yx(nc, &dimy, &dimx); struct ncmenu* top = ncmenu_create(n, &mopts); @@ -118,8 +118,8 @@ int main(void){ goto err; } uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x88aa00); - channels_set_bg_rgb(&channels, 0x000088); + ncchannels_set_fg_rgb(&channels, 0x88aa00); + ncchannels_set_bg_rgb(&channels, 0x000088); if(ncplane_set_base(n, "x", 0, channels) < 0){ return EXIT_FAILURE; } diff --git a/src/poc/multiselect.c b/src/poc/multiselect.c index 37d33b4f1..2c82f88b9 100644 --- a/src/poc/multiselect.c +++ b/src/poc/multiselect.c @@ -86,8 +86,8 @@ int main(void){ sopts.footchannels = CHANNELS_RGB_INITIALIZER(0xe0, 0, 0x40, 0x20, 0x20, 0); sopts.titlechannels = CHANNELS_RGB_INITIALIZER(0x20, 0xff, 0xff, 0, 0, 0x20); uint64_t bgchannels = CHANNELS_RGB_INITIALIZER(0, 0x20, 0, 0, 0x20, 0); - channels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); struct ncplane* n = notcurses_stdplane(nc); if(notcurses_canopen_images(nc)){ diff --git a/src/poc/progbar.c b/src/poc/progbar.c index a40629e87..34a5bca35 100644 --- a/src/poc/progbar.c +++ b/src/poc/progbar.c @@ -50,7 +50,7 @@ hbar_make(struct notcurses* nc, uint64_t flags){ ncplane_dim_yx(pbar, &pdimy, &pdimx); ncplane_cursor_move_yx(std, posy - 1, posx - 1); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0, 0xde, 0xde); + ncchannels_set_fg_rgb8(&channels, 0, 0xde, 0xde); if(ncplane_rounded_box(std, 0, channels, posy + pdimy, posx + pdimx, 0)){ ncplane_destroy(pbar); return NULL; @@ -90,7 +90,7 @@ pbar_make(struct notcurses* nc, uint64_t flags){ ncplane_dim_yx(pbar, &pdimy, &pdimx); ncplane_cursor_move_yx(std, posy - 1, posx - 1); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0, 0xde, 0xde); + ncchannels_set_fg_rgb8(&channels, 0, 0xde, 0xde); if(ncplane_rounded_box(std, 0, channels, posy + pdimy, posx + pdimx, 0)){ ncplane_destroy(pbar); return NULL; diff --git a/src/poc/selector.c b/src/poc/selector.c index 3629b4a27..647d83677 100644 --- a/src/poc/selector.c +++ b/src/poc/selector.c @@ -77,8 +77,8 @@ int main(void){ sopts.footchannels = CHANNELS_RGB_INITIALIZER(0xe0, 0, 0x40, 0x20, 0, 0); sopts.titlechannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0x80, 0, 0, 0x20); uint64_t bgchannels = CHANNELS_RGB_INITIALIZER(0, 0x20, 0, 0, 0x20, 0); - channels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); - channels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&bgchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&bgchannels, CELL_ALPHA_BLEND); struct ncplane* n = notcurses_stdplane(nc); if(notcurses_canopen_images(nc)){ diff --git a/src/poc/textplay.c b/src/poc/textplay.c index e1650a857..fcab355b2 100644 --- a/src/poc/textplay.c +++ b/src/poc/textplay.c @@ -121,8 +121,8 @@ textplane(struct notcurses* nc){ }; struct ncplane* n = ncplane_create(stdn, &nopts); uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); if(n){ ncplane_set_base(n, "", 0, channels); } diff --git a/src/poc/tree.c b/src/poc/tree.c index 2b0fa3aba..7f8ceb235 100644 --- a/src/poc/tree.c +++ b/src/poc/tree.c @@ -372,15 +372,15 @@ callback(struct ncplane* ncp, void* curry, int dizzy){ ncplane_cursor_move_yx(ncp, 0, 0); uint64_t channels = 0; if(dizzy == 0){ - channels_set_bg_rgb(&channels, 0x004080); + ncchannels_set_bg_rgb(&channels, 0x004080); ncplane_set_fg_rgb(ncp, 0xffffff); }else if(dizzy < 0){ float f = -dizzy / totylen; - channels_set_bg_rgb8(&channels, 0, 0x40 - 0x40 * f, 0); + ncchannels_set_bg_rgb8(&channels, 0, 0x40 - 0x40 * f, 0); ncplane_set_fg_rgb(ncp, 0xbbbbbb); }else if(dizzy > 0){ float f = dizzy / totylen; - channels_set_bg_rgb8(&channels, 0, 0x40 - 0x40 * f, 0); + ncchannels_set_bg_rgb8(&channels, 0, 0x40 - 0x40 * f, 0); ncplane_set_fg_rgb(ncp, 0xbbbbbb); } ncplane_set_base(ncp, " ", 0, channels); diff --git a/src/pocpp/reel.cpp b/src/pocpp/reel.cpp index 321e8db46..b920a6b56 100644 --- a/src/pocpp/reel.cpp +++ b/src/pocpp/reel.cpp @@ -231,9 +231,9 @@ int main(int argc, char** argv){ if(ncplane_set_fg_rgb8(n, 0xb1, 0x1b, 0xb1)){ return -1; } - channels_set_fg_rgb(&ropts.focusedchan, 0xffffff); - channels_set_bg_rgb(&ropts.focusedchan, 0x00c080); - channels_set_fg_rgb(&ropts.borderchan, 0x00c080); + ncchannels_set_fg_rgb(&ropts.focusedchan, 0xffffff); + ncchannels_set_bg_rgb(&ropts.focusedchan, 0x00c080); + ncchannels_set_fg_rgb(&ropts.borderchan, 0x00c080); auto nr = ncreel_create(n, &ropts); ncplane_set_userptr(n, nr); if(!nr){ diff --git a/src/tests/bitmap.cpp b/src/tests/bitmap.cpp index c463eae34..2bf87c765 100644 --- a/src/tests/bitmap.cpp +++ b/src/tests/bitmap.cpp @@ -462,8 +462,8 @@ TEST_CASE("Bitmaps") { #ifdef NOTCURSES_USE_MULTIMEDIA SUBCASE("PixelWipeImage") { uint64_t channels = 0; - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); CHECK(0 == ncplane_set_base(n_, "", 0, channels)); auto ncv = ncvisual_from_file(find_data("worldmap.png")); REQUIRE(ncv); diff --git a/src/tests/blit.cpp b/src/tests/blit.cpp index 57b7e4a63..f601aaae1 100644 --- a/src/tests/blit.cpp +++ b/src/tests/blit.cpp @@ -50,7 +50,7 @@ TEST_CASE("Blitting") { CHECK(0 == strcmp(" ", egc)); free(egc); CHECK(0 == stylemask); - uint32_t rgb = htole(channels_bg_rgb(channels)); + uint32_t rgb = htole(ncchannels_bg_rgb(channels)); CHECK(ncpixel_r(bgra) == ncpixel_r(rgb)); CHECK(ncpixel_g(bgra) == ncpixel_g(rgb)); CHECK(ncpixel_b(bgra) == ncpixel_b(rgb)); @@ -100,7 +100,7 @@ TEST_CASE("Blitting") { CHECK(0 == strcmp(" ", egc)); free(egc); CHECK(0 == stylemask); - uint32_t rgb = htole(channels_bg_rgb(channels)); + uint32_t rgb = htole(ncchannels_bg_rgb(channels)); CHECK(ncpixel_r(bgra) == ncpixel_r(rgb)); CHECK(ncpixel_g(bgra) == ncpixel_g(rgb)); CHECK(ncpixel_b(bgra) == ncpixel_b(rgb)); diff --git a/src/tests/cell.cpp b/src/tests/cell.cpp index c9a8202c4..82951cb7a 100644 --- a/src/tests/cell.cpp +++ b/src/tests/cell.cpp @@ -180,8 +180,8 @@ TEST_CASE("Cell") { REQUIRE(nullptr != negc); auto topegc = ncplane_at_yx(np, 0, 0, nullptr, &overchannels); REQUIRE(nullptr != topegc); - CHECK(channels_bg_rgb(channels) == channels_bg_rgb(underchannels)); - CHECK(channels_fg_rgb(channels) == channels_fg_rgb(overchannels)); + CHECK(ncchannels_bg_rgb(channels) == ncchannels_bg_rgb(underchannels)); + CHECK(ncchannels_fg_rgb(channels) == ncchannels_fg_rgb(overchannels)); ncplane_destroy(np); free(topegc); free(negc); @@ -220,8 +220,8 @@ TEST_CASE("Cell") { REQUIRE(nullptr != negc); auto topegc = ncplane_at_yx(np, 0, 0, nullptr, &overchannels); REQUIRE(nullptr != topegc); - CHECK(channels_bg_rgb(channels) == channels_bg_rgb(underchannels)); - CHECK(channels_fg_rgb(channels) < channels_fg_rgb(overchannels)); + CHECK(ncchannels_bg_rgb(channels) == ncchannels_bg_rgb(underchannels)); + CHECK(ncchannels_fg_rgb(channels) < ncchannels_fg_rgb(overchannels)); ncplane_destroy(np); free(topegc); free(negc); @@ -260,8 +260,8 @@ TEST_CASE("Cell") { REQUIRE(nullptr != negc); auto topegc = ncplane_at_yx(np, 0, 0, nullptr, &overchannels); REQUIRE(nullptr != topegc); - CHECK(channels_bg_rgb(channels) == channels_bg_rgb(underchannels)); - CHECK(channels_fg_rgb(channels) > channels_fg_rgb(overchannels)); + CHECK(ncchannels_bg_rgb(channels) == ncchannels_bg_rgb(underchannels)); + CHECK(ncchannels_fg_rgb(channels) > ncchannels_fg_rgb(overchannels)); ncplane_destroy(np); free(topegc); free(negc); @@ -300,8 +300,8 @@ TEST_CASE("Cell") { REQUIRE(nullptr != negc); auto topegc = ncplane_at_yx(np, 0, 0, nullptr, &overchannels); REQUIRE(nullptr != topegc); - CHECK(channels_bg_rgb(channels) == channels_bg_rgb(underchannels)); - CHECK(channels_fg_rgb(channels) == channels_fg_rgb(overchannels)); + CHECK(ncchannels_bg_rgb(channels) == ncchannels_bg_rgb(underchannels)); + CHECK(ncchannels_fg_rgb(channels) == ncchannels_fg_rgb(overchannels)); ncplane_destroy(np); free(topegc); free(negc); @@ -343,8 +343,8 @@ TEST_CASE("Cell") { REQUIRE(nullptr != negc); auto topegc = ncplane_at_yx(np, 0, 0, nullptr, &overchannels); REQUIRE(nullptr != topegc); - CHECK(channels_bg_rgb(channels) == channels_bg_rgb(overchannels)); - CHECK(channels_fg_rgb(channels) < channels_fg_rgb(underchannels)); + CHECK(ncchannels_bg_rgb(channels) == ncchannels_bg_rgb(overchannels)); + CHECK(ncchannels_fg_rgb(channels) < ncchannels_fg_rgb(underchannels)); free(topegc); free(negc); free(egc); diff --git a/src/tests/fills.cpp b/src/tests/fills.cpp index 4517a94aa..6eac56c66 100644 --- a/src/tests/fills.cpp +++ b/src/tests/fills.cpp @@ -114,15 +114,15 @@ TEST_CASE("Fills") { SUBCASE("GradientMonochromatic") { uint64_t c = 0; - channels_set_fg_rgb(&c, 0x40f040); - channels_set_bg_rgb(&c, 0x40f040); + ncchannels_set_fg_rgb(&c, 0x40f040); + ncchannels_set_bg_rgb(&c, 0x40f040); int dimy, dimx; ncplane_dim_yx(n_, &dimy, &dimx); REQUIRE(0 < ncplane_gradient_sized(n_, "M", 0, c, c, c, c, dimy, dimx)); nccell cl = CELL_TRIVIAL_INITIALIZER; uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x40f040); - channels_set_bg_rgb(&channels, 0x40f040); + ncchannels_set_fg_rgb(&channels, 0x40f040); + ncchannels_set_bg_rgb(&channels, 0x40f040); // check all squares for(int y = 0 ; y < dimy ; ++y){ for(int x = 0 ; x < dimx ; ++x){ @@ -138,21 +138,21 @@ TEST_CASE("Fills") { SUBCASE("GradientVertical") { uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0x40f040); - channels_set_bg_rgb(&ul, 0x40f040); - channels_set_fg_rgb(&ll, 0xf040f0); - channels_set_bg_rgb(&ll, 0xf040f0); - channels_set_fg_rgb(&ur, 0x40f040); - channels_set_bg_rgb(&ur, 0x40f040); - channels_set_fg_rgb(&lr, 0xf040f0); - channels_set_bg_rgb(&lr, 0xf040f0); + ncchannels_set_fg_rgb(&ul, 0x40f040); + ncchannels_set_bg_rgb(&ul, 0x40f040); + ncchannels_set_fg_rgb(&ll, 0xf040f0); + ncchannels_set_bg_rgb(&ll, 0xf040f0); + ncchannels_set_fg_rgb(&ur, 0x40f040); + ncchannels_set_bg_rgb(&ur, 0x40f040); + ncchannels_set_fg_rgb(&lr, 0xf040f0); + ncchannels_set_bg_rgb(&lr, 0xf040f0); int dimy, dimx; ncplane_dim_yx(n_, &dimy, &dimx); REQUIRE(0 < ncplane_gradient_sized(n_, "V", 0, ul, ur, ll, lr, dimy, dimx)); nccell c = CELL_TRIVIAL_INITIALIZER; uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x40f040); - channels_set_bg_rgb(&channels, 0x40f040); + ncchannels_set_fg_rgb(&channels, 0x40f040); + ncchannels_set_bg_rgb(&channels, 0x40f040); // check all squares. all rows ought be the same across their breadth, and // the components ought be going in the correct direction. uint64_t lastyrgb, lastxrgb; @@ -189,14 +189,14 @@ TEST_CASE("Fills") { SUBCASE("GradientHorizontal") { uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0x40f040); - channels_set_bg_rgb(&ul, 0x40f040); - channels_set_fg_rgb(&ur, 0xf040f0); - channels_set_bg_rgb(&ur, 0xf040f0); - channels_set_fg_rgb(&ll, 0x40f040); - channels_set_bg_rgb(&ll, 0x40f040); - channels_set_fg_rgb(&lr, 0xf040f0); - channels_set_bg_rgb(&lr, 0xf040f0); + ncchannels_set_fg_rgb(&ul, 0x40f040); + ncchannels_set_bg_rgb(&ul, 0x40f040); + ncchannels_set_fg_rgb(&ur, 0xf040f0); + ncchannels_set_bg_rgb(&ur, 0xf040f0); + ncchannels_set_fg_rgb(&ll, 0x40f040); + ncchannels_set_bg_rgb(&ll, 0x40f040); + ncchannels_set_fg_rgb(&lr, 0xf040f0); + ncchannels_set_bg_rgb(&lr, 0xf040f0); int dimy, dimx; ncplane_dim_yx(n_, &dimy, &dimx); REQUIRE(0 < ncplane_gradient_sized(n_, "H", 0, ul, ur, ll, lr, dimy, dimx)); @@ -207,14 +207,14 @@ TEST_CASE("Fills") { SUBCASE("GradientX") { uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0x000000); - channels_set_bg_rgb(&ul, 0xffffff); - channels_set_fg_rgb(&ll, 0x40f040); - channels_set_bg_rgb(&ll, 0x40f040); - channels_set_fg_rgb(&ur, 0xf040f0); - channels_set_bg_rgb(&ur, 0xf040f0); - channels_set_fg_rgb(&lr, 0xffffff); - channels_set_bg_rgb(&lr, 0x000000); + ncchannels_set_fg_rgb(&ul, 0x000000); + ncchannels_set_bg_rgb(&ul, 0xffffff); + ncchannels_set_fg_rgb(&ll, 0x40f040); + ncchannels_set_bg_rgb(&ll, 0x40f040); + ncchannels_set_fg_rgb(&ur, 0xf040f0); + ncchannels_set_bg_rgb(&ur, 0xf040f0); + ncchannels_set_fg_rgb(&lr, 0xffffff); + ncchannels_set_bg_rgb(&lr, 0x000000); int dimy, dimx; ncplane_dim_yx(n_, &dimy, &dimx); REQUIRE(0 < ncplane_gradient_sized(n_, "X", 0, ul, ur, ll, lr, dimy, dimx)); @@ -225,14 +225,14 @@ TEST_CASE("Fills") { SUBCASE("GradientS") { uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0xffffff); - channels_set_bg_rgb(&ul, 0xffffff); - channels_set_fg_rgb(&lr, 0x000000); - channels_set_bg_rgb(&lr, 0x000000); - channels_set_fg_rgb(&ll, 0x00ffff); - channels_set_bg_rgb(&ll, 0xff0000); - channels_set_fg_rgb(&ur, 0xff00ff); - channels_set_bg_rgb(&ur, 0x00ff00); + ncchannels_set_fg_rgb(&ul, 0xffffff); + ncchannels_set_bg_rgb(&ul, 0xffffff); + ncchannels_set_fg_rgb(&lr, 0x000000); + ncchannels_set_bg_rgb(&lr, 0x000000); + ncchannels_set_fg_rgb(&ll, 0x00ffff); + ncchannels_set_bg_rgb(&ll, 0xff0000); + ncchannels_set_fg_rgb(&ur, 0xff00ff); + ncchannels_set_bg_rgb(&ur, 0x00ff00); int dimy, dimx; ncplane_dim_yx(n_, &dimy, &dimx); REQUIRE(0 < ncplane_gradient_sized(n_, "S", 0, ul, ur, ll, lr, dimy, dimx)); @@ -270,8 +270,8 @@ TEST_CASE("Fills") { // EGC/color should change, but nothing else CHECK(0 == ncplane_cursor_move_yx(n_, 0, 0)); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0x88, 0x99, 0x77); - channels_set_bg_rgb(&channels, 0); + ncchannels_set_fg_rgb8(&channels, 0x88, 0x99, 0x77); + ncchannels_set_bg_rgb(&channels, 0); REQUIRE(0 < ncplane_stain(n_, 7, 7, channels, channels, channels, channels)); CHECK(0 == notcurses_render(nc_)); nccell d = CELL_TRIVIAL_INITIALIZER; @@ -293,8 +293,8 @@ TEST_CASE("Fills") { CHECK(0 == notcurses_render(nc_)); CHECK(0 == ncplane_cursor_move_yx(n_, 0, 0)); uint64_t channels = 0; - channels_set_fg_rgb8(&channels, 0x88, 0x99, 0x77); - channels_set_bg_rgb(&channels, 0); + ncchannels_set_fg_rgb8(&channels, 0x88, 0x99, 0x77); + ncchannels_set_bg_rgb(&channels, 0); REQUIRE(0 < ncplane_gradient(n_, "A", 0, channels, channels, channels, channels, 0, 0)); CHECK(0 == notcurses_render(nc_)); nccell d = CELL_TRIVIAL_INITIALIZER; @@ -312,10 +312,10 @@ TEST_CASE("Fills") { CHECK(0 == notcurses_render(nc_)); CHECK(0 == ncplane_cursor_move_yx(n_, 0, 0)); uint64_t chan1 = 0, chan2 = 0; - channels_set_fg_rgb8(&chan1, 0x88, 0x99, 0x77); - channels_set_fg_rgb8(&chan2, 0x77, 0x99, 0x88); - channels_set_bg_rgb(&chan1, 0); - channels_set_bg_rgb(&chan2, 0); + ncchannels_set_fg_rgb8(&chan1, 0x88, 0x99, 0x77); + ncchannels_set_fg_rgb8(&chan2, 0x77, 0x99, 0x88); + ncchannels_set_bg_rgb(&chan1, 0); + ncchannels_set_bg_rgb(&chan2, 0); REQUIRE(0 < ncplane_gradient(n_, "A", 0, chan1, chan2, chan1, chan2, 0, 3)); CHECK(0 == notcurses_render(nc_)); nccell d = CELL_TRIVIAL_INITIALIZER; @@ -535,9 +535,9 @@ TEST_CASE("Fills") { struct ncplane* p1 = ncplane_create(n_, &nopts); REQUIRE(p1); uint64_t ul = 0, ur = 0, bl = 0, br = 0; - channels_set_fg_rgb(&ur, 0xff0000); - channels_set_fg_rgb(&bl, 0x00ff00); - channels_set_fg_rgb(&br, 0x0000ff); + ncchannels_set_fg_rgb(&ur, 0xff0000); + ncchannels_set_fg_rgb(&bl, 0x00ff00); + ncchannels_set_fg_rgb(&br, 0x0000ff); ncplane_highgradient_sized(p1, ul, ur, bl, br, DIMY, DIMX); CHECK(0 == notcurses_render(nc_)); struct ncplane_options n2opts = { diff --git a/src/tests/notcurses.cpp b/src/tests/notcurses.cpp index 2eb9d5edb..33d04bc71 100644 --- a/src/tests/notcurses.cpp +++ b/src/tests/notcurses.cpp @@ -103,29 +103,29 @@ TEST_CASE("NotcursesBase") { SUBCASE("ChannelSetFGAlpha"){ uint64_t channel = 0; - CHECK(0 > channels_set_fg_alpha(&channel, -1)); - CHECK(0 > channels_set_fg_alpha(&channel, 4)); - CHECK(0 == channels_set_fg_alpha(&channel, CELL_ALPHA_OPAQUE)); - CHECK(CELL_ALPHA_OPAQUE == channels_fg_alpha(channel)); - CHECK(channels_fg_default_p(channel)); - CHECK(channels_bg_default_p(channel)); - CHECK(0 == channels_set_fg_alpha(&channel, CELL_ALPHA_HIGHCONTRAST)); - CHECK(CELL_ALPHA_HIGHCONTRAST == channels_fg_alpha(channel)); - CHECK(!channels_fg_default_p(channel)); - CHECK(channels_bg_default_p(channel)); + CHECK(0 > ncchannels_set_fg_alpha(&channel, -1)); + CHECK(0 > ncchannels_set_fg_alpha(&channel, 4)); + CHECK(0 == ncchannels_set_fg_alpha(&channel, CELL_ALPHA_OPAQUE)); + CHECK(CELL_ALPHA_OPAQUE == ncchannels_fg_alpha(channel)); + CHECK(ncchannels_fg_default_p(channel)); + CHECK(ncchannels_bg_default_p(channel)); + CHECK(0 == ncchannels_set_fg_alpha(&channel, CELL_ALPHA_HIGHCONTRAST)); + CHECK(CELL_ALPHA_HIGHCONTRAST == ncchannels_fg_alpha(channel)); + CHECK(!ncchannels_fg_default_p(channel)); + CHECK(ncchannels_bg_default_p(channel)); } SUBCASE("ChannelSetBGAlpha"){ uint64_t channel = 0; - CHECK(0 > channels_set_bg_alpha(&channel, -1)); - CHECK(0 > channels_set_bg_alpha(&channel, 4)); - CHECK(0 == channels_set_bg_alpha(&channel, CELL_ALPHA_OPAQUE)); - CHECK(CELL_ALPHA_OPAQUE == channels_bg_alpha(channel)); - CHECK(0 == channels_set_bg_alpha(&channel, CELL_ALPHA_TRANSPARENT)); - CHECK(0 > channels_set_bg_alpha(&channel, CELL_ALPHA_HIGHCONTRAST)); - CHECK(CELL_ALPHA_TRANSPARENT == channels_bg_alpha(channel)); - CHECK(channels_fg_default_p(channel)); - CHECK(!channels_bg_default_p(channel)); + CHECK(0 > ncchannels_set_bg_alpha(&channel, -1)); + CHECK(0 > ncchannels_set_bg_alpha(&channel, 4)); + CHECK(0 == ncchannels_set_bg_alpha(&channel, CELL_ALPHA_OPAQUE)); + CHECK(CELL_ALPHA_OPAQUE == ncchannels_bg_alpha(channel)); + CHECK(0 == ncchannels_set_bg_alpha(&channel, CELL_ALPHA_TRANSPARENT)); + CHECK(0 > ncchannels_set_bg_alpha(&channel, CELL_ALPHA_HIGHCONTRAST)); + CHECK(CELL_ALPHA_TRANSPARENT == ncchannels_bg_alpha(channel)); + CHECK(ncchannels_fg_default_p(channel)); + CHECK(!ncchannels_bg_default_p(channel)); } SUBCASE("Stats"){ diff --git a/src/tests/plane.cpp b/src/tests/plane.cpp index c73b86fe7..5405d7cce 100644 --- a/src/tests/plane.cpp +++ b/src/tests/plane.cpp @@ -661,14 +661,14 @@ TEST_CASE("Plane") { REQUIRE(40 < dimx); nccell ul{}, ll{}, lr{}, ur{}, hl{}, vl{}; REQUIRE(0 == nccells_double_box(n_, 0, 0, &ul, &ur, &ll, &lr, &hl, &vl)); - CHECK(0 == channels_set_fg_rgb8(&ul.channels, 255, 0, 0)); - CHECK(0 == channels_set_fg_rgb8(&ur.channels, 0, 255, 0)); - CHECK(0 == channels_set_fg_rgb8(&ll.channels, 0, 0, 255)); - CHECK(0 == channels_set_fg_rgb8(&lr.channels, 255, 255, 255)); - CHECK(0 == channels_set_bg_rgb8(&ul.channels, 0, 255, 255)); - CHECK(0 == channels_set_bg_rgb8(&ur.channels, 255, 0, 255)); - CHECK(0 == channels_set_bg_rgb8(&ll.channels, 255, 255, 0)); - CHECK(0 == channels_set_bg_rgb8(&lr.channels, 0, 0, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ul.channels, 255, 0, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ur.channels, 0, 255, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ll.channels, 0, 0, 255)); + CHECK(0 == ncchannels_set_fg_rgb8(&lr.channels, 255, 255, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&ul.channels, 0, 255, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&ur.channels, 255, 0, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&ll.channels, 255, 255, 0)); + CHECK(0 == ncchannels_set_bg_rgb8(&lr.channels, 0, 0, 0)); // we'll try all 16 gradmasks in sideszXsidesz configs in a 4x4 map unsigned gradmask = 0; for(auto y0 = 0 ; y0 < 4 ; ++y0){ @@ -700,18 +700,18 @@ TEST_CASE("Plane") { nccell ul{}, ll{}, lr{}, ur{}, hl{}, vl{}; REQUIRE(0 == nccells_rounded_box(n_, 0, 0, &ul, &ur, &ll, &lr, &hl, &vl)); // we'll try all 16 boxmasks in sideszXsidesz configurations in a 4x4 map - CHECK(0 == channels_set_fg_rgb8(&ul.channels, 255, 0, 0)); - CHECK(0 == channels_set_fg_rgb8(&ur.channels, 0, 255, 0)); - CHECK(0 == channels_set_fg_rgb8(&ll.channels, 0, 0, 255)); - CHECK(0 == channels_set_fg_rgb8(&lr.channels, 0, 0, 0)); - CHECK(0 == channels_set_bg_rgb8(&ul.channels, 0, 255, 255)); - CHECK(0 == channels_set_bg_rgb8(&ur.channels, 255, 0, 255)); - CHECK(0 == channels_set_bg_rgb8(&ll.channels, 255, 255, 0)); - CHECK(0 == channels_set_bg_rgb8(&lr.channels, 0, 0, 0)); - CHECK(0 == channels_set_fg_rgb8(&hl.channels, 255, 0, 255)); - CHECK(0 == channels_set_fg_rgb8(&vl.channels, 255, 255, 255)); - CHECK(0 == channels_set_bg_rgb8(&hl.channels, 0, 255, 0)); - CHECK(0 == channels_set_bg_rgb8(&vl.channels, 0, 0, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ul.channels, 255, 0, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ur.channels, 0, 255, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&ll.channels, 0, 0, 255)); + CHECK(0 == ncchannels_set_fg_rgb8(&lr.channels, 0, 0, 0)); + CHECK(0 == ncchannels_set_bg_rgb8(&ul.channels, 0, 255, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&ur.channels, 255, 0, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&ll.channels, 255, 255, 0)); + CHECK(0 == ncchannels_set_bg_rgb8(&lr.channels, 0, 0, 0)); + CHECK(0 == ncchannels_set_fg_rgb8(&hl.channels, 255, 0, 255)); + CHECK(0 == ncchannels_set_fg_rgb8(&vl.channels, 255, 255, 255)); + CHECK(0 == ncchannels_set_bg_rgb8(&hl.channels, 0, 255, 0)); + CHECK(0 == ncchannels_set_bg_rgb8(&vl.channels, 0, 0, 0)); for(auto y0 = 0 ; y0 < 4 ; ++y0){ for(auto x0 = 0 ; x0 < 4 ; ++x0){ CHECK(0 == ncplane_cursor_move_yx(n_, y0 * sidesz, x0 * (sidesz + 1))); @@ -815,12 +815,12 @@ TEST_CASE("Plane") { CHECK(1 == ncplane_at_yx_cell(n_, 0, 0, &c)); CHECK(cell_simple_p(&c)); CHECK(htole('C') == c.gcluster); - CHECK(0 == channels_set_fg_rgb(&channels, 0x444444)); + CHECK(0 == ncchannels_set_fg_rgb(&channels, 0x444444)); CHECK(channels == c.channels); CHECK(1 == ncplane_at_yx_cell(n_, 0, 1, &c)); CHECK(cell_simple_p(&c)); CHECK(htole('D') == c.gcluster); - CHECK(0 == channels_set_fg_rgb(&channels, 0x888888)); + CHECK(0 == ncchannels_set_fg_rgb(&channels, 0x888888)); CHECK(channels == c.channels); CHECK(0 == notcurses_render(nc_)); } diff --git a/src/tests/plot.cpp b/src/tests/plot.cpp index 7a192aaea..8d0c1890a 100644 --- a/src/tests/plot.cpp +++ b/src/tests/plot.cpp @@ -158,8 +158,8 @@ TEST_CASE("Plot") { memset(&popts, 0, sizeof(popts)); popts.maxchannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0xff, 0, 0, 0); popts.minchannels = CHANNELS_RGB_INITIALIZER(0, 0xff, 0, 0, 0, 0); - channels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); popts.gridtype = NCBLIT_BRAILLE; auto p = ncuplot_create(ncp, &popts, 0, 0); REQUIRE(p); @@ -189,8 +189,8 @@ TEST_CASE("Plot") { memset(&popts, 0, sizeof(popts)); popts.maxchannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0xff, 0, 0, 0); popts.minchannels = CHANNELS_RGB_INITIALIZER(0, 0xff, 0, 0, 0, 0); - channels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); popts.gridtype = NCBLIT_2x2; auto p = ncuplot_create(ncp, &popts, 0, 0); REQUIRE(p); @@ -216,8 +216,8 @@ TEST_CASE("Plot") { memset(&popts, 0, sizeof(popts)); popts.maxchannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0xff, 0, 0, 0); popts.minchannels = CHANNELS_RGB_INITIALIZER(0, 0xff, 0, 0, 0, 0); - channels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); popts.gridtype = NCBLIT_8x1; auto p = ncuplot_create(ncp, &popts, 0, 0); REQUIRE(p); @@ -240,8 +240,8 @@ TEST_CASE("Plot") { memset(&popts, 0, sizeof(popts)); popts.maxchannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0xff, 0, 0, 0); popts.minchannels = CHANNELS_RGB_INITIALIZER(0, 0xff, 0, 0, 0, 0); - channels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); popts.gridtype = NCBLIT_3x2; auto p = ncuplot_create(ncp, &popts, 0, 0); REQUIRE(p); @@ -267,8 +267,8 @@ TEST_CASE("Plot") { memset(&popts, 0, sizeof(popts)); popts.maxchannels = CHANNELS_RGB_INITIALIZER(0xff, 0xff, 0xff, 0, 0, 0); popts.minchannels = CHANNELS_RGB_INITIALIZER(0, 0xff, 0, 0, 0, 0); - channels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); - channels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_bg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); + ncchannels_set_fg_alpha(&popts.minchannels, CELL_ALPHA_BLEND); popts.gridtype = NCBLIT_BRAILLE; auto p = ncuplot_create(ncp, &popts, 0, 0); REQUIRE(p); diff --git a/src/tests/reel.cpp b/src/tests/reel.cpp index 0cc944c97..45414be84 100644 --- a/src/tests/reel.cpp +++ b/src/tests/reel.cpp @@ -289,7 +289,7 @@ TEST_CASE("Reels") { int dimy, dimx; notcurses_term_dim_yx(nc_, &dimy, &dimx); uint64_t channels = 0; - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); struct ncplane_options nopts = { .y = 0, .x = 0, diff --git a/src/tests/resize.cpp b/src/tests/resize.cpp index f9603dcdf..d8ed50c61 100644 --- a/src/tests/resize.cpp +++ b/src/tests/resize.cpp @@ -10,14 +10,14 @@ TEST_CASE("Resize") { REQUIRE(n_); uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0x40f040); - channels_set_bg_rgb(&ul, 0x40f040); - channels_set_fg_rgb(&ll, 0xf040f0); - channels_set_bg_rgb(&ll, 0xf040f0); - channels_set_fg_rgb(&ur, 0x40f040); - channels_set_bg_rgb(&ur, 0x40f040); - channels_set_fg_rgb(&lr, 0xf040f0); - channels_set_bg_rgb(&lr, 0xf040f0); + ncchannels_set_fg_rgb(&ul, 0x40f040); + ncchannels_set_bg_rgb(&ul, 0x40f040); + ncchannels_set_fg_rgb(&ll, 0xf040f0); + ncchannels_set_bg_rgb(&ll, 0xf040f0); + ncchannels_set_fg_rgb(&ur, 0x40f040); + ncchannels_set_bg_rgb(&ur, 0x40f040); + ncchannels_set_fg_rgb(&lr, 0xf040f0); + ncchannels_set_bg_rgb(&lr, 0xf040f0); // start at full size, and shrink to a nothing SUBCASE("ResizeShrink") { diff --git a/src/tests/rotate.cpp b/src/tests/rotate.cpp index 9d0c62876..2e36aca30 100644 --- a/src/tests/rotate.cpp +++ b/src/tests/rotate.cpp @@ -41,14 +41,14 @@ TEST_CASE("Rotate") { uint64_t ul, ur, ll, lr; ul = ur = ll = lr = 0; - channels_set_fg_rgb(&ul, 0x40f040); - channels_set_bg_rgb(&ul, 0x40f040); - channels_set_fg_rgb(&ll, 0xf040f0); - channels_set_bg_rgb(&ll, 0xf040f0); - channels_set_fg_rgb(&ur, 0x40f040); - channels_set_bg_rgb(&ur, 0x40f040); - channels_set_fg_rgb(&lr, 0xf040f0); - channels_set_bg_rgb(&lr, 0xf040f0); + ncchannels_set_fg_rgb(&ul, 0x40f040); + ncchannels_set_bg_rgb(&ul, 0x40f040); + ncchannels_set_fg_rgb(&ll, 0xf040f0); + ncchannels_set_bg_rgb(&ll, 0xf040f0); + ncchannels_set_fg_rgb(&ur, 0x40f040); + ncchannels_set_bg_rgb(&ur, 0x40f040); + ncchannels_set_fg_rgb(&lr, 0xf040f0); + ncchannels_set_bg_rgb(&lr, 0xf040f0); SUBCASE("RotateTransparentCW") { struct ncplane_options nopts = { @@ -64,8 +64,8 @@ TEST_CASE("Rotate") { }; struct ncplane* testn = ncplane_create(n_, &nopts); uint64_t channels = 0; - CHECK(0 == channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT)); - CHECK(0 == channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT)); + CHECK(0 == ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT)); + CHECK(0 == ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT)); REQUIRE(0 >= ncplane_set_base(testn, "", 0, channels)); nccell tl = CELL_TRIVIAL_INITIALIZER, tr = CELL_TRIVIAL_INITIALIZER; nccell bl = CELL_TRIVIAL_INITIALIZER, br = CELL_TRIVIAL_INITIALIZER; @@ -195,11 +195,11 @@ TEST_CASE("Rotate") { char* c = notcurses_at_yx(nc_, 0, x, &stylemask, &channels); REQUIRE(c); CHECK(0 == strcmp(c, " ")); - if(channels_fg_rgb(channels) & CELL_BG_RGB_MASK){ - CHECK(0xffccbb == channels_fg_rgb(channels)); + if(ncchannels_fg_rgb(channels) & CELL_BG_RGB_MASK){ + CHECK(0xffccbb == ncchannels_fg_rgb(channels)); } - if(channels_bg_rgb(channels) & CELL_BG_RGB_MASK){ - CHECK(0xffccbb == channels_bg_rgb(channels)); + if(ncchannels_bg_rgb(channels) & CELL_BG_RGB_MASK){ + CHECK(0xffccbb == ncchannels_bg_rgb(channels)); } free(c); } @@ -255,11 +255,11 @@ TEST_CASE("Rotate") { char* c = notcurses_at_yx(nc_, 0, x, &stylemask, &channels); REQUIRE(c); CHECK(0 == strcmp(c, " ")); - if(channels_fg_rgb(channels) & CELL_BG_RGB_MASK){ - CHECK(0xffccbb == channels_fg_rgb(channels)); + if(ncchannels_fg_rgb(channels) & CELL_BG_RGB_MASK){ + CHECK(0xffccbb == ncchannels_fg_rgb(channels)); } - if(channels_bg_rgb(channels) & CELL_BG_RGB_MASK){ - CHECK(0xffccbb == channels_bg_rgb(channels)); + if(ncchannels_bg_rgb(channels) & CELL_BG_RGB_MASK){ + CHECK(0xffccbb == ncchannels_bg_rgb(channels)); } free(c); } diff --git a/src/tests/stacking.cpp b/src/tests/stacking.cpp index ee15a905a..ea5493714 100644 --- a/src/tests/stacking.cpp +++ b/src/tests/stacking.cpp @@ -63,8 +63,8 @@ TEST_CASE("Stacking") { // ought yield space with white background FIXME currently just yields // a lower half block CHECK(0 == strcmp("\u2584", egc)); - CHECK(0xffffff == channels_fg_rgb(channels)); - CHECK(0xffffff == channels_bg_rgb(channels)); + CHECK(0xffffff == ncchannels_fg_rgb(channels)); + CHECK(0xffffff == ncchannels_bg_rgb(channels)); ncplane_destroy(top); } @@ -101,8 +101,8 @@ TEST_CASE("Stacking") { // ought yield space with white background FIXME currently just yields // an upper half block CHECK(0 == strcmp("\u2580", egc)); - CHECK(0xffffff == channels_fg_rgb(channels)); - CHECK(0xffffff == channels_bg_rgb(channels)); + CHECK(0xffffff == ncchannels_fg_rgb(channels)); + CHECK(0xffffff == ncchannels_bg_rgb(channels)); ncplane_destroy(top); } @@ -140,8 +140,8 @@ TEST_CASE("Stacking") { // ought yield space with white background FIXME currently just yields // an upper half block CHECK(0 == strcmp("\u2580", egc)); - CHECK(0x00ff00 == channels_fg_rgb(channels)); - CHECK(0x00ff00 == channels_bg_rgb(channels)); + CHECK(0x00ff00 == ncchannels_fg_rgb(channels)); + CHECK(0x00ff00 == ncchannels_bg_rgb(channels)); ncplane_destroy(top); } } @@ -182,8 +182,8 @@ TEST_CASE("Stacking") { // ought yield space with white background FIXME currently just yields // an upper half block CHECK(0 == strcmp("\u259a", egc)); // quadrant upper left and lower right - CHECK(0xffffff == channels_fg_rgb(channels)); - CHECK(0xffffff == channels_bg_rgb(channels)); + CHECK(0xffffff == ncchannels_fg_rgb(channels)); + CHECK(0xffffff == ncchannels_bg_rgb(channels)); ncplane_destroy(top); } } diff --git a/src/tests/visual.cpp b/src/tests/visual.cpp index 60844afd1..adf66df05 100644 --- a/src/tests/visual.cpp +++ b/src/tests/visual.cpp @@ -142,8 +142,8 @@ TEST_CASE("Visual") { uint64_t channels; char* egc = notcurses_at_yx(nc_, y, x, &stylemask, &channels); REQUIRE(nullptr != egc); - CHECK((htole(rgba[y * 2 * DIMX + x]) & 0xffffff) == channels_bg_rgb(channels)); - CHECK((htole(rgba[(y * 2 + 1) * DIMX + x]) & 0xffffff) == channels_fg_rgb(channels)); + CHECK((htole(rgba[y * 2 * DIMX + x]) & 0xffffff) == ncchannels_bg_rgb(channels)); + CHECK((htole(rgba[(y * 2 + 1) * DIMX + x]) & 0xffffff) == ncchannels_fg_rgb(channels)); free(egc); } } @@ -183,8 +183,8 @@ TEST_CASE("Visual") { uint64_t channels; char* egc = notcurses_at_yx(nc_, y, x, &stylemask, &channels); REQUIRE(nullptr != egc); - CHECK((htole(rgba[(y * 2 * DIMX) + (x * 2)]) & 0xffffff) == channels_fg_rgb(channels)); - CHECK((htole(rgba[(y * 2 + 1) * DIMX + (x * 2) + 1]) & 0xffffff) == channels_fg_rgb(channels)); + CHECK((htole(rgba[(y * 2 * DIMX) + (x * 2)]) & 0xffffff) == ncchannels_fg_rgb(channels)); + CHECK((htole(rgba[(y * 2 + 1) * DIMX + (x * 2) + 1]) & 0xffffff) == ncchannels_fg_rgb(channels)); free(egc); } } @@ -300,8 +300,8 @@ TEST_CASE("Visual") { auto egc = ncplane_at_yx(ncvp, 0, 0, &stylemask, &channels); CHECK(0 == strcmp(" ", egc)); CHECK(0 == stylemask); - CHECK(0x405060 == channels_fg_rgb(channels)); - CHECK(0x405060 == channels_bg_rgb(channels)); + CHECK(0x405060 == ncchannels_fg_rgb(channels)); + CHECK(0x405060 == ncchannels_bg_rgb(channels)); free(egc); ncvisual_destroy(ncv); } @@ -345,8 +345,8 @@ TEST_CASE("Visual") { auto egc = ncplane_at_yx(ncvp, 0, 0, &stylemask, &channels); CHECK(0 == strcmp(egcs[i], egc)); CHECK(0 == stylemask); - CHECK(0x405060 == channels_fg_rgb(channels)); - CHECK(0xcccccc == channels_bg_rgb(channels)); + CHECK(0x405060 == ncchannels_fg_rgb(channels)); + CHECK(0xcccccc == ncchannels_bg_rgb(channels)); free(egc); ncvisual_destroy(ncv); } @@ -394,11 +394,11 @@ TEST_CASE("Visual") { CHECK(0 == strcmp(egcs[i], egc)); CHECK(0 == stylemask); if(i >= 3){ - CHECK(0x405060 == channels_fg_rgb(channels)); - CHECK(0xcccccc == channels_bg_rgb(channels)); + CHECK(0x405060 == ncchannels_fg_rgb(channels)); + CHECK(0xcccccc == ncchannels_bg_rgb(channels)); }else{ - CHECK(0x405060 == channels_bg_rgb(channels)); - CHECK(0xcccccc == channels_fg_rgb(channels)); + CHECK(0x405060 == ncchannels_bg_rgb(channels)); + CHECK(0xcccccc == ncchannels_fg_rgb(channels)); } free(egc); ncvisual_destroy(ncv); @@ -447,11 +447,11 @@ TEST_CASE("Visual") { CHECK(0 == strcmp(egcs[i], egc)); CHECK(0 == stylemask); if(i > 3){ - CHECK(0x405060 == channels_fg_rgb(channels)); - CHECK(0xdddddd == channels_bg_rgb(channels)); + CHECK(0x405060 == ncchannels_fg_rgb(channels)); + CHECK(0xdddddd == ncchannels_bg_rgb(channels)); }else{ - CHECK(0x424c57 == channels_fg_rgb(channels)); - CHECK(0xcccccc == channels_bg_rgb(channels)); + CHECK(0x424c57 == ncchannels_fg_rgb(channels)); + CHECK(0xcccccc == ncchannels_bg_rgb(channels)); } free(egc); ncvisual_destroy(ncv); @@ -498,8 +498,8 @@ TEST_CASE("Visual") { auto egc = ncplane_at_yx(ncvp, 0, 0, &stylemask, &channels); CHECK(0 == strcmp(egcs[i], egc)); CHECK(0 == stylemask); - CHECK(0x111111 == channels_fg_rgb(channels)); - CHECK(0xdddddd == channels_bg_rgb(channels)); + CHECK(0x111111 == ncchannels_fg_rgb(channels)); + CHECK(0xdddddd == ncchannels_bg_rgb(channels)); free(egc); ncvisual_destroy(ncv); } diff --git a/src/tests/wide.cpp b/src/tests/wide.cpp index e2b5a0cd2..1cb40d4ab 100644 --- a/src/tests/wide.cpp +++ b/src/tests/wide.cpp @@ -416,8 +416,8 @@ TEST_CASE("Wide") { int sbytes; CHECK(2 == ncplane_putegc_yx(n_, 1, 1, "六", &sbytes)); uint64_t channels = 0; - channels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); - channels_set_bg_rgb8(&channels, 0x80, 0xf0, 0x10); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_BLEND); + ncchannels_set_bg_rgb8(&channels, 0x80, 0xf0, 0x10); CHECK(1 == ncplane_set_base(p, " ", 0, channels)); CHECK(0 == notcurses_render(nc_)); uint16_t stylemask; @@ -1011,7 +1011,7 @@ TEST_CASE("Wide") { char* egc = notcurses_at_yx(nc_, 0, 0, &stylemask, &channels); REQUIRE(egc); CHECK(0 == stylemask); - CHECK(0xff00ff == channels_fg_rgb(channels)); + CHECK(0xff00ff == ncchannels_fg_rgb(channels)); CHECK(0 == strcmp("\u2658", egc)); free(egc); } @@ -1030,7 +1030,7 @@ TEST_CASE("Wide") { char* egc = notcurses_at_yx(nc_, 0, 0, &stylemask, &channels); REQUIRE(egc); CHECK(0 == stylemask); - CHECK(0xff00ff == channels_fg_rgb(channels)); + CHECK(0xff00ff == ncchannels_fg_rgb(channels)); CHECK(0 == strcmp("\u2658", egc)); free(egc); } diff --git a/src/tetris/background.h b/src/tetris/background.h index 2c7bf3b5d..c8e753d02 100644 --- a/src/tetris/background.h +++ b/src/tetris/background.h @@ -18,15 +18,15 @@ void DrawBoard() { // draw all fixed components of the game board_ = std::make_unique(BOARD_HEIGHT, BOARD_WIDTH * 2, board_top_y_, x / 2 - (BOARD_WIDTH + 1)); uint64_t channels = 0; - channels_set_fg_rgb(&channels, 0x00b040); - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_rgb(&channels, 0x00b040); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); board_->double_box(0, channels, BOARD_HEIGHT - 1, BOARD_WIDTH * 2 - 1, NCBOXMASK_TOP); - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); board_->set_base("", 0, channels); scoreplane_ = std::make_unique(2, 30, y - BOARD_HEIGHT, 2, nullptr); uint64_t scorechan = 0; - channels_set_bg_alpha(&scorechan, CELL_ALPHA_TRANSPARENT); - channels_set_fg_alpha(&scorechan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&scorechan, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&scorechan, CELL_ALPHA_TRANSPARENT); scoreplane_->set_base("", 0, scorechan); scoreplane_->set_bg_alpha(CELL_ALPHA_TRANSPARENT); scoreplane_->set_fg_rgb(0xd040d0); diff --git a/src/tetris/newpiece.h b/src/tetris/newpiece.h index 1deef3dc9..fb1a891e8 100644 --- a/src/tetris/newpiece.h +++ b/src/tetris/newpiece.h @@ -19,8 +19,8 @@ std::unique_ptr NewPiece() { std::unique_ptr n = std::make_unique(2, cols, board_top_y_ - 1, xoff, nullptr); if(n){ uint64_t channels = 0; - channels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); - channels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_bg_alpha(&channels, CELL_ALPHA_TRANSPARENT); + ncchannels_set_fg_alpha(&channels, CELL_ALPHA_TRANSPARENT); n->set_fg_rgb(t->color); n->set_bg_alpha(CELL_ALPHA_TRANSPARENT); n->set_base("", 0, channels);