rust: +8 plane functions; fix headers; minor fixes

rust/src/cells.rs

@@ -8,10 +8,10 @@
 // - cells_rounded_box
 //
 // static inline functions to reimplement: 45
-// ------------------------------------------ (done / wont / remaining)
+// ------------------------------------------ (done / (x) wont / remaining)
-// - implement : 2 / 0 / 43
+// (+) implement : 2 / 0 / 43
-// - unit tests: 0 / 0 / 45
+// (#) unit tests: 0 / 0 / 45
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// ------------------------------------------
 // cell_bchannel
 // cell_bg
 // cell_bg_alpha
@@ -49,7 +49,7 @@
 // cell_set_fg_rgb
 // cell_set_fg_rgb_clipped
 // cell_simple_p
-//+cells_load_box  // FIXME
+//+cells_load_box            // FIXME
 // cell_strdup
 // cell_styles
 // cell_styles_off
@@ -57,10 +57,6 @@
 // cell_styles_set
 // cell_wide_left_p
 // cell_wide_right_p
-//
-// NOTE:
-// - ? gcluster (&str) > type alias?
-// - ? attr (u32)  > type alias?
 
 use cstr_core::CString;
 

rust/src/channel.rs

@@ -15,10 +15,10 @@
 // ------------------------------------------
 //
 // static inline functions to reimplement: 38
-// ------------------------------------------ (done / wont / remaining)
+// ------------------------------------------ (done / (x) wont / remaining)
-// - implement : 34 / 3 /  1
+// (+) implement : 34 / 3 /  1
-// - unit tests: 14 / 0 / 21
+// (#) unit tests: 14 / 0 / 21
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// ------------------------------------------
 //#channel_alpha
 //#channel_b
 //#channel_default_p
@@ -115,7 +115,7 @@ pub fn channel_alpha(channel: Channel) -> Alpha {
 /// Set the 2-bit alpha component of the 32-bit channel.
 #[inline]
 pub fn channel_set_alpha(channel: &mut Channel, alpha: Alpha) {
-    let mut alpha_clean = alpha & ffi::NCCHANNEL_ALPHA_MASK;
+    let alpha_clean = alpha & ffi::NCCHANNEL_ALPHA_MASK;
     *channel = alpha_clean | (*channel & !ffi::NCCHANNEL_ALPHA_MASK);
 
     if alpha != ffi::CELL_ALPHA_OPAQUE {
@@ -283,13 +283,13 @@ pub fn channels_set_fg_alpha(channels: &mut ChannelPair, alpha: Alpha) {
 // TODO: TEST
 #[inline]
 pub fn channels_set_bg_alpha(channels: &mut ChannelPair, alpha: Alpha) {
-    let mut _alpha_clean = alpha;
+    let mut alpha_clean = alpha;
     if alpha == ffi::CELL_ALPHA_HIGHCONTRAST {
         // forbidden for background alpha, so makes it opaque
-        _alpha_clean = ffi::CELL_ALPHA_OPAQUE;
+        alpha_clean = ffi::CELL_ALPHA_OPAQUE;
     }
     let mut channel = channels_bchannel(*channels);
-    channel_set_alpha(&mut channel, _alpha_clean);
+    channel_set_alpha(&mut channel, alpha_clean);
     channels_set_bchannel(channels, channel);
 }
 
@@ -473,7 +473,7 @@ mod test {
         let mut c: Channel = 0x112233;
         assert_eq!(true, super::channel_default_p(c));
 
-        // TODO FIXME: succesfully test for the false result
+        // TODO FIXME: test for the false result
         // let _ = super::channel_set_alpha(&mut c, ffi::CELL_ALPHA_TRANSPARENT);
         // assert_eq!(false, super::channel_default_p(c));
 

rust/src/key.rs

@@ -2,10 +2,10 @@
 // ------------------------------------------
 //
 // static inline functions to reimplement: 2
-// ------------------------------------------ (done / wont / remaining)
+// ------------------------------------------ (done / (x) wont / remaining)
-// - implement : 2 / 0 / 0
+// (+) implement : 2 / 0 / 0
-// - unit tests: 0 / 0 / 2
+// (#) unit tests: 0 / 0 / 2
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// ------------------------------------------
 //+nckey_mouse_p
 //+nckey_supppuab_p
 

rust/src/keycodes.rs

@@ -106,7 +106,7 @@ pub const NCKEY_COPY: u32 = suppuabize(132);
 pub const NCKEY_EXIT: u32 = suppuabize(133);
 pub const NCKEY_PRINT: u32 = suppuabize(134);
 pub const NCKEY_REFRESH: u32 = suppuabize(135);
-//
+
 // Mouse events. We try to encode some details into the char32_t (i.e. which
 // button was pressed);, but some is embedded in the ncinput event. The release
 // event is generic across buttons; callers must maintain state, if they care.

rust/src/nc.rs

@@ -37,10 +37,10 @@
 // notcurses_version_components
 //
 // static inline functions to reimplement: 4
-// ----------------------------------------- (done / wont / remaining)
+// ----------------------------------------- (done / (x) wont / remaining)
-// - implement : 0 / 0 / 4
+// (+) implement : 0 / 0 / 4
-// - unit tests: 0 / 0 / 4
+// (#) unit tests: 0 / 0 / 4
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// -----------------------------------------
 // notcurses_getc_blocking
 // notcurses_getc_nblock
 // notcurses_stddim_yx

rust/src/palette.rs

@@ -1,6 +1,6 @@
-// ---------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
-// NOTE: Now none of these functions can't fail and therefore don't return errors.
+// Now none of these functions can't fail and therefore don't return errors.
-// ---------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 //
 // functions already exported by bindgen : 3
 // -----------------------------------------
@@ -9,10 +9,10 @@
 // palette256_use
 //
 // static inline functions to reimplement: 3
-// ----------------------------------------- (done / wont / remaining)
+// ----------------------------------------- (done / (x) wont / remaining)
-// - implement : 1 / 0 / 2
+// (+) implement : 1 / 0 / 2
-// - unit tests: 0 / 0 / 3
+// (#) unit tests: 0 / 0 / 3
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// -----------------------------------------
 //+palette256_get_rgb
 //+palette256_set
 //+palette256_set_rgb

rust/src/pixel.rs

@@ -12,10 +12,10 @@
 // -----------------------------------------
 //
 // static inline functions to reimplement: 10
-// ------------------------------------------ (done / wont / remaining)
+// ------------------------------------------ (done / (x) wont / remaining)
-// - implement : 10 /  0 /  0
+// (+) implement : 10 /  0 /  0
-// - unit tests:  0 /  0 / 10
+// (#) unit tests:  0 /  0 / 10
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// ------------------------------------------
 //+ncpixel
 //+ncpixel_a
 //+ncpixel_b

rust/src/plane.rs

@@ -88,27 +88,27 @@
 // ncplane_yx
 //
 // static inline functions to reimplement: 42
-// ------------------------------------------ (done / wont / remaining)
+// ------------------------------------------ (done / (x) wont / remaining)
-// - implement : 4 / 0 / 38
+// (+) implement : 10 / … / 32
-// - unit tests: 0 / 0 / 42
+// (#) unit tests:  0 / … / 42
-// --------------- (+) implemented (#) + unit test (x) wont implement
+// ------------------------------------------
 // ncplane_align
 // ncplane_at_cursor_cell
 // ncplane_at_yx_cell
-// ncplane_bchannel
+//+ncplane_bchannel
-// ncplane_bg
+//+ncplane_bg
-// ncplane_bg_alpha
+//+ncplane_bg_alpha
-// ncplane_bg_default_p
+//+ncplane_bg_default_p
 //+ncplane_bg_rgb
 // ncplane_box_sized
 //+ncplane_dim_x
 //+ncplane_dim_y
 // ncplane_double_box
 // ncplane_double_box_sized
-// ncplane_fchannel
+//+ncplane_fchannel
-// ncplane_fg
+//+ncplane_fg
-// ncplane_fg_alpha
+//+ncplane_fg_alpha
-// ncplane_fg_default_p
+//+ncplane_fg_default_p
 //+ncplane_fg_rgb
 // ncplane_gradient_sized
 // ncplane_highgradient_sized
@@ -139,7 +139,7 @@ use core::ptr::null_mut;
 use cstr_core::CString;
 
 use crate as ffi;
-use ffi::types::{Channel, Color, IntResult};
+use ffi::types::{Alpha, Channel, Color, IntResult};
 
 pub fn ncplane_putstr(plane: *mut ffi::ncplane, _str: &str) -> i32 {
     unsafe {
@@ -486,53 +486,62 @@ pub fn ncplane_perimeter(
 //   return ncplane_highgradient(n, ul, ur, ll, lr, y + ylen - 1, x + xlen - 1);
 // }
 
-// // Extract the 32-bit working background channel from an ncplane.
+/// Extract the 32-bit working foreground channel from an ncplane.
-// static inline unsigned
+// TODO: TEST
-// ncplane_bchannel(const struct ncplane* nc){
+#[inline]
-//   return channels_bchannel(ncplane_channels(nc));
+pub fn ncplane_fchannel(plane: &ffi::ncplane) -> Channel {
-// }
+    ffi::channels_fchannel(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Extract the 32-bit working foreground channel from an ncplane.
+/// Extract the 32-bit working background channel from an ncplane.
-// static inline unsigned
+// TODO: TEST
-// ncplane_fchannel(const struct ncplane* nc){
+#[inline]
-//   return channels_fchannel(ncplane_channels(nc));
+pub fn ncplane_bchannel(plane: &ffi::ncplane) -> Channel {
-// }
+    ffi::channels_bchannel(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs.
+/// Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs.
-// static inline unsigned
+// TODO: TEST
-// ncplane_fg(const struct ncplane* nc){
+#[inline]
-//   return channels_fg(ncplane_channels(nc));
+pub fn ncplane_fg(plane: &ffi::ncplane) -> Channel {
-// }
+    ffi::channels_fg(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Extract 24 bits of working background RGB from an ncplane, shifted to LSBs.
-// static inline unsigned
-// ncplane_bg(const struct ncplane* nc){
-//   return channels_bg(ncplane_channels(nc));
-// }
 
-// // Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs.
+/// Extract 24 bits of working background RGB from an ncplane, shifted to LSBs.
-// static inline unsigned
+// TODO: TEST
-// ncplane_fg_alpha(const struct ncplane* nc){
+#[inline]
-//   return channels_fg_alpha(ncplane_channels(nc));
+pub fn ncplane_bg(plane: &ffi::ncplane) -> Channel {
-// }
+    ffi::channels_bg(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Is the plane's foreground using the "default foreground color"?
+/// Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs.
-// static inline bool
+// TODO: TEST
-// ncplane_fg_default_p(const struct ncplane* nc){
+#[inline]
-//   return channels_fg_default_p(ncplane_channels(nc));
+pub fn ncplane_fg_alpha(plane: &ffi::ncplane) -> Alpha {
-// }
+    ffi::channels_fg_alpha(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs.
+/// Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs.
-// static inline unsigned
+// TODO: TEST
-// ncplane_bg_alpha(const struct ncplane* nc){
+#[inline]
-//   return channels_bg_alpha(ncplane_channels(nc));
+pub fn ncplane_bg_alpha(plane: &ffi::ncplane) -> Alpha {
-// }
+    ffi::channels_bg_alpha(unsafe { ffi::ncplane_channels(plane)})
+}
 
-// // Is the plane's background using the "default background color"?
+/// Is the plane's foreground using the "default foreground color"?
-// static inline bool
+// TODO: TEST
-// ncplane_bg_default_p(const struct ncplane* nc){
+#[inline]
-//   return channels_bg_default_p(ncplane_channels(nc));
+pub fn ncplane_fg_default_p(plane: &ffi::ncplane) -> bool {
-// }
+    ffi::channels_fg_default_p(unsafe { ffi::ncplane_channels(plane)})
+}
+
+/// Is the plane's background using the "default background color"?
+// TODO: TEST
+#[inline]
+pub fn ncplane_bg_default_p(plane: &ffi::ncplane) -> bool {
+    ffi::channels_bg_default_p(unsafe { ffi::ncplane_channels(plane)})
+}
 
 /// Extract 24 bits of foreground RGB from a plane, split into components.
 // TODO: TEST