From 2ba4777443a535497aa3869ed92598745efa5692 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?joseLu=C3=ADs?= Date: Wed, 16 Jun 2021 19:15:59 +0200 Subject: [PATCH] [rust] rename `NCCELL_`* constants to `NCALPHA_`* - move `NCALPHA_`* constants to the channel module where `NcAlphaBits` is defined. - fix several docs and doclinks. - rustfmt. --- rust/src/cells/methods.rs | 12 +- rust/src/cells/mod.rs | 99 ++--------------- rust/src/cells/reimplemented.rs | 26 ++--- rust/src/cells/test/methods.rs | 2 +- rust/src/cells/test/reimplemented.rs | 12 +- rust/src/channel/methods.rs | 146 ++++++++++++------------- rust/src/channel/mod.rs | 115 ++++++++++++++++--- rust/src/channel/reimplemented.rs | 44 ++++---- rust/src/channel/test/reimplemented.rs | 31 +++--- rust/src/fade.rs | 7 +- rust/src/macros.rs | 2 +- rust/src/notcurses/methods.rs | 28 ++--- rust/src/notcurses/reimplemented.rs | 2 +- rust/src/palette/methods.rs | 2 +- rust/src/plane/helpers.rs | 2 +- rust/src/plane/methods.rs | 13 +-- rust/src/visual/methods.rs | 10 +- rust/src/visual/mod.rs | 2 +- 18 files changed, 268 insertions(+), 287 deletions(-) diff --git a/rust/src/cells/methods.rs b/rust/src/cells/methods.rs index d9208150a..87457084f 100644 --- a/rust/src/cells/methods.rs +++ b/rust/src/cells/methods.rs @@ -226,9 +226,9 @@ impl NcCell { /// Sets the background [NcPaletteIndex]. /// - /// Also sets [NCCELL_BG_PALETTE][crate::NCCELL_BG_PALETTE] and - /// [NCCELL_OPAQUE][crate::NCCELL_OPAQUE], and clears out - /// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK]. + /// Also sets [NCALPHA_BG_PALETTE][crate::NCALPHA_BG_PALETTE] and + /// [NCALPHA_OPAQUE][crate::NCALPHA_OPAQUE], and clears out + /// [NCALPHA_BGDEFAULT_MASK][crate::NCALPHA_BGDEFAULT_MASK]. /// /// *C style function: [nccell_set_bg_palindex()][crate::nccell_set_bg_palindex].* pub fn set_bg_palindex(&mut self, index: NcPaletteIndex) { @@ -266,9 +266,9 @@ impl NcCell { /// Sets the foreground [NcPaletteIndex]. /// - /// Also sets [NCCELL_FG_PALETTE][crate::NCCELL_FG_PALETTE] and - /// [NCCELL_OPAQUE][crate::NCCELL_OPAQUE], and clears out - /// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK]. + /// Also sets [NCALPHA_FG_PALETTE][crate::NCALPHA_FG_PALETTE] and + /// [NCALPHA_OPAQUE][crate::NCALPHA_OPAQUE], and clears out + /// [NCALPHA_BGDEFAULT_MASK][crate::NCALPHA_BGDEFAULT_MASK]. /// /// *C style function: [nccell_set_fg_palindex()][crate::nccell_set_fg_palindex].* pub fn set_fg_palindex(&mut self, index: NcPaletteIndex) { diff --git a/rust/src/cells/mod.rs b/rust/src/cells/mod.rs index 672d247e1..22bc50c5c 100644 --- a/rust/src/cells/mod.rs +++ b/rust/src/cells/mod.rs @@ -73,6 +73,9 @@ mod methods; mod reimplemented; pub use reimplemented::*; +#[allow(unused_imports)] // TEMP +use crate::{NcChannel, NcPlane}; + // NcCell /// A coordinate on an [`NcPlane`][crate::NcPlane] storing 128 bits of data. /// @@ -86,12 +89,12 @@ pub use reimplemented::*; /// /// # Description /// -/// An `NcCell` corresponds to a single character cell on some NcPlane`, +/// An `NcCell` corresponds to a single character cell on some `NcPlane`, /// which can be occupied by a single [`NcEgc`] grapheme cluster (some root /// spacing glyph, along with possible combining characters, which might span /// multiple columns). /// -/// An NcCell is bounded to an NcPlane, but the cell doesn't store anything +/// An NcCell is bounded to an `NcPlane`, but the cell doesn't store anything /// about the plane. /// /// At any `NcCell`, we can have a theoretically arbitrarily long UTF-8 string, @@ -161,19 +164,19 @@ pub use reimplemented::*; /// have two bits of inverted alpha. The actual grapheme written to a cell is /// the topmost non-zero grapheme. /// -/// - If its alpha is 00 ([`NCCELL_OPAQUE`]) its foreground color is used unchanged. +/// - If its alpha is 00 ([`NCALPHA_OPAQUE`]) its foreground color is used unchanged. /// -/// - If its alpha is 10 ([`NCCELL_TRANSPARENT`]) its foreground color is derived +/// - If its alpha is 10 ([`NCALPHA_TRANSPARENT`]) its foreground color is derived /// entirely from cells underneath it. /// -/// - If its alpha is 01 ([`NCCELL_BLEND`]) the result will be a composite. +/// - If its alpha is 01 ([`NCALPHA_BLEND`]) the result will be a composite. /// /// Likewise for the background. If the bottom of a coordinate's zbuffer is /// reached with a cumulative alpha of zero, the default is used. In this way, /// a terminal configured with transparent background can be supported through /// multiple occluding ncplanes. /// -/// A foreground alpha of 11 ([`NCCELL_HIGHCONTRAST`]) requests high-contrast +/// A foreground alpha of 11 ([`NCALPHA_HIGHCONTRAST`]) requests high-contrast /// text (relative to the computed background). /// A background alpha of 11 is currently forbidden. /// @@ -200,88 +203,6 @@ pub use reimplemented::*; /// pub type NcCell = crate::bindings::ffi::cell; -#[allow(unused_imports)] -use crate::{NcAlphaBits, NcChannel, NcPlane}; - -/// [`NcAlphaBits`] bits indicating -/// [`NcCell`]'s foreground or background color will be a composite between -/// its color and the `NcCell`s' corresponding colors underneath it -pub const NCCELL_BLEND: u32 = crate::bindings::ffi::NCALPHA_BLEND; - -/// [`NcAlphaBits`] bits indicating -/// [`NcCell`]'s foreground color will be high-contrast (relative to the -/// computed background). Background cannot be highcontrast -pub const NCCELL_HIGHCONTRAST: u32 = crate::bindings::ffi::NCALPHA_HIGHCONTRAST; - -/// [`NcAlphaBits`] bits indicating -/// [`NcCell`]'s foreground or background color is used unchanged -pub const NCCELL_OPAQUE: u32 = crate::bindings::ffi::NCALPHA_OPAQUE; - -/// [`NcAlphaBits`] bits indicating -/// [`NcCell`]'s foreground or background color is derived entirely from the -/// `NcCell`s underneath it -pub const NCCELL_TRANSPARENT: u32 = crate::bindings::ffi::NCALPHA_TRANSPARENT; - -/// If this bit is set, we are *not* using the default background color -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: This can also be used against a single [`NcChannel`] -pub const NCCELL_BGDEFAULT_MASK: u32 = crate::bindings::ffi::CELL_BGDEFAULT_MASK; - -/// Extract these bits to get the background alpha mask -/// ([`NcAlphaBits`]) -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: This can also be used against a single [`NcChannel`] -pub const NCCELL_BG_ALPHA_MASK: u32 = crate::bindings::ffi::CELL_BG_ALPHA_MASK; - -/// If this bit *and* [`NCCELL_BGDEFAULT_MASK`] are set, we're using a -/// palette-indexed background color -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: This can also be used against a single [`NcChannel`] -pub const NCCELL_BG_PALETTE: u32 = crate::bindings::ffi::CELL_BG_PALETTE; - -/// Extract these bits to get the background [`NcRgb`][crate::NcRgb] value -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: This can also be used against a single [`NcChannel`] -pub const NCCELL_BG_RGB_MASK: u32 = crate::bindings::ffi::CELL_BG_RGB_MASK; - -/// If this bit is set, we are *not* using the default foreground color -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: When working with a single [`NcChannel`] use [`NCCELL_BGDEFAULT_MASK`]; -pub const NCCELL_FGDEFAULT_MASK: u64 = crate::bindings::ffi::CELL_FGDEFAULT_MASK; - -/// Extract these bits to get the foreground alpha mask -/// ([`NcAlphaBits`]) -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: When working with a single [`NcChannel`] use [`NCCELL_BG_ALPHA_MASK`]; -pub const NCCELL_FG_ALPHA_MASK: u64 = crate::bindings::ffi::CELL_FG_ALPHA_MASK; - -/// If this bit *and* [`NCCELL_FGDEFAULT_MASK`] are set, we're using a -/// palette-indexed background color -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: When working with a single [`NcChannel`] use [`NCCELL_BG_PALETTE`]; -pub const NCCELL_FG_PALETTE: u64 = crate::bindings::ffi::CELL_FG_PALETTE; - -/// Extract these bits to get the foreground [`NcRgb`][crate::NcRgb] value -/// -/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] -/// -/// NOTE: When working with a single [`NcChannel`] use [`NCCELL_BG_RGB_MASK`]; -pub const NCCELL_FG_RGB_MASK: u64 = crate::bindings::ffi::CELL_FG_RGB_MASK; - // NcEgc // /// Extended Grapheme Cluster. A 32-bit [`char`]-like type @@ -322,7 +243,7 @@ pub const NCCELL_FG_RGB_MASK: u64 = crate::bindings::ffi::CELL_FG_RGB_MASK; /// in a cell, and therefore it must not be allowed through the API. /// /// ----- -/// NOTE that even if the `NcEgc` is <= 4 bytes and inlined, is still interpreted as +/// Note that even if the `NcEgc` is <= 4 bytes and inlined, is still interpreted as /// a NUL-terminated char * (technically, &cell->gcluster is treated as a char*). /// If it is more than 4 bytes, cell->gcluster has a first byte of 0x01, /// and the remaining 24 bits are an index into the plane's egcpool, diff --git a/rust/src/cells/reimplemented.rs b/rust/src/cells/reimplemented.rs index 30e5d6344..2e9ba2923 100644 --- a/rust/src/cells/reimplemented.rs +++ b/rust/src/cells/reimplemented.rs @@ -4,9 +4,9 @@ use libc::strcmp; use crate::{ cstring, nccell_release, NcAlphaBits, NcCell, NcChannel, NcChannelPair, NcColor, NcEgc, - NcIntResult, NcPaletteIndex, NcPlane, NcRgb, NcStyle, NCCELL_BGDEFAULT_MASK, NCCELL_BG_PALETTE, - NCCELL_FGDEFAULT_MASK, NCCELL_FG_PALETTE, NCCELL_OPAQUE, NCRESULT_ERR, NCRESULT_OK, - NCSTYLE_MASK, + NcIntResult, NcPaletteIndex, NcPlane, NcRgb, NcStyle, NCALPHA_BGDEFAULT_MASK, + NCALPHA_BG_PALETTE, NCALPHA_FGDEFAULT_MASK, NCALPHA_FG_PALETTE, NCALPHA_OPAQUE, NCRESULT_ERR, + NCRESULT_OK, NCSTYLE_MASK, }; // Alpha ----------------------------------------------------------------------- @@ -208,8 +208,8 @@ pub const fn nccell_bg_palindex(cell: &NcCell) -> NcPaletteIndex { /// Sets an [NcCell]'s foreground [NcPaletteIndex]. /// -/// Also sets [NCCELL_FG_PALETTE] and [NCCELL_OPAQUE], -/// and clears out [NCCELL_FGDEFAULT_MASK]. +/// Also sets [NCALPHA_FG_PALETTE] and [NCALPHA_OPAQUE], +/// and clears out [NCALPHA_FGDEFAULT_MASK]. /// /// *Method: NcCell.[set_fg_palindex()][NcCell#method.set_fg_palindex].* // @@ -217,26 +217,26 @@ pub const fn nccell_bg_palindex(cell: &NcCell) -> NcPaletteIndex { #[inline] #[allow(clippy::unnecessary_cast)] pub fn nccell_set_fg_palindex(cell: &mut NcCell, index: NcPaletteIndex) { - cell.channels |= NCCELL_FGDEFAULT_MASK; - cell.channels |= NCCELL_FG_PALETTE; - nccell_set_fg_alpha(cell, NCCELL_OPAQUE); + cell.channels |= NCALPHA_FGDEFAULT_MASK; + cell.channels |= NCALPHA_FG_PALETTE; + nccell_set_fg_alpha(cell, NCALPHA_OPAQUE); cell.channels &= 0xff000000ffffffff as NcChannelPair; cell.channels |= (index as NcChannelPair) << 32; } /// Sets an [NcCell]'s background [NcPaletteIndex]. /// -/// Also sets [NCCELL_BG_PALETTE] and [NCCELL_OPAQUE], -/// and clears out [NCCELL_BGDEFAULT_MASK]. +/// Also sets [NCALPHA_BG_PALETTE] and [NCALPHA_OPAQUE], +/// and clears out [NCALPHA_BGDEFAULT_MASK]. /// /// *Method: NcCell.[set_bg_palindex()][NcCell#method.set_bg_palindex].* // // NOTE: unlike the original C function, this one can't fail #[inline] pub fn nccell_set_bg_palindex(cell: &mut NcCell, index: NcPaletteIndex) { - cell.channels |= NCCELL_BGDEFAULT_MASK as NcChannelPair; - cell.channels |= NCCELL_BG_PALETTE as NcChannelPair; - nccell_set_bg_alpha(cell, NCCELL_OPAQUE); + cell.channels |= NCALPHA_BGDEFAULT_MASK as NcChannelPair; + cell.channels |= NCALPHA_BG_PALETTE as NcChannelPair; + nccell_set_bg_alpha(cell, NCALPHA_OPAQUE); cell.channels &= 0xffffffffff000000; cell.channels |= index as NcChannelPair; } diff --git a/rust/src/cells/test/methods.rs b/rust/src/cells/test/methods.rs index 348e69246..b5d05ce69 100644 --- a/rust/src/cells/test/methods.rs +++ b/rust/src/cells/test/methods.rs @@ -1,6 +1,6 @@ //! Test `NcCell` methods and associated functions. -use crate::{NcCell, NcPlane, Nc}; +use crate::{Nc, NcCell, NcPlane}; use serial_test::serial; diff --git a/rust/src/cells/test/reimplemented.rs b/rust/src/cells/test/reimplemented.rs index e9c0480bc..b5f5d961a 100644 --- a/rust/src/cells/test/reimplemented.rs +++ b/rust/src/cells/test/reimplemented.rs @@ -26,12 +26,12 @@ fn rgb() { crate::nccell_set_fg_rgb8(&mut c2, 0x11, 0x22, 0x33); let fchannel = crate::nccell_fg_rgb8(&c2, &mut r, &mut g, &mut b); assert_eq!((0x11, 0x22, 0x33), (r, g, b)); - assert_eq![0x112233, fchannel & !crate::NCCELL_BGDEFAULT_MASK]; + assert_eq![0x112233, fchannel & !crate::NCALPHA_BGDEFAULT_MASK]; crate::nccell_set_bg_rgb8(&mut c2, 0x44, 0x55, 0x66); let bchannel = crate::nccell_bg_rgb8(&c2, &mut r, &mut g, &mut b); assert_eq!((0x44, 0x55, 0x66), (r, g, b)); - assert_eq![0x445566, bchannel & !crate::NCCELL_BGDEFAULT_MASK]; + assert_eq![0x445566, bchannel & !crate::NCALPHA_BGDEFAULT_MASK]; } #[test] @@ -41,11 +41,11 @@ fn alpha() { assert_eq![0, crate::nccell_fg_alpha(&c1)]; assert_eq![0, crate::nccell_bg_alpha(&c1)]; - crate::nccell_set_fg_alpha(&mut c1, crate::NCCELL_TRANSPARENT); - assert_eq![crate::NCCELL_TRANSPARENT, crate::nccell_fg_alpha(&c1)]; + crate::nccell_set_fg_alpha(&mut c1, crate::NCALPHA_TRANSPARENT); + assert_eq![crate::NCALPHA_TRANSPARENT, crate::nccell_fg_alpha(&c1)]; - crate::nccell_set_bg_alpha(&mut c1, crate::NCCELL_BLEND); - assert_eq![crate::NCCELL_BLEND, crate::nccell_bg_alpha(&c1)]; + crate::nccell_set_bg_alpha(&mut c1, crate::NCALPHA_BLEND); + assert_eq![crate::NCALPHA_BLEND, crate::nccell_bg_alpha(&c1)]; } #[test] diff --git a/rust/src/channel/methods.rs b/rust/src/channel/methods.rs index d0c342d22..2516a839d 100644 --- a/rust/src/channel/methods.rs +++ b/rust/src/channel/methods.rs @@ -3,7 +3,7 @@ use crate::{NcAlphaBits, NcChannel, NcChannelPair, NcColor, NcPaletteIndex, NcRgb}; -/// Enables the [NcChannel] methods. +/// Enables the [`NcChannel`] methods. pub trait NcChannelMethods { // constructors fn new() -> Self; @@ -41,7 +41,7 @@ pub trait NcChannelMethods { fn palindex_p(&self) -> bool; } -/// Enables the [NcChannelPair] methods. +/// Enables the [`NcChannelPair`] methods. pub trait NcChannelPairMethods { // constructors fn new() -> Self; @@ -134,7 +134,7 @@ impl NcChannelMethods for NcChannel { /// New NcChannel, set to black and NOT using the "default color". fn new() -> Self { - 0 as NcChannel | crate::NCCELL_BGDEFAULT_MASK + 0 as NcChannel | crate::NCALPHA_BGDEFAULT_MASK } /// New NcChannel, set to black but using the "default color". @@ -142,30 +142,30 @@ impl NcChannelMethods for NcChannel { 0 as NcChannel } - /// New NcChannel, expects [NcRgb]. + /// New NcChannel, expects [`NcRgb`]. fn with_rgb(rgb: NcRgb) -> Self { Self::new().set(rgb) } - /// New NcChannel, expects [NcRgb] & [NcAlphaBits]. + /// New NcChannel, expects [`NcRgb`] & [`NcAlphaBits`]. fn with_rgb_alpha(rgb: NcRgb, alpha: NcAlphaBits) -> Self { Self::new().set(rgb).set_alpha(alpha) } - /// New NcChannel, expects three RGB [NcColor] components. + /// New NcChannel, expects three RGB [`NcColor`] components. fn with_rgb8(r: NcColor, g: NcColor, b: NcColor) -> Self { Self::new().set_rgb8(r, g, b) } - /// New NcChannel, expects three RGB [NcColor] components & [NcAlphaBits]. + /// New NcChannel, expects three RGB [`NcColor`] components & [`NcAlphaBits`]. fn with_rgb8_alpha(r: NcColor, g: NcColor, b: NcColor, alpha: NcAlphaBits) -> Self { Self::new().set_rgb8(r, g, b).set_alpha(alpha) } // Combine - /// Combines this [NcChannel] as foreground, with another as background - /// into an [NcChannelPair]. + /// Combines this [`NcChannel`] as foreground, with another as background + /// into an [`NcChannelPair`]. /// /// *C style function: [channels_combine()][crate::ncchannels_combine].* // @@ -174,8 +174,8 @@ impl NcChannelMethods for NcChannel { crate::ncchannels_combine(*self, bchannel) } - /// Combines this [NcChannel] as background, with another as foreground - /// into an [NcChannelPair]. + /// Combines this [`NcChannel`] as background, with another as foreground + /// into an [`NcChannelPair`]. /// /// *C style function: [channels_combine()][crate::ncchannels_combine].* // @@ -186,14 +186,14 @@ impl NcChannelMethods for NcChannel { // Alpha - /// Gets the [NcAlphaBits]. + /// Gets the [`NcAlphaBits`]. /// /// *C style function: [channel_alpha()][crate::ncchannel_alpha].* fn alpha(&self) -> NcAlphaBits { crate::ncchannel_alpha(*self) } - /// Sets the [NcAlphaBits]. + /// Sets the [`NcAlphaBits`]. /// /// *C style function: [channel_set_alpha()][crate::ncchannel_set_alpha].* fn set_alpha(&mut self, alpha: NcAlphaBits) -> Self { @@ -203,7 +203,7 @@ impl NcChannelMethods for NcChannel { // NcRgb - /// Sets the [NcRgb], and marks the NcChannel as NOT using the + /// Sets the [`NcRgb`], and marks the NcChannel as NOT using the /// "default color", retaining the other bits unchanged. /// /// *C style function: [channel_set()][crate::ncchannel_set].* @@ -214,7 +214,7 @@ impl NcChannelMethods for NcChannel { // NcColor - /// Gets the three [NcColor]s. + /// Gets the three [`NcColor`]s. /// /// *C style function: [channel_rgb8()][crate::ncchannel_rgb8].* fn rgb8(&self) -> (NcColor, NcColor, NcColor) { @@ -223,7 +223,7 @@ impl NcChannelMethods for NcChannel { (r, g, b) } - /// Sets the three [NcColor]s, and + /// Sets the three [`NcColor`]s, and /// marks the NcChannel as NOT using the "default color". /// /// *C style function: [channel_set_rgb8()][crate::ncchannel_set_rgb8].* @@ -232,28 +232,28 @@ impl NcChannelMethods for NcChannel { *self } - /// Gets the red [NcColor]. + /// Gets the red [`NcColor`]. /// /// *C style function: [channel_r()][crate::ncchannel_r].* fn r(&self) -> NcColor { crate::ncchannel_r(*self) } - /// Gets the green [NcColor]. + /// Gets the green [`NcColor`]. /// /// *C style function: [channel_g()][crate::ncchannel_g].* fn g(&self) -> NcColor { crate::ncchannel_g(*self) } - /// Gets the blue [NcColor]. + /// Gets the blue [`NcColor`]. /// /// *C style function: [channel_b()][crate::ncchannel_b].* fn b(&self) -> NcColor { crate::ncchannel_b(*self) } - /// Sets the red [NcColor], and returns the new NcChannel. + /// Sets the red [`NcColor`], and returns the new `NcChannel`. /// /// *C style function: [channel_set_r()][crate::ncchannel_set_r].* // @@ -262,7 +262,7 @@ impl NcChannelMethods for NcChannel { crate::ncchannel_set_r(self, r) } - /// Sets the green [NcColor], and returns the new NcChannel. + /// Sets the green [`NcColor`], and returns the new `NcChannel`. /// /// *C style function: [channel_set_g()][crate::ncchannel_set_g].* // @@ -271,7 +271,7 @@ impl NcChannelMethods for NcChannel { crate::ncchannel_set_g(self, g) } - /// Sets the blue [NcColor], and returns the new NcChannel. + /// Sets the blue [`NcColor`], and returns the new `NcChannel`. /// /// *C style function: [channel_set_b()][crate::ncchannel_set_b].* // @@ -282,7 +282,7 @@ impl NcChannelMethods for NcChannel { // NcRgb - /// Gets the [NcRgb]. + /// Gets the [`NcRgb`]. /// /// *C style function: [channel_rgb()][crate::ncchannel_rgb].* // @@ -291,7 +291,7 @@ impl NcChannelMethods for NcChannel { crate::ncchannel_rgb(*self) } - /// Sets the [NcRgb] and marks it as NOT using the "default color", + /// Sets the [`NcRgb`] and marks it as NOT using the "default color", /// retaining the other bits unchanged. /// /// *C style function: [channel_set()][crate::ncchannel_set].* @@ -350,8 +350,8 @@ impl NcChannelPairMethods for NcChannelPair { /// New NcChannelPair, set to black and NOT using the "default color". fn new() -> Self { Self::combine( - 0 as NcChannel | crate::NCCELL_BGDEFAULT_MASK, - 0 as NcChannel | crate::NCCELL_BGDEFAULT_MASK, + 0 as NcChannel | crate::NCALPHA_BGDEFAULT_MASK, + 0 as NcChannel | crate::NCALPHA_BGDEFAULT_MASK, ) } @@ -360,20 +360,20 @@ impl NcChannelPairMethods for NcChannelPair { Self::combine(0 as NcChannel, 0 as NcChannel) } - /// New NcChannel, expects two separate [NcRgb]s for the foreground + /// New NcChannel, expects two separate [`NcRgb`]s for the foreground /// and background channels. fn with_rgb(fg_rgb: NcRgb, bg_rgb: NcRgb) -> Self { Self::combine(NcChannel::with_rgb(fg_rgb), NcChannel::with_rgb(bg_rgb)) } - /// New NcChannelPair, expects a single [NcRgb] for both foreground + /// New NcChannelPair, expects a single [`NcRgb`] for both foreground /// and background channels. fn with_rgb_both(rgb: NcRgb) -> Self { let channel = NcChannel::new().set(rgb); Self::combine(channel, channel) } - /// New NcChannel, expects two separate [NcRgb] & [NcAlphaBits] for the + /// New NcChannel, expects two separate [`NcRgb`] & [`NcAlphaBits`] for the /// foreground and background channels. fn with_rgb_alpha( fg_rgb: NcRgb, @@ -387,13 +387,13 @@ impl NcChannelPairMethods for NcChannelPair { ) } - /// New NcChannel, expects [NcRgb] & [NcAlphaBits] for both channels. + /// New NcChannel, expects [`NcRgb`] & [`NcAlphaBits`] for both channels. fn with_rgb_alpha_both(rgb: NcRgb, alpha: NcAlphaBits) -> Self { let channel = NcChannel::new().set(rgb).set_alpha(alpha); Self::combine(channel, channel) } - /// New NcChannelPair, expects three RGB [NcColor] components for each channel. + /// New NcChannelPair, expects three RGB [`NcColor`] components for each channel. fn with_rgb8( fg_r: NcColor, fg_g: NcColor, @@ -408,14 +408,14 @@ impl NcChannelPairMethods for NcChannelPair { ) } - /// New NcChannelPair, expects three RGB [NcColor] components for both + /// New NcChannelPair, expects three RGB [`NcColor`] components for both /// the foreground and background channels. fn with_rgb8_both(r: NcColor, g: NcColor, b: NcColor) -> Self { let channel = NcChannel::new().set_rgb8(r, g, b); Self::combine(channel, channel) } - /// New NcChannelPair, expects three RGB [NcColor] components & [NcAlphaBits] + /// New NcChannelPair, expects three RGB [`NcColor`] components & [`NcAlphaBits`] /// for both foreground and background channels. fn with_rgb8_alpha( fg_r: NcColor, @@ -433,7 +433,7 @@ impl NcChannelPairMethods for NcChannelPair { ) } - /// New NcChannel, expects three RGB [NcColor] components. + /// New NcChannel, expects three RGB [`NcColor`] components. fn with_rgb8_alpha_both(r: NcColor, g: NcColor, b: NcColor, alpha: NcAlphaBits) -> Self { let channel = NcChannel::new().set_rgb8(r, g, b).set_alpha(alpha); Self::combine(channel, channel) @@ -441,7 +441,7 @@ impl NcChannelPairMethods for NcChannelPair { // Combine - /// Combines two [NcChannel]s into an [NcChannelPair]. + /// Combines two [`NcChannel`]s into an [`NcChannelPair`]. /// /// *C style function: [channels_combine()][crate::ncchannels_combine].* fn combine(fchannel: NcChannel, bchannel: NcChannel) -> Self { @@ -450,28 +450,28 @@ impl NcChannelPairMethods for NcChannelPair { // NcChannel - /// Extracts the foreground [NcChannel]. + /// Extracts the foreground [`NcChannel`]. /// /// *C style function: [channels_fchannel()][crate::ncchannels_fchannel].* fn fchannel(&self) -> NcChannel { crate::ncchannels_fchannel(*self) } - /// Extracts the background [NcChannel]. + /// Extracts the background [`NcChannel`]. /// /// *C style function: [channels_bchannel()][crate::ncchannels_bchannel].* fn bchannel(&self) -> NcChannel { crate::ncchannels_bchannel(*self) } - /// Sets the foreground [NcChannel]. + /// Sets the foreground [`NcChannel`]. /// /// *C style function: [channels_set_fchannel()][crate::ncchannels_set_fchannel].* fn set_fchannel(&mut self, fchannel: NcChannel) -> Self { crate::ncchannels_set_fchannel(self, fchannel) } - /// Sets the background [NcChannel]. + /// Sets the background [`NcChannel`]. /// /// *C style function: [channels_set_bchannel()][crate::ncchannels_set_bchannel].* fn set_bchannel(&mut self, bchannel: NcChannel) -> Self { @@ -480,28 +480,28 @@ impl NcChannelPairMethods for NcChannelPair { // Alpha - /// Gets the foreground [NcAlphaBits]. + /// Gets the foreground [`NcAlphaBits`]. /// /// *C style function: [channels_fg_alpha()][crate::ncchannels_fg_alpha].* fn fg_alpha(&self) -> NcAlphaBits { crate::ncchannels_fg_alpha(*self) } - /// Gets the background [NcAlphaBits]. + /// Gets the background [`NcAlphaBits`]. /// /// *C style function: [channels_bg_alpha()][crate::ncchannels_bg_alpha].* fn bg_alpha(&self) -> NcAlphaBits { crate::ncchannels_bg_alpha(*self) } - /// Sets the foreground [NcAlphaBits]. + /// Sets the foreground [`NcAlphaBits`]. /// /// *C style function: [channels_set_fg_alpha()][crate::ncchannels_set_fg_alpha].* fn set_fg_alpha(&mut self, alpha: NcAlphaBits) { crate::ncchannels_set_fg_alpha(self, alpha) } - /// Sets the background [NcAlphaBits]. + /// Sets the background [`NcAlphaBits`]. /// /// *C style function: [channels_set_bg_alpha()][crate::ncchannels_set_bg_alpha].* fn set_bg_alpha(&mut self, alpha: NcAlphaBits) { @@ -510,21 +510,21 @@ impl NcChannelPairMethods for NcChannelPair { // NcRgb - /// Gets the foreground [NcRgb]. + /// Gets the foreground [`NcRgb`]. /// /// *C style function: [channels_fg_rgb()][crate::ncchannels_fg_rgb].* fn fg_rgb(&self) -> NcRgb { crate::ncchannels_fg_rgb(*self) } - /// Gets the background [NcRgb]. + /// Gets the background [`NcRgb`]. /// /// *C style function: [channels_bg_rgb()][crate::ncchannels_bg_rgb].* fn bg_rgb(&self) -> NcRgb { crate::ncchannels_bg_rgb(*self) } - /// Sets the foreground [NcRgb]. + /// Sets the foreground [`NcRgb`]. /// /// *C style function: [channels_set_fg_rgb()][crate::ncchannels_set_fg_rgb].* fn set_fg_rgb(&mut self, rgb: NcRgb) -> Self { @@ -532,7 +532,7 @@ impl NcChannelPairMethods for NcChannelPair { *self } - /// Sets the background [NcRgb]. + /// Sets the background [`NcRgb`]. /// /// *C style function: [channels_set_bg_rgb()][crate::ncchannels_set_bg_rgb].* fn set_bg_rgb(&mut self, rgb: NcRgb) -> Self { @@ -542,7 +542,7 @@ impl NcChannelPairMethods for NcChannelPair { // NcColor - /// Gets the three foreground [NcColor]s (r, g, b). + /// Gets the three foreground [`NcColor`]s (r, g, b). /// /// *C style function: [channels_fg_rgb8()][crate::ncchannels_fg_rgb8].* fn fg_rgb8(&self) -> (NcColor, NcColor, NcColor) { @@ -551,7 +551,7 @@ impl NcChannelPairMethods for NcChannelPair { (r, g, b) } - /// Gets the three background [NcColor]s (r, g, b). + /// Gets the three background [`NcColor`]s (r, g, b). /// /// *C style function: [channels_bg_rgb8()][crate::ncchannels_bg_rgb8].* fn bg_rgb8(&self) -> (NcColor, NcColor, NcColor) { @@ -560,65 +560,65 @@ impl NcChannelPairMethods for NcChannelPair { (r, g, b) } - /// Sets the three foreground [NcColor]s (r, g, b), and - /// marks the foreground [NcChannel] as not using the "default color". + /// Sets the three foreground [`NcColor`]s (r, g, b), and + /// marks the foreground [`NcChannel`] as not using the "default color". /// /// *C style function: [channels_set_fg_rgb8()][crate::ncchannels_set_fg_rgb8].* fn set_fg_rgb8(&mut self, r: NcColor, g: NcColor, b: NcColor) -> Self { crate::ncchannels_set_fg_rgb8(self, r, g, b) } - /// Sets the three background [NcColor]s (r, g, b), and - /// marks the background [NcChannel] as not using the "default color". + /// Sets the three background [`NcColor`]s (r, g, b), and + /// marks the background [`NcChannel`] as not using the "default color". /// /// *C style function: [channels_set_bg_rgb8()][crate::ncchannels_set_bg_rgb8].* fn set_bg_rgb8(&mut self, r: NcColor, g: NcColor, b: NcColor) -> Self { crate::ncchannels_set_bg_rgb8(self, r, g, b) } - /// Gets the foreground red [NcColor]. + /// Gets the foreground red [`NcColor`]. /// /// *(No equivalent C style function)* fn fg_r(&self) -> NcColor { crate::ncchannel_r(crate::ncchannels_fchannel(*self)) } - /// Gets the foreground green [NcColor]. + /// Gets the foreground green [`NcColor`]. /// /// *(No equivalent C style function)* fn fg_g(&self) -> NcColor { crate::ncchannel_g(crate::ncchannels_fchannel(*self)) } - /// Gets the foreground blue [NcColor]. + /// Gets the foreground blue [`NcColor`]. /// /// *(No equivalent C style function)* fn fg_b(&self) -> NcColor { crate::ncchannel_b(crate::ncchannels_fchannel(*self)) } - /// Gets the background red [NcColor]. + /// Gets the background red [`NcColor`]. /// /// *(No equivalent C style function)* fn bg_r(&self) -> NcColor { crate::ncchannel_r(crate::ncchannels_bchannel(*self)) } - /// Gets the background green [NcColor]. + /// Gets the background green [`NcColor`]. /// /// *(No equivalent C style function)* fn bg_g(&self) -> NcColor { crate::ncchannel_g(crate::ncchannels_bchannel(*self)) } - /// Gets the background blue [NcColor]. + /// Gets the background blue [`NcColor`]. /// /// *(No equivalent C style function)* fn bg_b(&self) -> NcColor { crate::ncchannel_b(crate::ncchannels_bchannel(*self)) } - /// Sets the foreground red [NcColor], and returns the new NcChannelPair. + /// Sets the foreground red [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn fg_set_r(&mut self, r: NcColor) -> Self { @@ -626,7 +626,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_set_fg_rgb8(self, r, g, b) } - /// Sets the foreground green [NcColor], and returns the new NcChannelPair. + /// Sets the foreground green [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn fg_set_g(&mut self, g: NcColor) -> Self { @@ -634,7 +634,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_set_fg_rgb8(self, r, g, b) } - /// Sets the foreground blue [NcColor], and returns the new NcChannelPair. + /// Sets the foreground blue [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn fg_set_b(&mut self, b: NcColor) -> Self { @@ -642,7 +642,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_set_fg_rgb8(self, r, g, b) } - /// Sets the background red [NcColor], and returns the new NcChannelPair. + /// Sets the background red [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn bg_set_r(&mut self, r: NcColor) -> Self { @@ -650,7 +650,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_set_bg_rgb8(self, r, g, b) } - /// Sets the background green [NcColor], and returns the new NcChannelPair. + /// Sets the background green [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn bg_set_g(&mut self, g: NcColor) -> Self { @@ -658,7 +658,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_set_bg_rgb8(self, r, g, b) } - /// Sets the background blue [NcColor], and returns the new NcChannelPair. + /// Sets the background blue [`NcColor`], and returns the new `NcChannelPair`. /// /// *(No equivalent C style function)* fn bg_set_b(&mut self, b: NcColor) -> Self { @@ -686,7 +686,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks the foreground as using its "default color", and - /// returns the new [NcChannelPair]. + /// returns the new [`NcChannelPair`]. /// /// *C style function: [channels_set_fg_default()][crate::ncchannels_set_fg_default].* fn set_fg_default(&mut self) -> Self { @@ -694,7 +694,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks the background as using its "default color", and - /// returns the new [NcChannelPair]. + /// returns the new [`NcChannelPair`]. /// /// *C style function: [channels_set_bg_default()][crate::ncchannels_set_bg_default].* fn set_bg_default(&mut self) -> Self { @@ -702,7 +702,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks the foreground as NOT using its "default color", and - /// returns the new [NcChannelPair]. + /// returns the new [`NcChannelPair`]. /// /// *C style function: [channels_set_fg_default()][crate::ncchannels_set_fg_default].* // @@ -712,7 +712,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks the background as NOT using its "default color", and - /// returns the new [NcChannelPair]. + /// returns the new [`NcChannelPair`]. /// /// *C style function: [channels_set_bg_not_default()][crate::ncchannels_set_bg_not_default].* // @@ -722,7 +722,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks both the foreground and background as using its "default color", and - /// returns the new [NcChannelPair]. + /// returns the new [`NcChannelPair`]. /// // // Not in the C API @@ -731,7 +731,7 @@ impl NcChannelPairMethods for NcChannelPair { } /// Marks both the foreground and background as NOT using its "default color", - /// and returns the new [NcChannelPair]. + /// and returns the new [`NcChannelPair`]. /// // // Not in the C API @@ -757,7 +757,7 @@ impl NcChannelPairMethods for NcChannelPair { crate::ncchannels_bg_palindex_p(*self) } - /// Sets the foreground of an [NcChannelPair] as using an + /// Sets the foreground of an [`NcChannelPair`] as using an /// [indexed][NcPaletteIndex] [NcPalette][crate::NcPalette] color. /// /// *C style function: [channels_set_fg_palindex()][crate::ncchannels_set_fg_palindex].* @@ -766,7 +766,7 @@ impl NcChannelPairMethods for NcChannelPair { *self } - /// Sets the background of an [NcChannelPair] as using an + /// Sets the background of an [`NcChannelPair`] as using an /// [indexed][NcPaletteIndex] [NcPalette][crate::NcPalette] color. /// /// *C style function: [channels_set_bg_palindex()][crate::ncchannels_set_bg_palindex].* diff --git a/rust/src/channel/mod.rs b/rust/src/channel/mod.rs index 3a8d944ff..218669877 100644 --- a/rust/src/channel/mod.rs +++ b/rust/src/channel/mod.rs @@ -116,6 +116,85 @@ pub const NCCHANNEL_ALPHA_MASK: u32 = crate::bindings::ffi::CELL_BG_ALPHA_MASK; /// pub type NcAlphaBits = u32; +/// [`NcAlphaBits`] bits indicating +/// [`NcCell`]'s foreground or background color will be a composite between +/// its color and the `NcCell`s' corresponding colors underneath it +pub const NCALPHA_BLEND: u32 = crate::bindings::ffi::NCALPHA_BLEND; + +/// [`NcAlphaBits`] bits indicating +/// [`NcCell`]'s foreground color will be high-contrast (relative to the +/// computed background). Background cannot be highcontrast +pub const NCALPHA_HIGHCONTRAST: u32 = crate::bindings::ffi::NCALPHA_HIGHCONTRAST; + +/// [`NcAlphaBits`] bits indicating +/// [`NcCell`]'s foreground or background color is used unchanged +pub const NCALPHA_OPAQUE: u32 = crate::bindings::ffi::NCALPHA_OPAQUE; + +/// [`NcAlphaBits`] bits indicating +/// [`NcCell`]'s foreground or background color is derived entirely from the +/// `NcCell`s underneath it +pub const NCALPHA_TRANSPARENT: u32 = crate::bindings::ffi::NCALPHA_TRANSPARENT; + +/// If this bit is set, we are *not* using the default background color +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: This can also be used against a single [`NcChannel`] +pub const NCALPHA_BGDEFAULT_MASK: u32 = crate::bindings::ffi::CELL_BGDEFAULT_MASK; + +/// Extract these bits to get the background alpha mask +/// ([`NcAlphaBits`]) +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: This can also be used against a single [`NcChannel`] +pub const NCALPHA_BG_ALPHA_MASK: u32 = crate::bindings::ffi::CELL_BG_ALPHA_MASK; + +/// If this bit *and* [`NCALPHA_BGDEFAULT_MASK`] are set, we're using a +/// palette-indexed background color +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: This can also be used against a single [`NcChannel`] +pub const NCALPHA_BG_PALETTE: u32 = crate::bindings::ffi::CELL_BG_PALETTE; + +/// Extract these bits to get the background [`NcRgb`][crate::NcRgb] value +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: This can also be used against a single [`NcChannel`] +pub const NCALPHA_BG_RGB_MASK: u32 = crate::bindings::ffi::CELL_BG_RGB_MASK; + +/// If this bit is set, we are *not* using the default foreground color +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: When working with a single [`NcChannel`] use [`NCALPHA_BGDEFAULT_MASK`]; +pub const NCALPHA_FGDEFAULT_MASK: u64 = crate::bindings::ffi::CELL_FGDEFAULT_MASK; + +/// Extract these bits to get the foreground alpha mask +/// ([`NcAlphaBits`]) +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: When working with a single [`NcChannel`] use [`NCALPHA_BG_ALPHA_MASK`]; +pub const NCALPHA_FG_ALPHA_MASK: u64 = crate::bindings::ffi::CELL_FG_ALPHA_MASK; + +/// If this bit *and* [`NCALPHA_FGDEFAULT_MASK`] are set, we're using a +/// palette-indexed background color +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: When working with a single [`NcChannel`] use [`NCALPHA_BG_PALETTE`]; +pub const NCALPHA_FG_PALETTE: u64 = crate::bindings::ffi::CELL_FG_PALETTE; + +/// Extract these bits to get the foreground [`NcRgb`][crate::NcRgb] value +/// +/// See the detailed diagram at [`NcChannelPair`][crate::NcChannelPair] +/// +/// Note: When working with a single [`NcChannel`] use [`NCALPHA_BG_RGB_MASK`]; +pub const NCALPHA_FG_RGB_MASK: u64 = crate::bindings::ffi::CELL_FG_RGB_MASK; + // NcChannelPair // /// 64 bits containing a foreground and background [`NcChannel`] @@ -145,25 +224,25 @@ pub type NcAlphaBits = u32; /// /// ```txt /// ~foreground channel~ -/// NCCELL_WIDEASIAN_MASK: part of a wide glyph ↓bits view↓ ↓hex mask↓ +/// NCALPHA_WIDEASIAN_MASK: part of a wide glyph ↓bits view↓ ↓hex mask↓ /// 1······· ········ ········ ········ ········ ········ ········ ········ = 8······· ········ /// -/// NCCELL_FGDEFAULT_MASK: foreground is NOT "default color" +/// NCALPHA_FGDEFAULT_MASK: foreground is NOT "default color" /// ·1······ ········ ········ ········ ········ ········ ········ ········ = 4······· ········ /// -/// NCCELL_FG_ALPHA_MASK: foreground alpha (2bits) +/// NCALPHA_FG_ALPHA_MASK: foreground alpha (2bits) /// ··11···· ········ ········ ········ ········ ········ ········ ········ = 3······· ········ /// -/// NCCELL_FG_PALETTE: foreground uses palette index +/// NCALPHA_FG_PALETTE: foreground uses palette index /// ····1··· ········ ········ ········ ········ ········ ········ ········ = ·8······ ········ /// -/// NCCELL_NOBACKGROUND_MASK: glyph is entirely foreground +/// NCALPHA_NOBACKGROUND_MASK: glyph is entirely foreground /// ·····1·· ········ ········ ········ ········ ········ ········ ········ = ·4······ ········ /// /// reserved, must be 0 /// ······00 ········ ········ ········ ········ ········ ········ ········ = ·3······ ········ /// -/// NCCELL_FG_RGB_MASK: foreground in 3x8 RGB (rrggbb) +/// NCALPHA_FG_RGB_MASK: foreground in 3x8 RGB (rrggbb) /// ········ 11111111 11111111 11111111 ········ ········ ········ ········ = ··FFFFFF ········ /// ``` @@ -172,33 +251,33 @@ pub type NcAlphaBits = u32; /// reserved, must be 0 ↓bits view↓ ↓hex mask↓ /// ········ ········ ········ ········ 0······· ········ ········ ········ = ········ 8······· /// -/// NCCELL_BGDEFAULT_MASK: background is NOT "default color" +/// NCALPHA_BGDEFAULT_MASK: background is NOT "default color" /// ········ ········ ········ ········ ·1······ ········ ········ ········ = ········ 4······· /// -/// NCCELL_BG_ALPHA_MASK: background alpha (2 bits) +/// NCALPHA_BG_ALPHA_MASK: background alpha (2 bits) /// ········ ········ ········ ········ ··11···· ········ ········ ········ = ········ 3······· /// -/// NCCELL_BG_PALETTE: background uses palette index +/// NCALPHA_BG_PALETTE: background uses palette index /// ········ ········ ········ ········ ····1··· ········ ········ ········ = ········ ·8······ /// /// reserved, must be 0 /// ········ ········ ········ ········ ·····000 ········ ········ ········ = ········ ·7······ /// -/// NCCELL_BG_RGB_MASK: background in 3x8 RGB (rrggbb) +/// NCALPHA_BG_RGB_MASK: background in 3x8 RGB (rrggbb) /// 0········ ········ ········ ········ ········11111111 11111111 11111111 = ········ ··FFFFFF /// ``` /// `type in C: channels (uint64_t)` /// /// ## `NcCell` Mask Flags /// -/// - [`NCCELL_BGDEFAULT_MASK`][crate::NCCELL_BGDEFAULT_MASK] -/// - [`NCCELL_BG_ALPHA_MASK`][crate::NCCELL_BG_ALPHA_MASK] -/// - [`NCCELL_BG_PALETTE`][crate::NCCELL_BG_PALETTE] -/// - [`NCCELL_BG_RGB_MASK`][crate::NCCELL_BG_RGB_MASK] -/// - [`NCCELL_FGDEFAULT_MASK`][crate::NCCELL_FGDEFAULT_MASK] -/// - [`NCCELL_FG_ALPHA_MASK`][crate::NCCELL_FG_ALPHA_MASK] -/// - [`NCCELL_FG_PALETTE`][crate::NCCELL_FG_PALETTE] -/// - [`NCCELL_FG_RGB_MASK`][crate::NCCELL_FG_RGB_MASK] +/// - [`NCALPHA_BGDEFAULT_MASK`][crate::NCALPHA_BGDEFAULT_MASK] +/// - [`NCALPHA_BG_ALPHA_MASK`][crate::NCALPHA_BG_ALPHA_MASK] +/// - [`NCALPHA_BG_PALETTE`][crate::NCALPHA_BG_PALETTE] +/// - [`NCALPHA_BG_RGB_MASK`][crate::NCALPHA_BG_RGB_MASK] +/// - [`NCALPHA_FGDEFAULT_MASK`][crate::NCALPHA_FGDEFAULT_MASK] +/// - [`NCALPHA_FG_ALPHA_MASK`][crate::NCALPHA_FG_ALPHA_MASK] +/// - [`NCALPHA_FG_PALETTE`][crate::NCALPHA_FG_PALETTE] +/// - [`NCALPHA_FG_RGB_MASK`][crate::NCALPHA_FG_RGB_MASK] /// pub type NcChannelPair = u64; diff --git a/rust/src/channel/reimplemented.rs b/rust/src/channel/reimplemented.rs index 6507d03a1..665fe002d 100644 --- a/rust/src/channel/reimplemented.rs +++ b/rust/src/channel/reimplemented.rs @@ -1,9 +1,9 @@ //! `channel*_*` reimplemented functions. use crate::{ - NcAlphaBits, NcChannel, NcChannelPair, NcColor, NcPaletteIndex, NcRgb, NCCELL_BGDEFAULT_MASK, - NCCELL_BG_PALETTE, NCCELL_BG_RGB_MASK, NCCELL_FGDEFAULT_MASK, NCCELL_FG_PALETTE, - NCCELL_HIGHCONTRAST, NCCELL_OPAQUE, NCCHANNEL_ALPHA_MASK, + NcAlphaBits, NcChannel, NcChannelPair, NcColor, NcPaletteIndex, NcRgb, NCALPHA_BGDEFAULT_MASK, + NCALPHA_BG_PALETTE, NCALPHA_BG_RGB_MASK, NCALPHA_FGDEFAULT_MASK, NCALPHA_FG_PALETTE, + NCALPHA_HIGHCONTRAST, NCALPHA_OPAQUE, NCCHANNEL_ALPHA_MASK, }; // Alpha ----------------------------------------------------------------------- @@ -24,9 +24,9 @@ pub fn ncchannel_set_alpha(channel: &mut NcChannel, alpha: NcAlphaBits) { let alpha_clean = alpha & NCCHANNEL_ALPHA_MASK; *channel = alpha_clean | (*channel & !NCCHANNEL_ALPHA_MASK); - if alpha != NCCELL_OPAQUE { + if alpha != NCALPHA_OPAQUE { // indicate that we are *not* using the default background color - *channel |= NCCELL_BGDEFAULT_MASK; + *channel |= NCALPHA_BGDEFAULT_MASK; } } @@ -62,9 +62,9 @@ pub fn ncchannels_set_fg_alpha(channels: &mut NcChannelPair, alpha: NcAlphaBits) #[inline] pub fn ncchannels_set_bg_alpha(channels: &mut NcChannelPair, alpha: NcAlphaBits) { let mut alpha_clean = alpha; - if alpha == NCCELL_HIGHCONTRAST { + if alpha == NCALPHA_HIGHCONTRAST { // forbidden for background alpha, so makes it opaque - alpha_clean = NCCELL_OPAQUE; + alpha_clean = NCALPHA_OPAQUE; } let mut channel = ncchannels_bchannel(*channels); ncchannel_set_alpha(&mut channel, alpha_clean); @@ -200,7 +200,7 @@ pub fn ncchannel_rgb8( #[inline] pub fn ncchannel_set_rgb8(channel: &mut NcChannel, r: NcColor, g: NcColor, b: NcColor) { let rgb: NcRgb = (r as NcChannel) << 16 | (g as NcChannel) << 8 | (b as NcChannel); - *channel = (*channel & !NCCELL_BG_RGB_MASK) | NCCELL_BGDEFAULT_MASK | rgb; + *channel = (*channel & !NCALPHA_BG_RGB_MASK) | NCALPHA_BGDEFAULT_MASK | rgb; } /// Gets the three foreground RGB [NcColor]s from an [NcChannelPair], and @@ -276,7 +276,7 @@ pub fn ncchannels_set_bg_rgb8( /// *Method: NcChannelPair.[fg_rgb()][NcChannelPair#method.fg_rgb]* #[inline] pub fn ncchannels_fg_rgb(channels: NcChannelPair) -> NcRgb { - ncchannels_fchannel(channels) & NCCELL_BG_RGB_MASK + ncchannels_fchannel(channels) & NCALPHA_BG_RGB_MASK } /// Gets the background [NcRgb] from an [NcChannelPair], shifted to LSBs. @@ -284,7 +284,7 @@ pub fn ncchannels_fg_rgb(channels: NcChannelPair) -> NcRgb { /// *Method: NcChannelPair.[bg_rgb()][NcChannelPair#method.bg_rgb]* #[inline] pub fn ncchannels_bg_rgb(channels: NcChannelPair) -> NcRgb { - ncchannels_bchannel(channels) & NCCELL_BG_RGB_MASK + ncchannels_bchannel(channels) & NCALPHA_BG_RGB_MASK } /// Gets the [NcRgb] of an [NcChannel]. @@ -296,7 +296,7 @@ pub fn ncchannels_bg_rgb(channels: NcChannelPair) -> NcRgb { // Not in the C API #[inline] pub const fn ncchannel_rgb(channel: NcChannel) -> NcRgb { - channel & NCCELL_BG_RGB_MASK + channel & NCALPHA_BG_RGB_MASK } /// Sets the [NcRgb] of an [NcChannel], and marks it as NOT using the @@ -305,7 +305,7 @@ pub const fn ncchannel_rgb(channel: NcChannel) -> NcRgb { /// *Method: NcChannel.[set()][NcChannel#method.set]* #[inline] pub fn ncchannel_set(channel: &mut NcChannel, rgb: NcRgb) { - *channel = (*channel & !NCCELL_BG_RGB_MASK) | NCCELL_BGDEFAULT_MASK | (rgb & 0x00ffffff); + *channel = (*channel & !NCALPHA_BG_RGB_MASK) | NCALPHA_BGDEFAULT_MASK | (rgb & 0x00ffffff); } /// Sets the foreground [NcRgb] of an [NcChannelPair], and marks it as NOT using @@ -337,7 +337,7 @@ pub fn ncchannels_set_bg_rgb(channels: &mut NcChannelPair, rgb: NcRgb) { /// *Method: NcChannel.[default_p()][NcChannel#method.default_p]* #[inline] pub const fn ncchannel_default_p(channel: NcChannel) -> bool { - (channel & NCCELL_BGDEFAULT_MASK) == 0 + (channel & NCALPHA_BGDEFAULT_MASK) == 0 } /// Marks an [NcChannel] as using its "default color", which also marks it opaque. @@ -345,7 +345,7 @@ pub const fn ncchannel_default_p(channel: NcChannel) -> bool { /// *Method: NcChannel.[set_default()][NcChannel#method.set_default]* #[inline] pub fn ncchannel_set_default(channel: &mut NcChannel) -> NcChannel { - *channel &= !(NCCELL_BGDEFAULT_MASK | NCCELL_HIGHCONTRAST); + *channel &= !(NCALPHA_BGDEFAULT_MASK | NCALPHA_HIGHCONTRAST); *channel } @@ -357,7 +357,7 @@ pub fn ncchannel_set_default(channel: &mut NcChannel) -> NcChannel { // Not in the C API #[inline] pub fn ncchannel_set_not_default(channel: &mut NcChannel) -> NcChannel { - *channel |= NCCELL_BGDEFAULT_MASK; + *channel |= NCALPHA_BGDEFAULT_MASK; *channel } @@ -461,7 +461,7 @@ pub fn ncchannels_set_not_default(channels: &mut NcChannelPair) -> NcChannelPair /// *Method: NcChannel.[palindex_p()][NcChannel#method.palindex_p]* #[inline] pub fn ncchannel_palindex_p(channel: NcChannel) -> bool { - !(ncchannel_default_p(channel) && (channel & NCCELL_BG_PALETTE) == 0) + !(ncchannel_default_p(channel) && (channel & NCALPHA_BG_PALETTE) == 0) } /// Is the foreground of an [NcChannelPair] using an [indexed][NcPaletteIndex] @@ -489,9 +489,9 @@ pub fn ncchannels_bg_palindex_p(channels: NcChannelPair) -> bool { #[inline] #[allow(clippy::unnecessary_cast)] pub fn ncchannels_set_fg_palindex(channels: &mut NcChannelPair, index: NcPaletteIndex) { - *channels |= NCCELL_FGDEFAULT_MASK; - *channels |= NCCELL_FG_PALETTE as NcChannelPair; - ncchannels_set_fg_alpha(channels, NCCELL_OPAQUE); + *channels |= NCALPHA_FGDEFAULT_MASK; + *channels |= NCALPHA_FG_PALETTE as NcChannelPair; + ncchannels_set_fg_alpha(channels, NCALPHA_OPAQUE); *channels &= 0xff000000ffffffff as NcChannelPair; *channels |= (index as NcChannelPair) << 32; } @@ -502,9 +502,9 @@ pub fn ncchannels_set_fg_palindex(channels: &mut NcChannelPair, index: NcPalette /// *Method: NcChannelPair.[set_bg_palindex()][NcChannelPair#method.set_bg_palindex]* #[inline] pub fn ncchannels_set_bg_palindex(channels: &mut NcChannelPair, index: NcPaletteIndex) { - *channels |= NCCELL_BGDEFAULT_MASK as NcChannelPair; - *channels |= NCCELL_BG_PALETTE as NcChannelPair; - ncchannels_set_bg_alpha(channels, NCCELL_OPAQUE); + *channels |= NCALPHA_BGDEFAULT_MASK as NcChannelPair; + *channels |= NCALPHA_BG_PALETTE as NcChannelPair; + ncchannels_set_bg_alpha(channels, NCALPHA_OPAQUE); *channels &= 0xffffffffff000000; *channels |= index as NcChannelPair; } diff --git a/rust/src/channel/test/reimplemented.rs b/rust/src/channel/test/reimplemented.rs index 0c10cfcf8..9998f83ab 100644 --- a/rust/src/channel/test/reimplemented.rs +++ b/rust/src/channel/test/reimplemented.rs @@ -3,7 +3,8 @@ use serial_test::serial; use crate::{ - NcChannel, NcChannelPair, NCCELL_BLEND, NCCELL_HIGHCONTRAST, NCCELL_OPAQUE, NCCELL_TRANSPARENT, + NcChannel, NcChannelPair, NCALPHA_BLEND, NCALPHA_HIGHCONTRAST, NCALPHA_OPAQUE, + NCALPHA_TRANSPARENT, }; // NcChannel tests ------------------------------------------------------------- @@ -88,10 +89,10 @@ fn channel_set() { #[serial] fn channel_alpha() { let c: NcChannel = 0x112233; - assert_ne!(crate::ncchannel_alpha(c), NCCELL_TRANSPARENT); + assert_ne!(crate::ncchannel_alpha(c), NCALPHA_TRANSPARENT); - let c: NcChannel = 0x112233 | NCCELL_TRANSPARENT; - assert_eq!(crate::ncchannel_alpha(c), NCCELL_TRANSPARENT); + let c: NcChannel = 0x112233 | NCALPHA_TRANSPARENT; + assert_eq!(crate::ncchannel_alpha(c), NCALPHA_TRANSPARENT); } /// sets the alpha component @@ -99,18 +100,18 @@ fn channel_alpha() { #[serial] fn channel_set_alpha() { let mut c: NcChannel = 0x112233; - crate::ncchannel_set_alpha(&mut c, NCCELL_HIGHCONTRAST); - assert_eq!(NCCELL_HIGHCONTRAST, crate::ncchannel_alpha(c)); + crate::ncchannel_set_alpha(&mut c, NCALPHA_HIGHCONTRAST); + assert_eq!(NCALPHA_HIGHCONTRAST, crate::ncchannel_alpha(c)); - crate::ncchannel_set_alpha(&mut c, NCCELL_TRANSPARENT); - assert_eq!(NCCELL_TRANSPARENT, crate::ncchannel_alpha(c)); + crate::ncchannel_set_alpha(&mut c, NCALPHA_TRANSPARENT); + assert_eq!(NCALPHA_TRANSPARENT, crate::ncchannel_alpha(c)); - crate::ncchannel_set_alpha(&mut c, NCCELL_BLEND); - assert_eq!(NCCELL_BLEND, crate::ncchannel_alpha(c)); + crate::ncchannel_set_alpha(&mut c, NCALPHA_BLEND); + assert_eq!(NCALPHA_BLEND, crate::ncchannel_alpha(c)); - crate::ncchannel_set_alpha(&mut c, NCCELL_OPAQUE); - assert_eq!(NCCELL_OPAQUE, crate::ncchannel_alpha(c)); - // TODO: CHECK for NCCELL_BGDEFAULT_MASK + crate::ncchannel_set_alpha(&mut c, NCALPHA_OPAQUE); + assert_eq!(NCALPHA_OPAQUE, crate::ncchannel_alpha(c)); + // TODO: CHECK for NCALPHA_BGDEFAULT_MASK } /// sets the channel as using the default color @@ -122,7 +123,7 @@ fn channel_set_default() { assert_eq!(true, crate::ncchannel_default_p(channel)); // If we change it from being opaque... - let mut channel_transp = channel | NCCELL_TRANSPARENT; + let mut channel_transp = channel | NCALPHA_TRANSPARENT; assert_eq!(0x_20_112233, channel_transp); // the transparent bit is now set crate::ncchannel_set_not_default(&mut channel_transp); @@ -161,7 +162,7 @@ fn channel_default_p() { let mut c: NcChannel = 0x112233; assert_eq!(true, crate::ncchannel_default_p(c)); - let _ = crate::ncchannel_set_alpha(&mut c, NCCELL_OPAQUE); + let _ = crate::ncchannel_set_alpha(&mut c, NCALPHA_OPAQUE); assert_eq!(true, crate::ncchannel_default_p(c)); crate::ncchannel_set(&mut c, 0x112233); diff --git a/rust/src/fade.rs b/rust/src/fade.rs index 8ddf6bc47..1f76c045b 100644 --- a/rust/src/fade.rs +++ b/rust/src/fade.rs @@ -11,7 +11,7 @@ use std::ffi::c_void; -use crate::{NcIntResult, NcPlane, NcTime, Nc}; +use crate::{Nc, NcIntResult, NcPlane, NcTime}; /// Called for each fade iteration on the NcPlane. /// @@ -19,9 +19,8 @@ use crate::{NcIntResult, NcPlane, NcTime, Nc}; /// and that value is propagated out. /// /// The recommended absolute display time target is passed in 'tspec'. -pub type NcFadeCb = Option< - unsafe extern "C" fn(*mut Nc, *mut NcPlane, *const NcTime, *mut c_void) -> NcIntResult, ->; +pub type NcFadeCb = + Option NcIntResult>; /// Context for a palette fade operation pub type NcFadeCtx = crate::bindings::ffi::ncfadectx; diff --git a/rust/src/macros.rs b/rust/src/macros.rs index 665aa4b19..b520a4af2 100644 --- a/rust/src/macros.rs +++ b/rust/src/macros.rs @@ -5,7 +5,7 @@ #[allow(unused_imports)] // enjoy briefer doc comments -use crate::{NcDirect, NcError, NcPlane, NcResult, Nc, NCRESULT_ERR, NCRESULT_OK}; +use crate::{Nc, NcDirect, NcError, NcPlane, NcResult, NCRESULT_ERR, NCRESULT_OK}; // Sleep, Render & Flush Macros ------------------------------------------------ diff --git a/rust/src/notcurses/methods.rs b/rust/src/notcurses/methods.rs index eed76ef34..59fb3e404 100644 --- a/rust/src/notcurses/methods.rs +++ b/rust/src/notcurses/methods.rs @@ -3,10 +3,10 @@ use core::ptr::{null, null_mut}; use crate::{ - cstring, error, error_ref_mut, notcurses_init, rstring, NcAlign, NcBlitter, NcChannelPair, - NcDim, NcEgc, NcError, NcFile, NcInput, NcLogLevel, NcPlane, NcResult, NcScale, NcSignalSet, - NcStats, NcStyle, NcTime, Nc, NcOptions, NCOPTION_NO_ALTERNATE_SCREEN, - NCOPTION_SUPPRESS_BANNERS, NCRESULT_ERR, + cstring, error, error_ref_mut, notcurses_init, rstring, Nc, NcAlign, NcBlitter, NcChannelPair, + NcDim, NcEgc, NcError, NcFile, NcInput, NcLogLevel, NcOptions, NcPlane, NcResult, NcScale, + NcSignalSet, NcStats, NcStyle, NcTime, NCOPTION_NO_ALTERNATE_SCREEN, NCOPTION_SUPPRESS_BANNERS, + NCRESULT_ERR, }; /// # `NcOptions` Constructors @@ -110,9 +110,7 @@ impl Nc { /// New notcurses context, expects [NcLogLevel] and flags. pub fn with_debug<'a>(loglevel: NcLogLevel, flags: u64) -> NcResult<&'a mut Nc> { - Self::with_options(NcOptions::with_all_options( - loglevel, 0, 0, 0, 0, flags, - )) + Self::with_options(NcOptions::with_all_options(loglevel, 0, 0, 0, 0, flags)) } } @@ -405,11 +403,7 @@ impl Nc { if res as u32 as i32 != -1 { Ok(res) } else { - error![ - -1, - &format!("Nc.getc_blocking({:?})", input_txt), - res - ] + error![-1, &format!("Nc.getc_blocking({:?})", input_txt), res] } } @@ -506,10 +500,7 @@ impl Nc { pub fn palette_size(&self) -> NcResult { let res = unsafe { crate::notcurses_palette_size(self) }; if res == 1 { - return Err(NcError::with_msg( - 1, - "No color support ← Nc.palette_size()", - )); + return Err(NcError::with_msg(1, "No color support ← Nc.palette_size()")); } Ok(res) } @@ -539,10 +530,7 @@ impl Nc { /// /// *C style function: [notcurses_render()][crate::notcurses_render].* pub fn render(&mut self) -> NcResult<()> { - error![ - unsafe { crate::notcurses_render(self) }, - "Nc.render()" - ] + error![unsafe { crate::notcurses_render(self) }, "Nc.render()"] } /// Performs the rendering and rasterization portion of diff --git a/rust/src/notcurses/reimplemented.rs b/rust/src/notcurses/reimplemented.rs index 776fca86c..e3d866d5a 100644 --- a/rust/src/notcurses/reimplemented.rs +++ b/rust/src/notcurses/reimplemented.rs @@ -3,7 +3,7 @@ use core::ptr::{null, null_mut}; use crate::{ - NcAlign, NcDim, NcError, NcInput, NcOffset, NcPlane, NcResult, NcSignalSet, NcTime, Nc, + Nc, NcAlign, NcDim, NcError, NcInput, NcOffset, NcPlane, NcResult, NcSignalSet, NcTime, NCALIGN_CENTER, NCALIGN_LEFT, NCALIGN_RIGHT, NCRESULT_MAX, }; diff --git a/rust/src/palette/methods.rs b/rust/src/palette/methods.rs index a927e9852..16ce6350c 100644 --- a/rust/src/palette/methods.rs +++ b/rust/src/palette/methods.rs @@ -1,6 +1,6 @@ //! `NcPalette` methods and associated functions. -use crate::{error, NcChannel, NcColor, NcPalette, NcPaletteIndex, NcResult, NcRgb, Nc}; +use crate::{error, Nc, NcChannel, NcColor, NcPalette, NcPaletteIndex, NcResult, NcRgb}; impl NcPalette { /// New NcPalette. diff --git a/rust/src/plane/helpers.rs b/rust/src/plane/helpers.rs index 9cde8d652..56936b6f5 100644 --- a/rust/src/plane/helpers.rs +++ b/rust/src/plane/helpers.rs @@ -1,4 +1,4 @@ -use crate::{NcDim, NcOffset, NcPlane, NcPlaneOptions, Nc}; +use crate::{Nc, NcDim, NcOffset, NcPlane, NcPlaneOptions}; /// Helper function for a new NcPlane on C style tests. #[allow(dead_code)] diff --git a/rust/src/plane/methods.rs b/rust/src/plane/methods.rs index e3bfcc26c..848280ee9 100644 --- a/rust/src/plane/methods.rs +++ b/rust/src/plane/methods.rs @@ -5,10 +5,10 @@ use core::{ }; use crate::{ - cstring, error, error_ref, error_ref_mut, rstring, NcAlign, NcAlphaBits, NcBlitter, NcBoxMask, - NcCell, NcChannel, NcChannelPair, NcColor, NcDim, NcEgc, NcError, NcFadeCb, NcOffset, - NcPaletteIndex, NcPixelGeometry, NcPlane, NcPlaneOptions, NcResizeCb, NcResult, NcRgb, NcStyle, - NcTime, Nc, NCRESULT_ERR, + cstring, error, error_ref, error_ref_mut, rstring, Nc, NcAlign, NcAlphaBits, NcBlitter, + NcBoxMask, NcCell, NcChannel, NcChannelPair, NcColor, NcDim, NcEgc, NcError, NcFadeCb, + NcOffset, NcPaletteIndex, NcPixelGeometry, NcPlane, NcPlaneOptions, NcResizeCb, NcResult, + NcRgb, NcStyle, NcTime, NCRESULT_ERR, }; /// # NcPlaneOptions Constructors @@ -98,10 +98,7 @@ impl NcPlane { /// The returned plane will be the top, bottom, and root of this new pile. /// /// *C style function: [ncpile_create()][crate::ncpile_create].* - pub fn with_options<'a>( - nc: &mut Nc, - options: NcPlaneOptions, - ) -> NcResult<&'a mut NcPlane> { + pub fn with_options<'a>(nc: &mut Nc, options: NcPlaneOptions) -> NcResult<&'a mut NcPlane> { error_ref_mut![ unsafe { crate::ncpile_create(nc, &options) }, &format!["NcPlane::with_options(Nc, {:?})", &options] diff --git a/rust/src/visual/methods.rs b/rust/src/visual/methods.rs index 0989f9529..d752769ab 100644 --- a/rust/src/visual/methods.rs +++ b/rust/src/visual/methods.rs @@ -4,9 +4,9 @@ use core::ptr::null_mut; use libc::c_void; use crate::{ - cstring, error, error_ref_mut, rstring, NcBlitter, NcDim, NcDirect, NcDirectF, NcDirectV, + cstring, error, error_ref_mut, rstring, Nc, NcBlitter, NcDim, NcDirect, NcDirectF, NcDirectV, NcError, NcIntResult, NcPixel, NcPlane, NcResult, NcRgba, NcScale, NcTime, NcVGeom, NcVisual, - NcVisualOptions, Nc, NCBLIT_PIXEL, NCRESULT_ERR, + NcVisualOptions, NCBLIT_PIXEL, NCRESULT_ERR, }; /// # NcVisualOptions Constructors @@ -333,11 +333,7 @@ impl NcVisual { /// See [`NcVisualOptions`]. /// /// *C style function: [ncvisual_render()][crate::ncvisual_render].* - pub fn render( - &mut self, - nc: &mut Nc, - options: &NcVisualOptions, - ) -> NcResult<&mut NcPlane> { + pub fn render(&mut self, nc: &mut Nc, options: &NcVisualOptions) -> NcResult<&mut NcPlane> { error_ref_mut![ unsafe { crate::ncvisual_render(nc, self, options) }, "NcVisual.render(Nc, &NcVisualOptions)" diff --git a/rust/src/visual/mod.rs b/rust/src/visual/mod.rs index e8f7e5991..adb09ab64 100644 --- a/rust/src/visual/mod.rs +++ b/rust/src/visual/mod.rs @@ -146,7 +146,7 @@ pub type NcRgba = u32; /// Treats as transparent the color specified in the `transcolor` field. pub const NCVISUAL_OPTION_ADDALPHA: u32 = crate::bindings::ffi::NCVISUAL_OPTION_ADDALPHA; -/// Uses [`NCCELL_BLEND`][crate::NCCELL_BLEND] with visual. +/// Uses [`NCALPHA_BLEND`][crate::NCALPHA_BLEND] with visual. pub const NCVISUAL_OPTION_BLEND: u32 = crate::bindings::ffi::NCVISUAL_OPTION_BLEND; /// allows you to indicate that the n field of ncvisual_options refers not to