Archives
/
notcurses
mirror of https://github.com/dankamongmen/notcurses
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

s/channels/ncchannels/g #1570

Browse Source
pull/1606/head
nick black 3 years ago 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

3
NEWS.md
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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);

Write Preview
Loading…
Cancel
Save