|
|
|
@ -9,59 +9,59 @@
|
|
|
|
|
//
|
|
|
|
|
// static inline functions to reimplement: 45
|
|
|
|
|
// ------------------------------------------ (done / (x) wont / remaining)
|
|
|
|
|
// (+) implement : 2 / 0 / 43
|
|
|
|
|
// (+) implement : 24 / 0 / 21
|
|
|
|
|
// (#) unit tests: 0 / 0 / 45
|
|
|
|
|
// ------------------------------------------
|
|
|
|
|
// cell_bchannel
|
|
|
|
|
//+cell_bchannel
|
|
|
|
|
// cell_bg
|
|
|
|
|
// cell_bg_alpha
|
|
|
|
|
// cell_bg_default_p
|
|
|
|
|
// cell_bg_palindex
|
|
|
|
|
// cell_bg_palindex_p
|
|
|
|
|
// cell_bg_rgb
|
|
|
|
|
//+cell_bg_rgb
|
|
|
|
|
// cell_blend_bchannel
|
|
|
|
|
// cell_blend_fchannel
|
|
|
|
|
// cellcmp
|
|
|
|
|
// cell_double_wide_p
|
|
|
|
|
// cell_extract
|
|
|
|
|
// cell_fchannel
|
|
|
|
|
//+cellcmp
|
|
|
|
|
//+cell_double_wide_p
|
|
|
|
|
//+cell_extract
|
|
|
|
|
//+cell_fchannel
|
|
|
|
|
// cell_fg
|
|
|
|
|
// cell_fg_alpha
|
|
|
|
|
// cell_fg_default_p
|
|
|
|
|
// cell_fg_palindex
|
|
|
|
|
// cell_fg_palindex_p
|
|
|
|
|
// cell_fg_rgb
|
|
|
|
|
// cell_init
|
|
|
|
|
// cell_load_simple
|
|
|
|
|
//+cell_fg_rgb
|
|
|
|
|
//+cell_init
|
|
|
|
|
//+cell_load_simple
|
|
|
|
|
//+cell_prime
|
|
|
|
|
// cell_set_bchannel
|
|
|
|
|
//+cell_set_bchannel
|
|
|
|
|
// cell_set_bg
|
|
|
|
|
// cell_set_bg_alpha
|
|
|
|
|
//+cell_set_bg_alpha
|
|
|
|
|
// cell_set_bg_default
|
|
|
|
|
// cell_set_bg_palindex
|
|
|
|
|
// cell_set_bg_rgb
|
|
|
|
|
// cell_set_bg_rgb_clipped
|
|
|
|
|
// cell_set_fchannel
|
|
|
|
|
//+cell_set_fchannel
|
|
|
|
|
// cell_set_fg
|
|
|
|
|
// cell_set_fg_alpha
|
|
|
|
|
// cell_set_fg_default
|
|
|
|
|
// cell_set_fg_palindex
|
|
|
|
|
//+cell_set_fg_alpha
|
|
|
|
|
//+cell_set_fg_default
|
|
|
|
|
//+cell_set_fg_palindex
|
|
|
|
|
// cell_set_fg_rgb
|
|
|
|
|
// cell_set_fg_rgb_clipped
|
|
|
|
|
// cell_simple_p
|
|
|
|
|
//+cells_load_box // FIXME
|
|
|
|
|
// cell_strdup
|
|
|
|
|
// cell_styles
|
|
|
|
|
// cell_styles_off
|
|
|
|
|
// cell_styles_on
|
|
|
|
|
// cell_styles_set
|
|
|
|
|
// cell_wide_left_p
|
|
|
|
|
// cell_wide_right_p
|
|
|
|
|
//+cell_strdup
|
|
|
|
|
//+cell_styles
|
|
|
|
|
//+cell_styles_off
|
|
|
|
|
//+cell_styles_on
|
|
|
|
|
//+cell_styles_set
|
|
|
|
|
//+cell_wide_left_p
|
|
|
|
|
//+cell_wide_right_p
|
|
|
|
|
|
|
|
|
|
use cstr_core::CString;
|
|
|
|
|
|
|
|
|
|
use crate as ffi;
|
|
|
|
|
use ffi::types::{ChannelPair, IntResult};
|
|
|
|
|
use ffi::types::{AlphaBits, Channel, ChannelPair, Color, GraphemeCluster, IntResult, StyleMask};
|
|
|
|
|
use ffi::{cell, ncplane};
|
|
|
|
|
|
|
|
|
|
/// cell_load(), plus blast the styling with 'attr' and 'channels'.
|
|
|
|
@ -108,6 +108,7 @@ pub fn cells_load_box(
|
|
|
|
|
) -> IntResult {
|
|
|
|
|
cell_prime(plane, _ul, gcluster, style, channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// static inline int
|
|
|
|
|
// cells_load_box(struct ncplane* n, uint32_t style, uint64_t channels,
|
|
|
|
|
// cell* ul, cell* ur, cell* ll, cell* lr,
|
|
|
|
@ -134,192 +135,227 @@ pub fn cells_load_box(
|
|
|
|
|
// return -1;
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_init(cell* c){
|
|
|
|
|
// memset(c, 0, sizeof(*c));
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// Set the specified style bits for the cell 'c', whether they're actively
|
|
|
|
|
// supported or not. Only the lower 16 bits are meaningful.
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_styles_set(cell* c, unsigned stylebits){
|
|
|
|
|
// c->stylemask = stylebits & NCSTYLE_MASK;
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract the style bits from the cell.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_styles(const cell* c){
|
|
|
|
|
// return c->stylemask;
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Add the specified styles (in the LSBs) to the cell's existing spec, whether
|
|
|
|
|
// // they're actively supported or not.
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_styles_on(cell* c, unsigned stylebits){
|
|
|
|
|
// c->stylemask |= (stylebits & NCSTYLE_MASK);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Remove the specified styles (in the LSBs) from the cell's existing spec.
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_styles_off(cell* c, unsigned stylebits){
|
|
|
|
|
// c->stylemask &= ~(stylebits & NCSTYLE_MASK);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Use the default color for the foreground.
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_set_fg_default(cell* c){
|
|
|
|
|
// channels_set_fg_default(&c->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Use the default color for the background.
|
|
|
|
|
// static inline void
|
|
|
|
|
// cell_set_bg_default(cell* c){
|
|
|
|
|
// channels_set_bg_default(&c->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// static inline int
|
|
|
|
|
// cell_set_fg_alpha(cell* c, int alpha){
|
|
|
|
|
// return channels_set_fg_alpha(&c->channels, alpha);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// static inline int
|
|
|
|
|
// cell_set_bg_alpha(cell* c, int alpha){
|
|
|
|
|
// return channels_set_bg_alpha(&c->channels, alpha);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Does the cell contain an East Asian Wide codepoint?
|
|
|
|
|
// static inline bool
|
|
|
|
|
// cell_double_wide_p(const cell* c){
|
|
|
|
|
// return (c->channels & CELL_WIDEASIAN_MASK);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Is this the right half of a wide character?
|
|
|
|
|
// static inline bool
|
|
|
|
|
// cell_wide_right_p(const cell* c){
|
|
|
|
|
// return cell_double_wide_p(c) && c->gcluster == 0;
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Is this the left half of a wide character?
|
|
|
|
|
// static inline bool
|
|
|
|
|
// cell_wide_left_p(const cell* c){
|
|
|
|
|
// return cell_double_wide_p(c) && c->gcluster;
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // copy the UTF8-encoded EGC out of the cell, whether simple or complex. the
|
|
|
|
|
// // result is not tied to the ncplane, and persists across erases / destruction.
|
|
|
|
|
// static inline char*
|
|
|
|
|
// cell_strdup(const struct ncplane* n, const cell* c){
|
|
|
|
|
// return strdup(cell_extended_gcluster(n, c));
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract the three elements of a cell.
|
|
|
|
|
// static inline char*
|
|
|
|
|
// cell_extract(const struct ncplane* n, const cell* c,
|
|
|
|
|
// uint16_t* stylemask, uint64_t* channels){
|
|
|
|
|
// if(stylemask){
|
|
|
|
|
// *stylemask = c->stylemask;
|
|
|
|
|
// }
|
|
|
|
|
// if(channels){
|
|
|
|
|
// *channels = c->channels;
|
|
|
|
|
// }
|
|
|
|
|
// return cell_strdup(n, c);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Returns true if the two cells are distinct EGCs, attributes, or channels.
|
|
|
|
|
// // The actual egcpool index needn't be the same--indeed, the planes needn't even
|
|
|
|
|
// // be the same. Only the expanded EGC must be equal. The EGC must be bit-equal;
|
|
|
|
|
// // it would probably be better to test whether they're Unicode-equal FIXME.
|
|
|
|
|
// static inline bool
|
|
|
|
|
// cellcmp(const struct ncplane* n1, const cell* RESTRICT c1,
|
|
|
|
|
// const struct ncplane* n2, const cell* RESTRICT c2){
|
|
|
|
|
// if(c1->stylemask != c2->stylemask){
|
|
|
|
|
// return true;
|
|
|
|
|
// }
|
|
|
|
|
// if(c1->channels != c2->channels){
|
|
|
|
|
// return true;
|
|
|
|
|
// }
|
|
|
|
|
// return strcmp(cell_extended_gcluster(n1, c1), cell_extended_gcluster(n2, c2));
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// static inline int
|
|
|
|
|
// cell_load_simple(struct ncplane* n, cell* c, char ch){
|
|
|
|
|
// cell_release(n, c);
|
|
|
|
|
// c->channels &= ~(CELL_WIDEASIAN_MASK | CELL_NOBACKGROUND_MASK);
|
|
|
|
|
// c->gcluster = ch;
|
|
|
|
|
// return 1;
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract the 32-bit background channel from a cell.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_bchannel(const cell* cl){
|
|
|
|
|
// return channels_bchannel(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract the 32-bit foreground channel from a cell.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_fchannel(const cell* cl){
|
|
|
|
|
// return channels_fchannel(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Set the 32-bit background channel of a cell.
|
|
|
|
|
// static inline uint64_t
|
|
|
|
|
// cell_set_bchannel(cell* cl, uint32_t channel){
|
|
|
|
|
// return channels_set_bchannel(&cl->channels, channel);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Set the 32-bit foreground channel of a cell.
|
|
|
|
|
// static inline uint64_t
|
|
|
|
|
// cell_set_fchannel(cell* cl, uint32_t channel){
|
|
|
|
|
// return channels_set_fchannel(&cl->channels, channel);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // do not pass palette-indexed channels!
|
|
|
|
|
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_init(cell: &mut cell) {
|
|
|
|
|
*cell = unsafe { core::mem::zeroed() }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Set the specified style bits for the cell 'c', whether they're actively
|
|
|
|
|
/// supported or not. Only the lower 16 bits are meaningful.
|
|
|
|
|
/// static inline void
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_styles_set(cell: &mut cell, stylebits: StyleMask) {
|
|
|
|
|
cell.stylemask = stylebits & ffi::NCSTYLE_MASK as u16;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract the style bits from the cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_styles(cell: &cell) -> StyleMask {
|
|
|
|
|
cell.stylemask
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Add the specified styles (in the LSBs) to the cell's existing spec, whether
|
|
|
|
|
/// they're actively supported or not.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_styles_on(cell: &mut cell, stylebits: StyleMask) {
|
|
|
|
|
cell.stylemask |= stylebits & ffi::NCSTYLE_MASK as u16;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Remove the specified styles (in the LSBs) from the cell's existing spec.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_styles_off(cell: &mut cell, stylebits: StyleMask) {
|
|
|
|
|
cell.stylemask &= !(stylebits & ffi::NCSTYLE_MASK as u16);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Use the default color for the foreground.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_fg_default(cell: &mut cell) {
|
|
|
|
|
ffi::channels_set_fg_default(&mut cell.channels);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Use the default color for the background.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_bg_default(cell: &mut cell) {
|
|
|
|
|
ffi::channels_set_bg_default(&mut cell.channels);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Set the foreground alpha.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_fg_alpha(cell: &mut cell, alpha: AlphaBits) {
|
|
|
|
|
ffi::channels_set_fg_alpha(&mut cell.channels, alpha);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Set the background alpha.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_bg_alpha(cell: &mut cell, alpha: AlphaBits) {
|
|
|
|
|
ffi::channels_set_bg_alpha(&mut cell.channels, alpha);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Does the cell contain an East Asian Wide codepoint?
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
// NOTE: remove casting when fixed: https://github.com/rust-lang/rust-bindgen/issues/1875
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_double_wide_p(cell: &cell) -> bool {
|
|
|
|
|
(cell.channels & ffi::CELL_WIDEASIAN_MASK as u64) != 0
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Is this the right half of a wide character?
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_wide_right_p(cell: &cell) -> bool {
|
|
|
|
|
cell_double_wide_p(cell) && cell.gcluster == 0
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Is this the left half of a wide character?
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_wide_left_p(cell: &cell) -> bool {
|
|
|
|
|
cell_double_wide_p(cell) && cell.gcluster != 0
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// copy the UTF8-encoded EGC out of the cell, whether simple or complex. the
|
|
|
|
|
/// result is not tied to the ncplane, and persists across erases / destruction.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_strdup(plane: &ncplane, cell: &cell) -> *mut i8 {
|
|
|
|
|
unsafe{
|
|
|
|
|
libc::strdup(ffi::cell_extended_gcluster(plane, cell))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract the three elements of a cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_extract(plane: &ncplane, cell: &cell, stylemask: &mut StyleMask, channels: &mut ChannelPair) -> *mut i8 {
|
|
|
|
|
if *stylemask != 0 {
|
|
|
|
|
*stylemask = cell.stylemask;
|
|
|
|
|
}
|
|
|
|
|
if *channels != 0 {
|
|
|
|
|
*channels = cell.channels;
|
|
|
|
|
}
|
|
|
|
|
cell_strdup(plane, cell)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true if the two cells are distinct EGCs, attributes, or channels.
|
|
|
|
|
/// The actual egcpool index needn't be the same--indeed, the planes needn't even
|
|
|
|
|
/// be the same. Only the expanded EGC must be equal. The EGC must be bit-equal;
|
|
|
|
|
/// it would probably be better to test whether they're Unicode-equal FIXME.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cellcmp(plane1: &ncplane, cell1: &cell, plane2: &ncplane, cell2: &cell) -> bool {
|
|
|
|
|
if cell1.stylemask != cell2.stylemask {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
if cell1.channels != cell2.channels {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
unsafe {
|
|
|
|
|
libc::strcmp(ffi::cell_extended_gcluster(plane1, cell1), ffi::cell_extended_gcluster(plane2, cell2)) != 0
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
// NOTE: remove casting when fixed: https://github.com/rust-lang/rust-bindgen/issues/1875
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_load_simple(plane: &mut ncplane, cell: &mut cell, ch: char) -> i32 {
|
|
|
|
|
unsafe { ffi::cell_release(plane, cell); }
|
|
|
|
|
cell.channels &= !(ffi::CELL_WIDEASIAN_MASK as u64 | ffi::CELL_NOBACKGROUND_MASK);
|
|
|
|
|
cell.gcluster = ch as GraphemeCluster;
|
|
|
|
|
1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract the 32-bit background channel from a cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_bchannel(cell: &cell) -> Channel {
|
|
|
|
|
ffi::channels_bchannel(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract the 32-bit foreground channel from a cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_fchannel(cell: &cell) -> Channel {
|
|
|
|
|
ffi::channels_fchannel(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Set the 32-bit background channel of a cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_bchannel(cell: &mut cell, channel: Channel) -> ChannelPair {
|
|
|
|
|
ffi::channels_set_bchannel(&mut cell.channels, channel)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Set the 32-bit foreground channel of a cell.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_set_fchannel(cell: &mut cell, channel: Channel) -> ChannelPair {
|
|
|
|
|
ffi::channels_set_fchannel(&mut cell.channels, channel)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NOTE: do not pass palette-indexed channels!
|
|
|
|
|
// static inline uint64_t
|
|
|
|
|
// cell_blend_fchannel(cell* cl, unsigned channel, unsigned* blends){
|
|
|
|
|
// return cell_set_fchannel(cl, channels_blend(cell_fchannel(cl), channel, blends));
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
// NOTE: do not pass palette-indexed channels!
|
|
|
|
|
// static inline uint64_t
|
|
|
|
|
// cell_blend_bchannel(cell* cl, unsigned channel, unsigned* blends){
|
|
|
|
|
// return cell_set_bchannel(cl, channels_blend(cell_bchannel(cl), channel, blends));
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 24 bits of foreground RGB from 'cell', shifted to LSBs.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_fg(const cell* cl){
|
|
|
|
|
// return channels_fg(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 24 bits of background RGB from 'cell', shifted to LSBs.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_bg(const cell* cl){
|
|
|
|
|
// return channels_bg(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 2 bits of foreground alpha from 'cell', shifted to LSBs.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_fg_alpha(const cell* cl){
|
|
|
|
|
// return channels_fg_alpha(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 2 bits of background alpha from 'cell', shifted to LSBs.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_bg_alpha(const cell* cl){
|
|
|
|
|
// return channels_bg_alpha(cl->channels);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 24 bits of foreground RGB from 'cell', split into components.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_fg_rgb(const cell* cl, unsigned* r, unsigned* g, unsigned* b){
|
|
|
|
|
// return channels_fg_rgb(cl->channels, r, g, b);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
// // Extract 24 bits of background RGB from 'cell', split into components.
|
|
|
|
|
// static inline unsigned
|
|
|
|
|
// cell_bg_rgb(const cell* cl, unsigned* r, unsigned* g, unsigned* b){
|
|
|
|
|
// return channels_bg_rgb(cl->channels, r, g, b);
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
/// Extract 24 bits of foreground RGB from 'cell', shifted to LSBs.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_fg(cell: &cell) -> Channel {
|
|
|
|
|
ffi::channels_fg(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract 24 bits of background RGB from 'cell', shifted to LSBs.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_bg(cell: &cell) -> Channel {
|
|
|
|
|
ffi::channels_bg(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract 2 bits of foreground alpha from 'cell', shifted to LSBs.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_fg_alpha(cell: &cell) -> AlphaBits {
|
|
|
|
|
ffi::channels_fg_alpha(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract 2 bits of background alpha from 'cell', shifted to LSBs.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_bg_alpha(cell: &cell) -> AlphaBits {
|
|
|
|
|
ffi::channels_bg_alpha(cell.channels)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract 24 bits of foreground RGB from 'cell', split into components.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_fg_rgb(cell: &cell, red: &mut Color, green: &mut Color, blue: &mut Color) -> Channel {
|
|
|
|
|
ffi::channels_fg_rgb(cell.channels, red, green, blue)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Extract 24 bits of background RGB from 'cell', split into components.
|
|
|
|
|
// TODO: TEST
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn cell_bg_rgb(cell: &cell, red: &mut Color, green: &mut Color, blue: &mut Color) -> Channel {
|
|
|
|
|
ffi::channels_bg_rgb(cell.channels, red, green, blue)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// // 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
|
|
|
|
|