use crate::{
c_api::{self, NcAlpha_u32, NcChannel_u32, NcChannels_u64, NcResult_i32, NcRgb_u32},
NcPaletteIndex,
};
#[allow(unused_imports)]
use crate::{NcChannel, NcChannels};
#[inline]
pub fn ncchannel_alpha(channel: impl Into<NcChannel_u32>) -> NcAlpha_u32 {
channel.into() & c_api::NC_BG_ALPHA_MASK
}
#[inline]
pub fn ncchannel_set_alpha(
channel: &mut NcChannel_u32,
alpha: impl Into<NcAlpha_u32>,
) -> NcResult_i32 {
let alpha = alpha.into();
if (alpha & !c_api::NC_BG_ALPHA_MASK) != 0 {
return c_api::NCRESULT_ERR;
}
*channel = alpha | (*channel & !c_api::NC_BG_ALPHA_MASK);
if alpha != c_api::NCALPHA_OPAQUE {
*channel |= c_api::NC_BGDEFAULT_MASK;
}
c_api::NCRESULT_OK
}
#[inline]
pub fn ncchannels_fg_alpha(channels: impl Into<NcChannels_u64>) -> NcAlpha_u32 {
ncchannel_alpha(ncchannels_fchannel(channels))
}
#[inline]
pub fn ncchannels_bg_alpha(channels: impl Into<NcChannels_u64>) -> NcAlpha_u32 {
ncchannel_alpha(ncchannels_bchannel(channels))
}
#[inline]
pub fn ncchannels_set_fg_alpha(
channels: &mut NcChannels_u64,
alpha: impl Into<NcAlpha_u32>,
) -> NcResult_i32 {
let mut channel = ncchannels_fchannel(*channels);
if ncchannel_set_alpha(&mut channel, alpha.into()) < 0 {
return c_api::NCRESULT_ERR;
}
*channels = (channel as NcChannels_u64) << 32 | *channels & 0xffffffff_u64;
c_api::NCRESULT_OK
}
#[inline]
pub fn ncchannels_set_bg_alpha(
channels: &mut NcChannels_u64,
alpha: impl Into<NcAlpha_u32>,
) -> NcResult_i32 {
let alpha = alpha.into();
if alpha == c_api::NCALPHA_HIGHCONTRAST {
return c_api::NCRESULT_ERR;
}
let mut channel = ncchannels_bchannel(*channels);
if ncchannel_set_alpha(&mut channel, alpha) < 0 {
return c_api::NCRESULT_ERR;
}
ncchannels_set_bchannel(channels, channel);
c_api::NCRESULT_OK
}
#[inline]
pub fn ncchannels_bchannel(channels: impl Into<NcChannels_u64>) -> NcChannel_u32 {
(channels.into()
& (c_api::NC_BG_RGB_MASK
| c_api::NC_BG_PALETTE
| c_api::NC_BGDEFAULT_MASK
| c_api::NC_BG_ALPHA_MASK) as NcChannels_u64) as NcChannel_u32
}
#[inline]
pub fn ncchannels_fchannel(channels: impl Into<NcChannels_u64>) -> NcChannel_u32 {
ncchannels_bchannel(channels.into() >> 32)
}
#[inline]
pub fn ncchannels_channels(channels: impl Into<NcChannels_u64>) -> NcChannels_u64 {
let channels = channels.into();
ncchannels_bchannel(channels) as NcChannels_u64
| (ncchannels_fchannel(channels) as NcChannels_u64) << 32
}
#[inline]
pub fn ncchannels_set_bchannel(
channels: &mut NcChannels_u64,
bchannel: impl Into<NcChannel_u32>,
) -> NcChannels_u64 {
*channels &= (0xffffffff_u64 << 32) | c_api::NC_NOBACKGROUND_MASK;
*channels |= bchannel.into() as NcChannels_u64 & !c_api::NC_NOBACKGROUND_MASK;
*channels
}
#[inline]
pub fn ncchannels_set_fchannel(
channels: &mut NcChannels_u64,
fchannel: impl Into<NcChannel_u32>,
) -> NcChannels_u64 {
*channels &= 0xffffffff_u64 | c_api::NC_NOBACKGROUND_MASK << 32;
*channels |= (fchannel.into() as NcChannels_u64 & !c_api::NC_NOBACKGROUND_MASK) << 32;
*channels
}
#[inline]
pub fn ncchannels_set_channels(
channels: &mut NcChannels_u64,
other: impl Into<NcChannels_u64>,
) -> NcChannels_u64 {
let other = other.into();
ncchannels_set_bchannel(channels, (other & 0xffffffff_u64) as NcChannel_u32);
ncchannels_set_fchannel(channels, ((other >> 32) & 0xffffffff_u64) as NcChannel_u32);
*channels
}
#[inline]
pub fn ncchannels_combine(
fchannel: impl Into<NcChannel_u32>,
bchannel: impl Into<NcChannel_u32>,
) -> NcChannels_u64 {
let mut channels: NcChannels_u64 = 0;
ncchannels_set_fchannel(&mut channels, fchannel.into());
ncchannels_set_bchannel(&mut channels, bchannel.into());
channels
}
#[inline]
pub fn ncchannels_reverse(channels: impl Into<NcChannels_u64>) -> NcChannels_u64 {
let channels = channels.into();
let raw = ((ncchannels_bchannel(channels) as NcChannels_u64) << 32)
+ ncchannels_fchannel(channels) as NcChannels_u64;
let statemask = ((c_api::NC_NOBACKGROUND_MASK | c_api::NC_BG_ALPHA_MASK as NcChannels_u64)
<< 32)
| c_api::NC_NOBACKGROUND_MASK
| c_api::NC_BG_ALPHA_MASK as NcChannels_u64;
let mut ret = (raw as NcChannels_u64) & !statemask;
ret |= channels & statemask;
if ncchannels_bg_alpha(ret) != c_api::NCALPHA_OPAQUE && !ncchannels_bg_rgb_p(ret) {
ncchannels_set_bg_alpha(&mut ret, c_api::NCALPHA_OPAQUE);
}
if ncchannels_fg_alpha(ret) != c_api::NCALPHA_OPAQUE && !ncchannels_fg_rgb_p(ret) {
ncchannels_set_fg_alpha(&mut ret, c_api::NCALPHA_OPAQUE);
}
ret
}
#[inline]
pub fn ncchannel_r(channel: impl Into<NcChannel_u32>) -> u8 {
((channel.into() & 0xff0000) >> 16) as u8
}
#[inline]
pub fn ncchannel_g(channel: impl Into<NcChannel_u32>) -> u8 {
((channel.into() & 0x00ff00) >> 8) as u8
}
#[inline]
pub fn ncchannel_b(channel: impl Into<NcChannel_u32>) -> u8 {
(channel.into() & 0x0000ff) as u8
}
#[inline]
pub fn ncchannel_set_r(channel: &mut NcChannel_u32, r: u8) -> NcChannel_u32 {
*channel = (r as NcChannel_u32) << 16 | (*channel & 0xff00) | (*channel & 0xff);
*channel
}
#[inline]
pub fn ncchannel_set_g(channel: &mut NcChannel_u32, g: u8) -> NcChannel_u32 {
*channel = (*channel & 0xff0000) | (g as NcChannel_u32) << 8 | (*channel & 0xff);
*channel
}
#[inline]
pub fn ncchannel_set_b(channel: &mut NcChannel_u32, b: u8) -> NcChannel_u32 {
*channel = (*channel & 0xff0000) | (*channel & 0xff00) | (b as NcChannel_u32);
*channel
}
#[inline]
pub fn ncchannel_rgb8(
channel: impl Into<NcChannel_u32>,
r: &mut u8,
g: &mut u8,
b: &mut u8,
) -> NcChannel_u32 {
let channel = channel.into();
*r = ncchannel_r(channel);
*g = ncchannel_g(channel);
*b = ncchannel_b(channel);
channel
}
#[inline]
pub fn ncchannel_set_rgb8(channel: &mut NcChannel_u32, r: u8, g: u8, b: u8) {
let rgb: NcRgb_u32 =
(r as NcChannel_u32) << 16 | (g as NcChannel_u32) << 8 | (b as NcChannel_u32);
*channel = (*channel & !(c_api::NC_BG_RGB_MASK | c_api::NC_BG_PALETTE))
| c_api::NC_BGDEFAULT_MASK
| rgb;
}
#[inline]
pub fn ncchannels_fg_rgb8(
channels: impl Into<NcChannels_u64>,
r: &mut u8,
g: &mut u8,
b: &mut u8,
) -> NcChannel_u32 {
ncchannel_rgb8(ncchannels_fchannel(channels.into()), r, g, b)
}
#[inline]
pub fn ncchannels_bg_rgb8(
channels: impl Into<NcChannels_u64>,
r: &mut u8,
g: &mut u8,
b: &mut u8,
) -> NcChannel_u32 {
ncchannel_rgb8(ncchannels_bchannel(channels.into()), r, g, b)
}
#[inline]
pub fn ncchannels_set_fg_rgb8(
channels: &mut NcChannels_u64,
r: u8,
g: u8,
b: u8,
) -> NcChannels_u64 {
let mut channel = ncchannels_fchannel(*channels);
ncchannel_set_rgb8(&mut channel, r, g, b);
*channels = (channel as NcChannels_u64) << 32 | *channels & 0xffffffff;
*channels
}
#[inline]
pub fn ncchannels_set_bg_rgb8(
channels: &mut NcChannels_u64,
r: u8,
g: u8,
b: u8,
) -> NcChannels_u64 {
let mut channel = ncchannels_bchannel(*channels);
ncchannel_set_rgb8(&mut channel, r, g, b);
ncchannels_set_bchannel(channels, channel);
*channels
}
#[inline]
pub fn ncchannels_fg_rgb(channels: impl Into<NcChannels_u64>) -> NcRgb_u32 {
ncchannels_fchannel(channels.into()) & c_api::NC_BG_RGB_MASK
}
#[inline]
pub fn ncchannels_bg_rgb(channels: impl Into<NcChannels_u64>) -> NcRgb_u32 {
ncchannels_bchannel(channels.into()) & c_api::NC_BG_RGB_MASK
}
#[inline]
pub fn ncchannels_fg_rgb_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_rgb_p(ncchannels_fchannel(channels.into()))
}
#[inline]
pub fn ncchannels_bg_rgb_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_rgb_p(ncchannels_bchannel(channels.into()))
}
#[inline]
pub fn ncchannel_rgb(channel: impl Into<NcChannel_u32>) -> NcRgb_u32 {
channel.into() & c_api::NC_BG_RGB_MASK
}
#[inline]
pub fn ncchannel_rgb_p(channel: impl Into<NcChannel_u32>) -> bool {
let channel = channel.into();
!(ncchannel_default_p(channel) | ncchannel_palindex_p(channel))
}
#[inline]
pub fn ncchannel_set(channel: &mut NcChannel_u32, rgb: impl Into<NcRgb_u32>) {
*channel = (*channel & !(c_api::NC_BG_RGB_MASK | c_api::NC_BG_PALETTE))
| c_api::NC_BGDEFAULT_MASK
| (rgb.into() & 0x00ffffff);
}
#[inline]
pub fn ncchannels_set_fg_rgb(channels: &mut NcChannels_u64, rgb: impl Into<NcRgb_u32>) {
let mut channel = ncchannels_fchannel(*channels);
ncchannel_set(&mut channel, rgb.into());
*channels = (channel as NcChannels_u64) << 32 | *channels & 0xffffffff;
}
#[inline]
pub fn ncchannels_set_bg_rgb(channels: &mut NcChannels_u64, rgb: impl Into<NcRgb_u32>) {
let mut channel = ncchannels_bchannel(*channels);
ncchannel_set(&mut channel, rgb);
ncchannels_set_bchannel(channels, channel);
}
#[inline]
pub fn ncchannel_default_p(channel: impl Into<NcChannel_u32>) -> bool {
(channel.into() & c_api::NC_BGDEFAULT_MASK) == 0
}
#[inline]
pub fn ncchannel_set_default(channel: &mut NcChannel_u32) -> NcChannel_u32 {
*channel &= !c_api::NC_BGDEFAULT_MASK; ncchannel_set_alpha(channel, c_api::NCALPHA_OPAQUE);
*channel
}
#[inline]
pub fn ncchannel_set_not_default(channel: &mut NcChannel_u32) -> NcChannel_u32 {
*channel |= c_api::NC_BGDEFAULT_MASK;
*channel
}
#[inline]
pub fn ncchannels_fg_default_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_default_p(ncchannels_fchannel(channels.into()))
}
#[inline]
pub fn ncchannels_bg_default_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_default_p(ncchannels_bchannel(channels.into()))
}
#[inline]
pub fn ncchannels_set_fg_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
let mut channel = ncchannels_fchannel(*channels);
ncchannel_set_default(&mut channel);
*channels = (channel as NcChannels_u64) << 32 | *channels & 0xffffffff;
*channels
}
#[inline]
pub fn ncchannels_set_fg_not_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
let mut channel = ncchannels_fchannel(*channels);
ncchannel_set_not_default(&mut channel);
*channels = (channel as NcChannels_u64) << 32 | *channels & 0xffffffff;
*channels
}
#[inline]
pub fn ncchannels_set_bg_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
let mut channel = ncchannels_bchannel(*channels);
ncchannel_set_default(&mut channel);
ncchannels_set_bchannel(channels, channel);
*channels
}
#[inline]
pub fn ncchannels_set_bg_not_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
let mut channel = ncchannels_bchannel(*channels);
ncchannel_set_not_default(&mut channel);
ncchannels_set_bchannel(channels, channel);
*channels
}
#[inline]
pub fn ncchannels_set_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
ncchannels_set_bg_default(&mut ncchannels_set_fg_default(channels))
}
#[inline]
pub fn ncchannels_set_not_default(channels: &mut NcChannels_u64) -> NcChannels_u64 {
ncchannels_set_bg_not_default(&mut ncchannels_set_fg_not_default(channels))
}
pub fn ncchannel_palindex(channel: impl Into<NcChannel_u32>) -> NcPaletteIndex {
(channel.into() & 0xFF) as NcPaletteIndex
}
pub fn ncchannel_set_palindex(channel: &mut NcChannel_u32, index: impl Into<NcPaletteIndex>) {
ncchannel_set_alpha(channel, c_api::NCALPHA_OPAQUE);
*channel &= 0xFF000000;
*channel |= c_api::NC_BGDEFAULT_MASK | c_api::NC_BG_PALETTE | index.into() as NcChannel_u32;
}
#[inline]
pub fn ncchannel_palindex_p(channel: impl Into<NcChannel_u32>) -> bool {
let channel = channel.into();
!ncchannel_default_p(channel) && (channel & c_api::NC_BG_PALETTE) != 0
}
#[inline]
pub fn ncchannels_fg_palindex(channels: impl Into<NcChannels_u64>) -> NcPaletteIndex {
ncchannel_palindex(ncchannels_fchannel(channels.into()))
}
#[inline]
pub fn ncchannels_bg_palindex(channels: impl Into<NcChannels_u64>) -> NcPaletteIndex {
ncchannel_palindex(ncchannels_bchannel(channels.into()))
}
#[inline]
pub fn ncchannels_fg_palindex_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_palindex_p(ncchannels_fchannel(channels.into()))
}
#[inline]
pub fn ncchannels_bg_palindex_p(channels: impl Into<NcChannels_u64>) -> bool {
ncchannel_palindex_p(ncchannels_bchannel(channels.into()))
}
#[inline]
#[allow(clippy::unnecessary_cast)]
pub fn ncchannels_set_fg_palindex(channels: &mut NcChannels_u64, index: impl Into<NcPaletteIndex>) {
let mut channel = ncchannels_fchannel(*channels);
ncchannel_set_palindex(&mut channel, index.into());
*channels = (channel as NcChannels_u64) << 32 | (*channels & 0xffffffff as NcChannels_u64)
}
#[inline]
pub fn ncchannels_set_bg_palindex(channels: &mut NcChannels_u64, index: impl Into<NcPaletteIndex>) {
let mut channel = ncchannels_bchannel(*channels);
ncchannel_set_palindex(&mut channel, index.into());
ncchannels_set_bchannel(channels, channel);
}