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

[rust] renamed cell_* functions to nccell_*

Browse Source
pull/1541/head
joseLuís 4 years ago
parent 89fb48a30b
commit 452b7cd535
2 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File

126
rust/src/cells/methods.rs
Unescape Escape View File

@ -122,106 +122,106 @@ impl NcCell {
/// Extracts the background [NcAlphaBits] (shifted to LSBs). /// Extracts the background [NcAlphaBits] (shifted to LSBs).
/// ///
/// *C style function: [cell_bg_alpha()][crate::cell_bg_alpha].* /// *C style function: [nccell_bg_alpha()][crate::nccell_bg_alpha].*
pub fn bg_alpha(&self) -> NcAlphaBits { pub fn bg_alpha(&self) -> NcAlphaBits {
crate::cell_bg_alpha(self) crate::nccell_bg_alpha(self)
} }
/// Is the background [NcChannel] using the "default background color"? /// Is the background [NcChannel] using the "default background color"?
/// ///
/// *C style function: [cell_bg_default_p()][crate::cell_bg_default_p].* /// *C style function: [nccell_bg_default_p()][crate::nccell_bg_default_p].*
pub fn bg_default_p(&self) -> bool { pub fn bg_default_p(&self) -> bool {
crate::cell_bg_default_p(self) crate::nccell_bg_default_p(self)
} }
/// Gets the [NcPaletteIndex] of the background [NcChannel]. /// Gets the [NcPaletteIndex] of the background [NcChannel].
/// ///
/// *C style function: [cell_bg_palindex()][crate::cell_bg_palindex].* /// *C style function: [nccell_bg_palindex()][crate::nccell_bg_palindex].*
pub fn bg_palindex(&self) -> NcPaletteIndex { pub fn bg_palindex(&self) -> NcPaletteIndex {
crate::cell_bg_palindex(self) crate::nccell_bg_palindex(self)
} }
/// Is the background [NcChannel] using an [NcPaletteIndex] indexed /// Is the background [NcChannel] using an [NcPaletteIndex] indexed
/// [NcPalette][crate::NcPalette] color? /// [NcPalette][crate::NcPalette] color?
/// ///
/// *C style function: [cell_bg_palindex_p()][crate::cell_bg_palindex_p].* /// *C style function: [nccell_bg_palindex_p()][crate::nccell_bg_palindex_p].*
pub fn bg_palindex_p(&self) -> bool { pub fn bg_palindex_p(&self) -> bool {
crate::cell_bg_palindex_p(self) crate::nccell_bg_palindex_p(self)
} }
/// Gets the background [NcRgb] (shifted to LSBs). /// Gets the background [NcRgb] (shifted to LSBs).
/// ///
/// *C style function: [cell_bg_rgb()][crate::cell_bg_rgb].* /// *C style function: [nccell_bg_rgb()][crate::nccell_bg_rgb].*
pub fn bg_rgb(&self) -> NcRgb { pub fn bg_rgb(&self) -> NcRgb {
crate::cell_bg_rgb(self) crate::nccell_bg_rgb(self)
} }
/// Gets the background [NcColor] RGB components. /// Gets the background [NcColor] RGB components.
/// ///
/// *C style function: [cell_bg_rgb8()][crate::cell_bg_rgb8].* /// *C style function: [nccell_bg_rgb8()][crate::nccell_bg_rgb8].*
pub fn bg_rgb8(&self) -> (NcColor, NcColor, NcColor) { pub fn bg_rgb8(&self) -> (NcColor, NcColor, NcColor) {
let (mut r, mut g, mut b) = (0, 0, 0); let (mut r, mut g, mut b) = (0, 0, 0);
crate::cell_bg_rgb8(self, &mut r, &mut g, &mut b); crate::nccell_bg_rgb8(self, &mut r, &mut g, &mut b);
(r, g, b) (r, g, b)
} }
/// Extracts the foreground [NcAlphaBits] (shifted to LSBs). /// Extracts the foreground [NcAlphaBits] (shifted to LSBs).
/// ///
/// *C style function: [cell_fg_alpha()][crate::cell_fg_alpha].* /// *C style function: [nccell_fg_alpha()][crate::nccell_fg_alpha].*
pub fn fg_alpha(&self) -> NcAlphaBits { pub fn fg_alpha(&self) -> NcAlphaBits {
crate::cell_fg_alpha(self) crate::nccell_fg_alpha(self)
} }
/// Is the foreground [NcChannel] using the "default foreground color"? /// Is the foreground [NcChannel] using the "default foreground color"?
/// ///
/// *C style function: [cell_fg_default_p()][crate::cell_fg_default_p].* /// *C style function: [nccell_fg_default_p()][crate::nccell_fg_default_p].*
pub fn fg_default_p(&self) -> bool { pub fn fg_default_p(&self) -> bool {
crate::cell_fg_default_p(self) crate::nccell_fg_default_p(self)
} }
/// Gets the [NcPaletteIndex] of the foreground [NcChannel]. /// Gets the [NcPaletteIndex] of the foreground [NcChannel].
/// ///
/// *C style function: [cell_fg_palindex()][crate::cell_fg_palindex].* /// *C style function: [nccell_fg_palindex()][crate::nccell_fg_palindex].*
pub fn fg_palindex(&self) -> NcPaletteIndex { pub fn fg_palindex(&self) -> NcPaletteIndex {
crate::cell_fg_palindex(self) crate::nccell_fg_palindex(self)
} }
/// Is the foreground [NcChannel] using an [NcPaletteIndex] indexed /// Is the foreground [NcChannel] using an [NcPaletteIndex] indexed
/// [NcPalette][crate::NcPalette] color? /// [NcPalette][crate::NcPalette] color?
/// ///
/// *C style function: [cell_fg_palindex_p()][crate::cell_fg_palindex_p].* /// *C style function: [nccell_fg_palindex_p()][crate::nccell_fg_palindex_p].*
pub fn fg_palindex_p(&self) -> bool { pub fn fg_palindex_p(&self) -> bool {
crate::cell_fg_palindex_p(self) crate::nccell_fg_palindex_p(self)
} }
/// Gets the foreground [NcRgb] (shifted to LSBs). /// Gets the foreground [NcRgb] (shifted to LSBs).
/// ///
/// *C style function: [cell_fg_rgb()][crate::cell_fg_rgb].* /// *C style function: [nccell_fg_rgb()][crate::nccell_fg_rgb].*
pub fn fg_rgb(&self) -> NcRgb { pub fn fg_rgb(&self) -> NcRgb {
crate::cell_fg_rgb(self) crate::nccell_fg_rgb(self)
} }
/// Gets the foreground [NcColor] RGB components. /// Gets the foreground [NcColor] RGB components.
/// ///
/// *C style function: [cell_fg_rgb8()][crate::cell_fg_rgb8].* /// *C style function: [nccell_fg_rgb8()][crate::nccell_fg_rgb8].*
pub fn fg_rgb8(&self) -> (NcColor, NcColor, NcColor) { pub fn fg_rgb8(&self) -> (NcColor, NcColor, NcColor) {
let (mut r, mut g, mut b) = (0, 0, 0); let (mut r, mut g, mut b) = (0, 0, 0);
crate::cell_fg_rgb8(self, &mut r, &mut g, &mut b); crate::nccell_fg_rgb8(self, &mut r, &mut g, &mut b);
(r, g, b) (r, g, b)
} }
/// Sets the background [NcAlphaBits]. /// Sets the background [NcAlphaBits].
/// ///
/// *C style function: [cell_set_bg_alpha()][crate::cell_set_bg_alpha].* /// *C style function: [nccell_set_bg_alpha()][crate::nccell_set_bg_alpha].*
pub fn set_bg_alpha(&mut self, alpha: NcAlphaBits) { pub fn set_bg_alpha(&mut self, alpha: NcAlphaBits) {
crate::cell_set_bg_alpha(self, alpha); crate::nccell_set_bg_alpha(self, alpha);
} }
/// Indicates to use the "default color" for the background [NcChannel]. /// Indicates to use the "default color" for the background [NcChannel].
/// ///
/// *C style function: [cell_set_bg_default()][crate::cell_set_bg_default].* /// *C style function: [nccell_set_bg_default()][crate::nccell_set_bg_default].*
pub fn set_bg_default(&mut self) { pub fn set_bg_default(&mut self) {
crate::cell_set_bg_default(self); crate::nccell_set_bg_default(self);
} }
/// Sets the background [NcPaletteIndex]. /// Sets the background [NcPaletteIndex].
@ -230,38 +230,38 @@ impl NcCell {
/// [NCCELL_ALPHA_OPAQUE][crate::NCCELL_ALPHA_OPAQUE], and clears out /// [NCCELL_ALPHA_OPAQUE][crate::NCCELL_ALPHA_OPAQUE], and clears out
/// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK]. /// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK].
/// ///
/// *C style function: [cell_set_bg_palindex()][crate::cell_set_bg_palindex].* /// *C style function: [nccell_set_bg_palindex()][crate::nccell_set_bg_palindex].*
pub fn set_bg_palindex(&mut self, index: NcPaletteIndex) { pub fn set_bg_palindex(&mut self, index: NcPaletteIndex) {
crate::cell_set_bg_palindex(self, index); crate::nccell_set_bg_palindex(self, index);
} }
/// Sets the background [NcRgb] and marks it as not using the default color. /// Sets the background [NcRgb] and marks it as not using the default color.
/// ///
/// *C style function: [cell_set_bg_rgb()][crate::cell_set_bg_rgb].* /// *C style function: [nccell_set_bg_rgb()][crate::nccell_set_bg_rgb].*
pub fn set_bg_rgb(&mut self, rgb: NcRgb) { pub fn set_bg_rgb(&mut self, rgb: NcRgb) {
crate::cell_set_bg_rgb(self, rgb); crate::nccell_set_bg_rgb(self, rgb);
} }
/// Sets the background [NcColor] RGB components, and marks it as not using /// Sets the background [NcColor] RGB components, and marks it as not using
/// the "default color". /// the "default color".
/// ///
/// *C style function: [cell_set_bg_rgb8()][crate::cell_set_bg_rgb8].* /// *C style function: [nccell_set_bg_rgb8()][crate::nccell_set_bg_rgb8].*
pub fn set_bg_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor) { pub fn set_bg_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor) {
crate::cell_set_bg_rgb8(self, red, green, blue); crate::nccell_set_bg_rgb8(self, red, green, blue);
} }
/// Sets the foreground [NcAlphaBits]. /// Sets the foreground [NcAlphaBits].
/// ///
/// *C style function: [cell_set_fg_alpha()][crate::cell_set_fg_alpha].* /// *C style function: [nccell_set_fg_alpha()][crate::nccell_set_fg_alpha].*
pub fn set_fg_alpha(&mut self, alpha: NcAlphaBits) { pub fn set_fg_alpha(&mut self, alpha: NcAlphaBits) {
crate::cell_set_fg_alpha(self, alpha); crate::nccell_set_fg_alpha(self, alpha);
} }
/// Indicates to use the "default color" for the foreground [NcChannel]. /// Indicates to use the "default color" for the foreground [NcChannel].
/// ///
/// *C style function: [cell_set_fg_default()][crate::cell_set_fg_default].* /// *C style function: [nccell_set_fg_default()][crate::nccell_set_fg_default].*
pub fn set_fg_default(&mut self) { pub fn set_fg_default(&mut self) {
crate::cell_set_fg_default(self); crate::nccell_set_fg_default(self);
} }
/// Sets the foreground [NcPaletteIndex]. /// Sets the foreground [NcPaletteIndex].
@ -270,24 +270,24 @@ impl NcCell {
/// [NCCELL_ALPHA_OPAQUE][crate::NCCELL_ALPHA_OPAQUE], and clears out /// [NCCELL_ALPHA_OPAQUE][crate::NCCELL_ALPHA_OPAQUE], and clears out
/// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK]. /// [NCCELL_BGDEFAULT_MASK][crate::NCCELL_BGDEFAULT_MASK].
/// ///
/// *C style function: [cell_set_fg_palindex()][crate::cell_set_fg_palindex].* /// *C style function: [nccell_set_fg_palindex()][crate::nccell_set_fg_palindex].*
pub fn set_fg_palindex(&mut self, index: NcPaletteIndex) { pub fn set_fg_palindex(&mut self, index: NcPaletteIndex) {
crate::cell_set_fg_palindex(self, index); crate::nccell_set_fg_palindex(self, index);
} }
/// Sets the foreground [NcRgb] and marks it as not using the default color. /// Sets the foreground [NcRgb] and marks it as not using the default color.
/// ///
/// *C style function: [cell_set_fg_rgb()][crate::cell_set_fg_rgb].* /// *C style function: [nccell_set_fg_rgb()][crate::nccell_set_fg_rgb].*
pub fn set_fg_rgb(&mut self, rgb: NcRgb) { pub fn set_fg_rgb(&mut self, rgb: NcRgb) {
crate::cell_set_fg_rgb(self, rgb); crate::nccell_set_fg_rgb(self, rgb);
} }
/// Sets the foreground [NcColor] RGB components, and marks it as not using /// Sets the foreground [NcColor] RGB components, and marks it as not using
/// the "default color". /// the "default color".
/// ///
/// *C style function: [cell_set_fg_rgb8()][crate::cell_set_fg_rgb8].* /// *C style function: [nccell_set_fg_rgb8()][crate::nccell_set_fg_rgb8].*
pub fn set_fg_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor) { pub fn set_fg_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor) {
crate::cell_set_fg_rgb8(self, red, green, blue); crate::nccell_set_fg_rgb8(self, red, green, blue);
} }
} }
@ -299,15 +299,15 @@ impl NcCell {
/// The actual egcpool index needn't be the same--indeed, the planes /// The actual egcpool index needn't be the same--indeed, the planes
/// needn't even be the same. Only the expanded NcEgc must be bit-equal. /// needn't even be the same. Only the expanded NcEgc must be bit-equal.
/// ///
/// *C style function: [cellcmp()][crate::cellcmp].* /// *C style function: [nccellcmp()][crate::nccellcmp].*
pub fn compare(plane1: &NcPlane, cell1: &NcCell, plane2: &NcPlane, cell2: &NcCell) -> bool { pub fn compare(plane1: &NcPlane, cell1: &NcCell, plane2: &NcPlane, cell2: &NcCell) -> bool {
crate::cellcmp(plane1, cell1, plane2, cell2) crate::nccellcmp(plane1, cell1, plane2, cell2)
} }
/// Saves the [NcStyleMask] and the [NcChannelPair], and returns the [NcEgc]. /// Saves the [NcStyleMask] and the [NcChannelPair], and returns the [NcEgc].
/// (These are the three elements of an NcCell). /// (These are the three elements of an NcCell).
/// ///
/// *C style function: [cell_fg_alpha()][crate::cell_fg_alpha].* /// *C style function: [nccell_fg_alpha()][crate::nccell_fg_alpha].*
pub fn extract( pub fn extract(
&mut self, &mut self,
plane: &mut NcPlane, plane: &mut NcPlane,
@ -329,30 +329,30 @@ impl NcCell {
/// Returns the [NcStyleMask] bits. /// Returns the [NcStyleMask] bits.
/// ///
/// *C style function: [cell_styles()][crate::cell_styles].* /// *C style function: [nccell_styles()][crate::nccell_styles].*
pub fn styles(&mut self) -> NcStyleMask { pub fn styles(&mut self) -> NcStyleMask {
crate::cell_styles(self) crate::nccell_styles(self)
} }
/// Removes the specified [NcStyleMask] bits. /// Removes the specified [NcStyleMask] bits.
/// ///
/// *C style function: [cell_off()][crate::cell_off_styles].* /// *C style function: [nccell_off()][crate::nccell_off_styles].*
pub fn off_styles(&mut self, stylebits: NcStyleMask) { pub fn off_styles(&mut self, stylebits: NcStyleMask) {
crate::cell_off_styles(self, stylebits) crate::nccell_off_styles(self, stylebits)
} }
/// Adds the specified [NcStyleMask] bits. /// Adds the specified [NcStyleMask] bits.
/// ///
/// *C style function: [cell_on()][crate::cell_on_styles].* /// *C style function: [nccell_on()][crate::nccell_on_styles].*
pub fn on_styles(&mut self, stylebits: NcStyleMask) { pub fn on_styles(&mut self, stylebits: NcStyleMask) {
crate::cell_on_styles(self, stylebits) crate::nccell_on_styles(self, stylebits)
} }
/// Sets just the specified [NcStyleMask] bits. /// Sets just the specified [NcStyleMask] bits.
/// ///
/// *C style function: [cell_set_styles()][crate::cell_set_styles].* /// *C style function: [nccell_set_styles()][crate::nccell_set_styles].*
pub fn set_styles(&mut self, stylebits: NcStyleMask) { pub fn set_styles(&mut self, stylebits: NcStyleMask) {
crate::cell_set_styles(self, stylebits) crate::nccell_set_styles(self, stylebits)
} }
} }
@ -363,9 +363,9 @@ impl NcCell {
// /// This pointer can be invalidated by any further operation on the referred // /// This pointer can be invalidated by any further operation on the referred
// /// plane, so… watch out! // /// plane, so… watch out!
// /// // ///
// /// *C style function: [cell_extended_gcluster()][crate::cell_wide_left_p].* // /// *C style function: [nccell_extended_gcluster()][crate::nccell_wide_left_p].*
// pub fn extended_gcluster(&self, plane: &NcPlane) -> u32 { // pub fn extended_gcluster(&self, plane: &NcPlane) -> u32 {
// let egcpointer = unsafe { crate::cell_extended_gcluster(plane, self) }; // let egcpointer = unsafe { crate::nccell_extended_gcluster(plane, self) };
// egcpointer // egcpointer
// } // }
@ -382,23 +382,23 @@ impl NcCell {
/// Does this NcCell contain a wide codepoint? /// Does this NcCell contain a wide codepoint?
/// ///
/// *C style function: [cell_double_wide_p()][crate::cell_double_wide_p].* /// *C style function: [nccell_double_wide_p()][crate::nccell_double_wide_p].*
pub fn double_wide_p(&self) -> bool { pub fn double_wide_p(&self) -> bool {
crate::cell_double_wide_p(self) crate::nccell_double_wide_p(self)
} }
/// Is this the left half of a wide character? /// Is this the left half of a wide character?
/// ///
/// *C style function: [cell_wide_left_p()][crate::cell_wide_left_p].* /// *C style function: [nccell_wide_left_p()][crate::nccell_wide_left_p].*
pub fn wide_left_p(&self) -> bool { pub fn wide_left_p(&self) -> bool {
crate::cell_wide_right_p(self) crate::nccell_wide_right_p(self)
} }
/// Is this the right side of a wide character? /// Is this the right side of a wide character?
/// ///
/// *C style function: [cell_wide_right_p()][crate::cell_wide_right_p].* /// *C style function: [nccell_wide_right_p()][crate::nccell_wide_right_p].*
pub fn wide_right_p(&self) -> bool { pub fn wide_right_p(&self) -> bool {
crate::cell_wide_right_p(self) crate::nccell_wide_right_p(self)
} }
} }

68
rust/src/cells/reimplemented.rs
Unescape Escape View File

@ -15,7 +15,7 @@ use crate::{
/// ///
/// *Method: NcCell.[fg_alpha()][NcCell#method.fg_alpha].* /// *Method: NcCell.[fg_alpha()][NcCell#method.fg_alpha].*
#[inline] #[inline]
pub fn cell_fg_alpha(cell: &NcCell) -> NcAlphaBits { pub fn nccell_fg_alpha(cell: &NcCell) -> NcAlphaBits {
crate::channels_fg_alpha(cell.channels) crate::channels_fg_alpha(cell.channels)
} }
@ -23,7 +23,7 @@ pub fn cell_fg_alpha(cell: &NcCell) -> NcAlphaBits {
/// ///
/// *Method: NcCell.[bg_alpha()][NcCell#method.bg_alpha].* /// *Method: NcCell.[bg_alpha()][NcCell#method.bg_alpha].*
#[inline] #[inline]
pub fn cell_bg_alpha(cell: &NcCell) -> NcAlphaBits { pub fn nccell_bg_alpha(cell: &NcCell) -> NcAlphaBits {
crate::channels_bg_alpha(cell.channels) crate::channels_bg_alpha(cell.channels)
} }
@ -31,7 +31,7 @@ pub fn cell_bg_alpha(cell: &NcCell) -> NcAlphaBits {
/// ///
/// *Method: NcCell.[set_fg_alpha()][NcCell#method.set_fg_alpha].* /// *Method: NcCell.[set_fg_alpha()][NcCell#method.set_fg_alpha].*
#[inline] #[inline]
pub fn cell_set_fg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) { pub fn nccell_set_fg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) {
crate::channels_set_fg_alpha(&mut cell.channels, alpha); crate::channels_set_fg_alpha(&mut cell.channels, alpha);
} }
@ -39,7 +39,7 @@ pub fn cell_set_fg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) {
/// ///
/// *Method: NcCell.[set_bg_alpha()][NcCell#method.set_bg_alpha].* /// *Method: NcCell.[set_bg_alpha()][NcCell#method.set_bg_alpha].*
#[inline] #[inline]
pub fn cell_set_bg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) { pub fn nccell_set_bg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) {
crate::channels_set_bg_alpha(&mut cell.channels, alpha); crate::channels_set_bg_alpha(&mut cell.channels, alpha);
} }
@ -50,7 +50,7 @@ pub fn cell_set_bg_alpha(cell: &mut NcCell, alpha: NcAlphaBits) {
/// ///
/// *Method: NcCell.[fg_rgb8()][NcCell#method.fg_rgb8].* /// *Method: NcCell.[fg_rgb8()][NcCell#method.fg_rgb8].*
#[inline] #[inline]
pub fn cell_fg_rgb8( pub fn nccell_fg_rgb8(
cell: &NcCell, cell: &NcCell,
red: &mut NcColor, red: &mut NcColor,
green: &mut NcColor, green: &mut NcColor,
@ -64,7 +64,7 @@ pub fn cell_fg_rgb8(
/// ///
/// *Method: NcCell.[bg_rgb8()][NcCell#method.bg_rgb8].* /// *Method: NcCell.[bg_rgb8()][NcCell#method.bg_rgb8].*
#[inline] #[inline]
pub fn cell_bg_rgb8( pub fn nccell_bg_rgb8(
cell: &NcCell, cell: &NcCell,
red: &mut NcColor, red: &mut NcColor,
green: &mut NcColor, green: &mut NcColor,
@ -78,7 +78,7 @@ pub fn cell_bg_rgb8(
/// ///
/// *Method: NcCell.[set_fg_rgb8()][NcCell#method.set_fg_rgb8].* /// *Method: NcCell.[set_fg_rgb8()][NcCell#method.set_fg_rgb8].*
#[inline] #[inline]
pub fn cell_set_fg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: NcColor) { pub fn nccell_set_fg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: NcColor) {
crate::channels_set_fg_rgb8(&mut cell.channels, red, green, blue); crate::channels_set_fg_rgb8(&mut cell.channels, red, green, blue);
} }
@ -87,7 +87,7 @@ pub fn cell_set_fg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: N
/// ///
/// *Method: NcCell.[set_bg_rgb8()][NcCell#method.set_bg_rgb8].* /// *Method: NcCell.[set_bg_rgb8()][NcCell#method.set_bg_rgb8].*
#[inline] #[inline]
pub fn cell_set_bg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: NcColor) { pub fn nccell_set_bg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: NcColor) {
crate::channels_set_bg_rgb8(&mut cell.channels, red, green, blue); crate::channels_set_bg_rgb8(&mut cell.channels, red, green, blue);
} }
@ -97,7 +97,7 @@ pub fn cell_set_bg_rgb8(cell: &mut NcCell, red: NcColor, green: NcColor, blue: N
/// ///
/// *Method: NcCell.[fg_rgb()][NcCell#method.fg_rgb].* /// *Method: NcCell.[fg_rgb()][NcCell#method.fg_rgb].*
#[inline] #[inline]
pub fn cell_fg_rgb(cell: &NcCell) -> NcRgb { pub fn nccell_fg_rgb(cell: &NcCell) -> NcRgb {
crate::channels_fg_rgb(cell.channels) crate::channels_fg_rgb(cell.channels)
} }
@ -105,7 +105,7 @@ pub fn cell_fg_rgb(cell: &NcCell) -> NcRgb {
/// ///
/// *Method: NcCell.[bg_rgb()][NcCell#method.bg_rgb].* /// *Method: NcCell.[bg_rgb()][NcCell#method.bg_rgb].*
#[inline] #[inline]
pub fn cell_bg_rgb(cell: &NcCell) -> NcRgb { pub fn nccell_bg_rgb(cell: &NcCell) -> NcRgb {
crate::channels_bg_rgb(cell.channels) crate::channels_bg_rgb(cell.channels)
} }
@ -114,7 +114,7 @@ pub fn cell_bg_rgb(cell: &NcCell) -> NcRgb {
/// ///
/// *Method: NcCell.[set_fg_rgb()][NcCell#method.set_fg_rgb].* /// *Method: NcCell.[set_fg_rgb()][NcCell#method.set_fg_rgb].*
#[inline] #[inline]
pub fn cell_set_fg_rgb(cell: &mut NcCell, rgb: NcRgb) { pub fn nccell_set_fg_rgb(cell: &mut NcCell, rgb: NcRgb) {
crate::channels_set_fg_rgb(&mut cell.channels, rgb); crate::channels_set_fg_rgb(&mut cell.channels, rgb);
} }
@ -123,7 +123,7 @@ pub fn cell_set_fg_rgb(cell: &mut NcCell, rgb: NcRgb) {
/// ///
/// *Method: NcCell.[set_bg_rgb()][NcCell#method.set_bg_rgb].* /// *Method: NcCell.[set_bg_rgb()][NcCell#method.set_bg_rgb].*
#[inline] #[inline]
pub fn cell_set_bg_rgb(cell: &mut NcCell, rgb: NcRgb) { pub fn nccell_set_bg_rgb(cell: &mut NcCell, rgb: NcRgb) {
crate::channels_set_bg_rgb(&mut cell.channels, rgb); crate::channels_set_bg_rgb(&mut cell.channels, rgb);
} }
@ -134,7 +134,7 @@ pub fn cell_set_bg_rgb(cell: &mut NcCell, rgb: NcRgb) {
/// ///
/// *Method: NcCell.[set_fg_default()][NcCell#method.set_fg_default].* /// *Method: NcCell.[set_fg_default()][NcCell#method.set_fg_default].*
#[inline] #[inline]
pub fn cell_set_fg_default(cell: &mut NcCell) { pub fn nccell_set_fg_default(cell: &mut NcCell) {
crate::channels_set_fg_default(&mut cell.channels); crate::channels_set_fg_default(&mut cell.channels);
} }
@ -143,7 +143,7 @@ pub fn cell_set_fg_default(cell: &mut NcCell) {
/// ///
/// *Method: NcCell.[set_bg_default()][NcCell#method.set_bg_default].* /// *Method: NcCell.[set_bg_default()][NcCell#method.set_bg_default].*
#[inline] #[inline]
pub fn cell_set_bg_default(cell: &mut NcCell) { pub fn nccell_set_bg_default(cell: &mut NcCell) {
crate::channels_set_bg_default(&mut cell.channels); crate::channels_set_bg_default(&mut cell.channels);
} }
@ -152,7 +152,7 @@ pub fn cell_set_bg_default(cell: &mut NcCell) {
/// ///
/// *Method: NcCell.[fg_default_p()][NcCell#method.fg_default_p].* /// *Method: NcCell.[fg_default_p()][NcCell#method.fg_default_p].*
#[inline] #[inline]
pub fn cell_fg_default_p(cell: &NcCell) -> bool { pub fn nccell_fg_default_p(cell: &NcCell) -> bool {
crate::channels_fg_default_p(cell.channels) crate::channels_fg_default_p(cell.channels)
} }
@ -164,7 +164,7 @@ pub fn cell_fg_default_p(cell: &NcCell) -> bool {
/// ///
/// *Method: NcCell.[bg_default_p()][NcCell#method.bg_default_p].* /// *Method: NcCell.[bg_default_p()][NcCell#method.bg_default_p].*
#[inline] #[inline]
pub fn cell_bg_default_p(cell: &NcCell) -> bool { pub fn nccell_bg_default_p(cell: &NcCell) -> bool {
crate::channels_bg_default_p(cell.channels) crate::channels_bg_default_p(cell.channels)
} }
@ -175,7 +175,7 @@ pub fn cell_bg_default_p(cell: &NcCell) -> bool {
/// ///
/// *Method: NcCell.[fg_palindex_p()][NcCell#method.fg_palindex_p].* /// *Method: NcCell.[fg_palindex_p()][NcCell#method.fg_palindex_p].*
#[inline] #[inline]
pub fn cell_fg_palindex_p(cell: &NcCell) -> bool { pub fn nccell_fg_palindex_p(cell: &NcCell) -> bool {
crate::channels_fg_palindex_p(cell.channels) crate::channels_fg_palindex_p(cell.channels)
} }
@ -184,7 +184,7 @@ pub fn cell_fg_palindex_p(cell: &NcCell) -> bool {
/// ///
/// *Method: NcCell.[bg_palindex_p()][NcCell#method.bg_palindex_p].* /// *Method: NcCell.[bg_palindex_p()][NcCell#method.bg_palindex_p].*
#[inline] #[inline]
pub fn cell_bg_palindex_p(cell: &NcCell) -> bool { pub fn nccell_bg_palindex_p(cell: &NcCell) -> bool {
crate::channels_bg_palindex_p(cell.channels) crate::channels_bg_palindex_p(cell.channels)
} }
@ -192,7 +192,7 @@ pub fn cell_bg_palindex_p(cell: &NcCell) -> bool {
/// ///
/// *Method: NcCell.[fg_palindex()][NcCell#method.fg_palindex].* /// *Method: NcCell.[fg_palindex()][NcCell#method.fg_palindex].*
#[inline] #[inline]
pub const fn cell_fg_palindex(cell: &NcCell) -> NcPaletteIndex { pub const fn nccell_fg_palindex(cell: &NcCell) -> NcPaletteIndex {
((cell.channels & 0xff00000000 as NcChannelPair) >> 32) as NcPaletteIndex ((cell.channels & 0xff00000000 as NcChannelPair) >> 32) as NcPaletteIndex
} }
@ -200,7 +200,7 @@ pub const fn cell_fg_palindex(cell: &NcCell) -> NcPaletteIndex {
/// ///
/// *Method: NcCell.[bg_palindex()][NcCell#method.bg_palindex].* /// *Method: NcCell.[bg_palindex()][NcCell#method.bg_palindex].*
#[inline] #[inline]
pub const fn cell_bg_palindex(cell: &NcCell) -> NcPaletteIndex { pub const fn nccell_bg_palindex(cell: &NcCell) -> NcPaletteIndex {
(cell.channels & 0xff) as NcPaletteIndex (cell.channels & 0xff) as NcPaletteIndex
} }
@ -213,10 +213,10 @@ pub const fn cell_bg_palindex(cell: &NcCell) -> NcPaletteIndex {
// //
// NOTE: unlike the original C function, this one can't fail // NOTE: unlike the original C function, this one can't fail
#[inline] #[inline]
pub fn cell_set_fg_palindex(cell: &mut NcCell, index: NcPaletteIndex) { pub fn nccell_set_fg_palindex(cell: &mut NcCell, index: NcPaletteIndex) {
cell.channels |= NCCELL_FGDEFAULT_MASK; cell.channels |= NCCELL_FGDEFAULT_MASK;
cell.channels |= NCCELL_FG_PALETTE; cell.channels |= NCCELL_FG_PALETTE;
cell_set_fg_alpha(cell, NCCELL_ALPHA_OPAQUE); nccell_set_fg_alpha(cell, NCCELL_ALPHA_OPAQUE);
cell.channels &= 0xff000000ffffffff as NcChannelPair; cell.channels &= 0xff000000ffffffff as NcChannelPair;
cell.channels |= (index as NcChannelPair) << 32; cell.channels |= (index as NcChannelPair) << 32;
} }
@ -230,10 +230,10 @@ pub fn cell_set_fg_palindex(cell: &mut NcCell, index: NcPaletteIndex) {
// //
// NOTE: unlike the original C function, this one can't fail // NOTE: unlike the original C function, this one can't fail
#[inline] #[inline]
pub fn cell_set_bg_palindex(cell: &mut NcCell, index: NcPaletteIndex) { pub fn nccell_set_bg_palindex(cell: &mut NcCell, index: NcPaletteIndex) {
cell.channels |= NCCELL_BGDEFAULT_MASK as NcChannelPair; cell.channels |= NCCELL_BGDEFAULT_MASK as NcChannelPair;
cell.channels |= NCCELL_BG_PALETTE as NcChannelPair; cell.channels |= NCCELL_BG_PALETTE as NcChannelPair;
cell_set_bg_alpha(cell, NCCELL_ALPHA_OPAQUE); nccell_set_bg_alpha(cell, NCCELL_ALPHA_OPAQUE);
cell.channels &= 0xffffffffff000000; cell.channels &= 0xffffffffff000000;
cell.channels |= index as NcChannelPair; cell.channels |= index as NcChannelPair;
} }
@ -244,7 +244,7 @@ pub fn cell_set_bg_palindex(cell: &mut NcCell, index: NcPaletteIndex) {
/// ///
/// *Method: NcCell.[cell_styles()][NcCell#method.cell_styles].* /// *Method: NcCell.[cell_styles()][NcCell#method.cell_styles].*
#[inline] #[inline]
pub const fn cell_styles(cell: &NcCell) -> NcStyleMask { pub const fn nccell_styles(cell: &NcCell) -> NcStyleMask {
cell.stylemask cell.stylemask
} }
@ -253,7 +253,7 @@ pub const fn cell_styles(cell: &NcCell) -> NcStyleMask {
/// ///
/// *Method: NcCell.[styles_on()][NcCell#method.styles_on].* /// *Method: NcCell.[styles_on()][NcCell#method.styles_on].*
#[inline] #[inline]
pub fn cell_on_styles(cell: &mut NcCell, stylebits: NcStyleMask) { pub fn nccell_on_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
cell.stylemask |= stylebits & NCSTYLE_MASK as u16; cell.stylemask |= stylebits & NCSTYLE_MASK as u16;
} }
@ -261,7 +261,7 @@ pub fn cell_on_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
/// ///
/// *Method: NcCell.[styles_off()][NcCell#method.styles_off].* /// *Method: NcCell.[styles_off()][NcCell#method.styles_off].*
#[inline] #[inline]
pub fn cell_off_styles(cell: &mut NcCell, stylebits: NcStyleMask) { pub fn nccell_off_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
cell.stylemask &= !(stylebits & NCSTYLE_MASK as u16); cell.stylemask &= !(stylebits & NCSTYLE_MASK as u16);
} }
@ -270,7 +270,7 @@ pub fn cell_off_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
/// ///
/// *Method: NcCell.[styles_set()][NcCell#method.styles_set].* /// *Method: NcCell.[styles_set()][NcCell#method.styles_set].*
#[inline] #[inline]
pub fn cell_set_styles(cell: &mut NcCell, stylebits: NcStyleMask) { pub fn nccell_set_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
cell.stylemask = stylebits & NCSTYLE_MASK as u16; cell.stylemask = stylebits & NCSTYLE_MASK as u16;
} }
@ -280,7 +280,7 @@ pub fn cell_set_styles(cell: &mut NcCell, stylebits: NcStyleMask) {
/// ///
/// *Method: NcCell.[double_wide_p()][NcCell#method.double_wide_p].* /// *Method: NcCell.[double_wide_p()][NcCell#method.double_wide_p].*
#[inline] #[inline]
pub const fn cell_double_wide_p(cell: &NcCell) -> bool { pub const fn nccell_double_wide_p(cell: &NcCell) -> bool {
cell.width > 0 cell.width > 0
} }
@ -288,16 +288,16 @@ pub const fn cell_double_wide_p(cell: &NcCell) -> bool {
/// ///
/// *Method: NcCell.[wide_right_p()][NcCell#method.wide_right_p].* /// *Method: NcCell.[wide_right_p()][NcCell#method.wide_right_p].*
#[inline] #[inline]
pub const fn cell_wide_right_p(cell: &NcCell) -> bool { pub const fn nccell_wide_right_p(cell: &NcCell) -> bool {
cell_double_wide_p(cell) && cell.gcluster == 0 nccell_double_wide_p(cell) && cell.gcluster == 0
} }
/// Is this the left half of a wide character? /// Is this the left half of a wide character?
/// ///
/// *Method: NcCell.[wide_left_p()][NcCell#method.wide_left_p].* /// *Method: NcCell.[wide_left_p()][NcCell#method.wide_left_p].*
#[inline] #[inline]
pub const fn cell_wide_left_p(cell: &NcCell) -> bool { pub const fn nccell_wide_left_p(cell: &NcCell) -> bool {
cell_double_wide_p(cell) && cell.gcluster != 0 nccell_double_wide_p(cell) && cell.gcluster != 0
} }
// /// Loads a 7-bit [NcEgc] character into the [NcCell]. // /// Loads a 7-bit [NcEgc] character into the [NcCell].
@ -391,7 +391,7 @@ pub fn nccell_extract(
// //
// NOTE: FIXME: it would probably be better to test whether they're Unicode-equal // NOTE: FIXME: it would probably be better to test whether they're Unicode-equal
#[inline] #[inline]
pub fn cellcmp(plane1: &NcPlane, cell1: &NcCell, plane2: &NcPlane, cell2: &NcCell) -> bool { pub fn nccellcmp(plane1: &NcPlane, cell1: &NcCell, plane2: &NcPlane, cell2: &NcCell) -> bool {
if cell1.stylemask != cell2.stylemask { if cell1.stylemask != cell2.stylemask {
return true; return true;
} }

Write Preview
Loading…
Cancel
Save