#![allow(dead_code)]
use libc::strcmp;
use crate::{
c_api::{
self, nccell_release, NcAlpha_u32, NcChannel_u32, NcChannels_u64, NcResult_i32, NcRgb_u32,
NcStyle_u16,
},
cstring, rstring, NcCell, NcPaletteIndex, NcPlane,
};
const NCBOXLIGHT: &str = "┌┐└┘─│";
const NCBOXHEAVY: &str = "┏┓┗┛━┃";
const NCBOXROUND: &str = "╭╮╰╯─│";
const NCBOXDOUBLE: &str = "╔╗╚╝═║";
const NCBOXASCII: &str = "/\\\\/-|";
const NCBOXOUTER: &str = "🭽🭾🭼🭿▁🭵🭶🭰";
#[inline]
pub fn nccell_bchannel(cell: &NcCell) -> NcChannel_u32 {
c_api::ncchannels_bchannel(cell.channels)
}
#[inline]
pub fn nccell_fchannel(cell: &NcCell) -> NcChannel_u32 {
c_api::ncchannels_fchannel(cell.channels)
}
#[inline]
pub fn nccell_channels(cell: &NcCell) -> NcChannels_u64 {
c_api::ncchannels_channels(cell.channels)
}
#[inline]
pub fn nccell_set_bchannel(
cell: &mut NcCell,
bchannel: impl Into<NcChannel_u32>,
) -> NcChannels_u64 {
c_api::ncchannels_set_bchannel(&mut cell.channels, bchannel.into())
}
#[inline]
pub fn nccell_set_fchannel(
cell: &mut NcCell,
fchannel: impl Into<NcChannel_u32>,
) -> NcChannels_u64 {
c_api::ncchannels_set_fchannel(&mut cell.channels, fchannel.into())
}
#[inline]
pub fn nccell_set_channels(
cell: &mut NcCell,
channels: impl Into<NcChannels_u64>,
) -> NcChannels_u64 {
c_api::ncchannels_set_channels(&mut cell.channels, channels.into())
}
#[inline]
pub fn nccell_fg_alpha(cell: &NcCell) -> NcAlpha_u32 {
c_api::ncchannels_fg_alpha(cell.channels)
}
#[inline]
pub fn nccell_bg_alpha(cell: &NcCell) -> NcAlpha_u32 {
c_api::ncchannels_bg_alpha(cell.channels)
}
#[inline]
pub fn nccell_set_fg_alpha(cell: &mut NcCell, alpha: impl Into<NcAlpha_u32>) {
c_api::ncchannels_set_fg_alpha(&mut cell.channels, alpha.into());
}
#[inline]
pub fn nccell_set_bg_alpha(cell: &mut NcCell, alpha: impl Into<NcAlpha_u32>) {
c_api::ncchannels_set_bg_alpha(&mut cell.channels, alpha.into());
}
#[inline]
pub fn nccell_fg_rgb8(cell: &NcCell, red: &mut u8, green: &mut u8, blue: &mut u8) -> NcChannel_u32 {
c_api::ncchannels_fg_rgb8(cell.channels, red, green, blue)
}
#[inline]
pub fn nccell_bg_rgb8(cell: &NcCell, red: &mut u8, green: &mut u8, blue: &mut u8) -> NcChannel_u32 {
c_api::ncchannels_bg_rgb8(cell.channels, red, green, blue)
}
#[inline]
pub fn nccell_set_fg_rgb8(cell: &mut NcCell, red: u8, green: u8, blue: u8) {
c_api::ncchannels_set_fg_rgb8(&mut cell.channels, red, green, blue);
}
#[inline]
pub fn nccell_set_bg_rgb8(cell: &mut NcCell, red: u8, green: u8, blue: u8) {
c_api::ncchannels_set_bg_rgb8(&mut cell.channels, red, green, blue);
}
#[inline]
pub fn nccell_fg_rgb(cell: &NcCell) -> NcRgb_u32 {
c_api::ncchannels_fg_rgb(cell.channels)
}
#[inline]
pub fn nccell_bg_rgb(cell: &NcCell) -> NcRgb_u32 {
c_api::ncchannels_bg_rgb(cell.channels)
}
#[inline]
pub fn nccell_set_fg_rgb(cell: &mut NcCell, rgb: impl Into<NcRgb_u32>) {
c_api::ncchannels_set_fg_rgb(&mut cell.channels, rgb.into());
}
#[inline]
pub fn nccell_set_bg_rgb(cell: &mut NcCell, rgb: impl Into<NcRgb_u32>) {
c_api::ncchannels_set_bg_rgb(&mut cell.channels, rgb.into());
}
#[inline]
pub fn nccell_set_fg_default(cell: &mut NcCell) {
c_api::ncchannels_set_fg_default(&mut cell.channels);
}
#[inline]
pub fn nccell_set_bg_default(cell: &mut NcCell) {
c_api::ncchannels_set_bg_default(&mut cell.channels);
}
#[inline]
pub fn nccell_fg_default_p(cell: &NcCell) -> bool {
c_api::ncchannels_fg_default_p(cell.channels)
}
#[inline]
pub fn nccell_bg_default_p(cell: &NcCell) -> bool {
c_api::ncchannels_bg_default_p(cell.channels)
}
#[inline]
pub fn nccell_fg_palindex_p(cell: &NcCell) -> bool {
c_api::ncchannels_fg_palindex_p(cell.channels)
}
#[inline]
pub fn nccell_bg_palindex_p(cell: &NcCell) -> bool {
c_api::ncchannels_bg_palindex_p(cell.channels)
}
#[inline]
#[allow(clippy::unnecessary_cast)]
pub const fn nccell_fg_palindex(cell: &NcCell) -> NcPaletteIndex {
((cell.channels & 0xff00000000 as NcChannels_u64) >> 32) as NcPaletteIndex
}
#[inline]
#[allow(clippy::unnecessary_cast)]
pub const fn nccell_bg_palindex(cell: &NcCell) -> NcPaletteIndex {
(cell.channels & 0xff) as NcPaletteIndex
}
#[inline]
pub fn nccell_set_fg_palindex(cell: &mut NcCell, index: impl Into<NcPaletteIndex>) {
c_api::ncchannels_set_fg_palindex(&mut cell.channels, index.into())
}
#[inline]
pub fn nccell_set_bg_palindex(cell: &mut NcCell, index: impl Into<NcPaletteIndex>) {
c_api::ncchannels_set_bg_palindex(&mut cell.channels, index.into())
}
#[inline]
pub const fn nccell_styles(cell: &NcCell) -> NcStyle_u16 {
cell.stylemask
}
#[inline]
pub fn nccell_on_styles(cell: &mut NcCell, stylebits: impl Into<NcStyle_u16>) {
cell.stylemask |= stylebits.into() & c_api::NCSTYLE_MASK;
}
#[inline]
pub fn nccell_off_styles(cell: &mut NcCell, stylebits: impl Into<NcStyle_u16>) {
cell.stylemask &= !(stylebits.into() & c_api::NCSTYLE_MASK);
}
#[inline]
pub fn nccell_set_styles(cell: &mut NcCell, stylebits: impl Into<NcStyle_u16>) {
cell.stylemask = stylebits.into() & c_api::NCSTYLE_MASK;
}
#[inline]
pub const fn nccell_cols(cell: &NcCell) -> u8 {
if cell.width != 0 {
cell.width
} else {
1
}
}
#[inline]
pub const fn nccell_double_wide_p(cell: &NcCell) -> bool {
cell.width > 0
}
#[inline]
pub const fn nccell_wide_right_p(cell: &NcCell) -> bool {
nccell_double_wide_p(cell) && cell.gcluster == 0
}
#[inline]
pub const fn nccell_wide_left_p(cell: &NcCell) -> bool {
nccell_double_wide_p(cell) && cell.gcluster != 0
}
#[inline]
pub fn nccell_strdup(plane: &NcPlane, cell: &NcCell) -> String {
rstring![libc::strdup(c_api::nccell_extended_gcluster(plane, cell))].into()
}
#[inline]
pub fn nccell_extract(
plane: &NcPlane,
cell: &NcCell,
stylemask: &mut NcStyle_u16,
channels: &mut NcChannels_u64,
) -> String {
*stylemask = cell.stylemask;
*channels = cell.channels;
nccell_strdup(plane, cell)
}
#[inline]
pub fn nccellcmp(plane1: &NcPlane, cell1: &NcCell, plane2: &NcPlane, cell2: &NcCell) -> bool {
if cell1.stylemask != cell2.stylemask {
return true;
}
if cell1.channels != cell2.channels {
return true;
}
unsafe {
strcmp(
c_api::nccell_extended_gcluster(plane1, cell1),
c_api::nccell_extended_gcluster(plane2, cell2),
) != 0
}
}
#[inline]
pub fn nccell_init(cell: &mut NcCell) {
*cell = unsafe { core::mem::zeroed() }
}
#[inline]
pub fn nccell_prime(
plane: &mut NcPlane,
cell: &mut NcCell,
gcluster: &str,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
) -> NcResult_i32 {
cell.stylemask = style.into();
cell.channels = channels.into();
let cs = cstring![gcluster];
unsafe { c_api::nccell_load(plane, cell, cs.as_ptr()) }
}
#[inline]
pub fn nccells_load_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
gcluster: &str,
) -> NcResult_i32 {
let (style, channels) = (style.into(), channels.into());
let cs = cstring![gcluster];
let mut gclu = cs.as_ptr();
let mut ulen: NcResult_i32 = nccell_prime(plane, ul, gcluster, style, channels);
if ulen > 0 {
gclu = unsafe { gclu.offset(ulen as isize) };
ulen = nccell_prime(plane, ur, gcluster, style, channels);
if ulen > 0 {
gclu = unsafe { gclu.offset(ulen as isize) };
ulen = nccell_prime(plane, ll, gcluster, style, channels);
if ulen > 0 {
gclu = unsafe { gclu.offset(ulen as isize) };
ulen = nccell_prime(plane, lr, gcluster, style, channels);
if ulen > 0 {
gclu = unsafe { gclu.offset(ulen as isize) };
ulen = nccell_prime(plane, hl, gcluster, style, channels);
if ulen > 0 {
let _gclu = unsafe { gclu.offset(ulen as isize) };
ulen = nccell_prime(plane, vl, gcluster, style, channels);
if ulen > 0 {
return c_api::NCRESULT_OK;
}
unsafe {
nccell_release(plane, hl);
}
}
unsafe {
nccell_release(plane, lr);
}
}
unsafe {
nccell_release(plane, ll);
}
}
unsafe {
nccell_release(plane, ur);
}
}
unsafe {
nccell_release(plane, ul);
}
}
c_api::NCRESULT_ERR
}
#[inline]
pub fn nccells_ascii_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
) -> NcResult_i32 {
nccells_load_box(
plane,
style.into(),
channels.into(),
ul,
ur,
ll,
lr,
hl,
vl,
NCBOXASCII,
)
}
#[inline]
pub fn nccells_double_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
) -> NcResult_i32 {
nccells_load_box(
plane,
style.into(),
channels.into(),
ul,
ur,
ll,
lr,
hl,
vl,
NCBOXDOUBLE,
)
}
#[inline]
pub fn nccells_heavy_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
) -> NcResult_i32 {
nccells_load_box(
plane,
style.into(),
channels.into(),
ul,
ur,
ll,
lr,
hl,
vl,
NCBOXHEAVY,
)
}
#[inline]
pub fn nccells_light_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
) -> NcResult_i32 {
nccells_load_box(
plane,
style.into(),
channels.into(),
ul,
ur,
ll,
lr,
hl,
vl,
NCBOXLIGHT,
)
}
#[inline]
pub fn nccells_rounded_box(
plane: &mut NcPlane,
style: impl Into<NcStyle_u16>,
channels: impl Into<NcChannels_u64>,
ul: &mut NcCell,
ur: &mut NcCell,
ll: &mut NcCell,
lr: &mut NcCell,
hl: &mut NcCell,
vl: &mut NcCell,
) -> NcResult_i32 {
nccells_load_box(
plane,
style.into(),
channels.into(),
ul,
ur,
ll,
lr,
hl,
vl,
NCBOXROUND,
)
}