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

s/channels/ncchannels/g #1570

Browse Source
This commit is contained in:
nick black 2021-04-29 01:18:37 -04:00 committed by Nick Black
parent decb36a9fd
commit 3eb004b61d
58 changed files with 766 additions and 621 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
NEWS.md
View File

@ -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,

126
USAGE.md
View File

@ -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;

40
doc/man/man3/notcurses_channels.3.md
View File

@ -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

340
include/notcurses/notcurses.h
View File

@ -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

4
src/demo/animate.c
View File

@ -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;

4
src/demo/demo.c
View File

@ -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;
}

58
src/demo/hud.c
View File

@ -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(&sectionchannels, 0xffffff);
channels_set_bg_rgb(&sectionchannels, 0x000000);
channels_set_fg_alpha(&sectionchannels, CELL_ALPHA_HIGHCONTRAST);
channels_set_bg_alpha(&sectionchannels, 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(&sectionchannels, 0xffffff);
ncchannels_set_bg_rgb(&sectionchannels, 0x000000);
ncchannels_set_fg_alpha(&sectionchannels, CELL_ALPHA_HIGHCONTRAST);
ncchannels_set_bg_alpha(&sectionchannels, 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);

8
src/demo/intro.c
View File

@ -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;

4
src/demo/keller.c
View File

@ -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 = {

8
src/demo/luigi.c
View File

@ -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);

2
src/demo/mojibake.c
View File

@ -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;

8
src/demo/normal.c
View File

@ -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;

6
src/demo/outro.c
View File

@ -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;
}

16
src/demo/reel.c
View File

@ -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;
}

4
src/demo/sliding.c
View File

@ -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,

4
src/demo/trans.c
View File

@ -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)){

10
src/demo/unicodeblocks.c
View File

@ -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);

6
src/demo/view.c
View File

@ -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);

14
src/demo/whiteout.c
View File

@ -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;

8
src/demo/xray.c
View File

@ -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,

4
src/demo/yield.c
View File

@ -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);

12
src/demo/zoo.c
View File

@ -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

6
src/fetch/main.c
View File

@ -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;

4
src/input/input.cpp
View File

@ -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<ncblitter_e>(NCBLIT_8x1);
plot = ncuplot_create(pplane, &popts, 0, 0);
if(!plot){

8
src/lib/blit.c
View File

@ -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];
}

88
src/lib/direct.c
View File

@ -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;
}

20
src/lib/fade.c
View File

@ -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;

10
src/lib/fill.c
View File

@ -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);
}

44
src/lib/internal.h
View File

@ -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,

4
src/lib/menu.c
View File

@ -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);

56
src/lib/notcurses.c
View File

@ -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;

16
src/lib/plot.c
View File

@ -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); \
} \
} \

8
src/lib/render.c
View File

@ -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;
}

10
src/lib/selector.c
View File

@ -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){

8
src/player/play.cpp
View File

@ -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<Plane> 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.

16
src/poc/dirlines.c
View File

@ -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;
}

16
src/poc/menu.c
View File

@ -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;
}

4
src/poc/multiselect.c
View File

@ -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)){

4
src/poc/progbar.c
View File

@ -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;

4
src/poc/selector.c
View File

@ -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)){

4
src/poc/textplay.c
View File

@ -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);
}

6
src/poc/tree.c
View File

@ -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);

6
src/pocpp/reel.cpp
View File

@ -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){

4
src/tests/bitmap.cpp
View File

@ -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);

4
src/tests/blit.cpp
View File

@ -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));

20
src/tests/cell.cpp
View File

@ -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);

98
src/tests/fills.cpp
View File

@ -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 = {

38
src/tests/notcurses.cpp
View File

@ -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"){

44
src/tests/plane.cpp
View File

@ -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_));
}

20
src/tests/plot.cpp
View File

@ -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);

2
src/tests/reel.cpp
View File

@ -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,

16
src/tests/resize.cpp
View File

@ -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") {

36
src/tests/rotate.cpp
View File

@ -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);
}

16
src/tests/stacking.cpp
View File

@ -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);
}
}

36
src/tests/visual.cpp
View File

@ -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);
}

8
src/tests/wide.cpp
View File

@ -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);
}

10
src/tetris/background.h
View File

@ -18,15 +18,15 @@ void DrawBoard() { // draw all fixed components of the game
board_ = std::make_unique<ncpp::Plane>(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<ncpp::Plane>(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);

4
src/tetris/newpiece.h
View File

@ -19,8 +19,8 @@ std::unique_ptr<ncpp::Plane> NewPiece() {
std::unique_ptr<ncpp::Plane> n = std::make_unique<ncpp::Plane>(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);