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

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

Browse Source
pull/885/head
joseLuís 4 years ago
parent 4720f23b12
commit d0f691af5f
8 changed files with 96 additions and 91 deletions
Show Stats Download Patch File Download Diff File

14
rust/src/cells.rs
Unescape Escape View File

@ -8,10 +8,10 @@
// - cells_rounded_box
//
// static inline functions to reimplement: 45
// ------------------------------------------ (done / wont / remaining)
// - implement : 2 / 0 / 43
// - unit tests: 0 / 0 / 45
// --------------- (+) implemented (#) + unit test (x) wont implement
// ------------------------------------------ (done / (x) wont / remaining)
// (+) implement : 2 / 0 / 43
// (#) unit tests: 0 / 0 / 45
// ------------------------------------------
// 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;

18
rust/src/channel.rs
Unescape Escape View File

@ -15,10 +15,10 @@
// ------------------------------------------
//
// static inline functions to reimplement: 38
// ------------------------------------------ (done / wont / remaining)
// - implement : 34 / 3 / 1
// - unit tests: 14 / 0 / 21
// --------------- (+) implemented (#) + unit test (x) wont implement
// ------------------------------------------ (done / (x) wont / remaining)
// (+) implement : 34 / 3 / 1
// (#) unit tests: 14 / 0 / 21
// ------------------------------------------
//#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));

8
rust/src/key.rs
Unescape Escape View File

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

2
rust/src/keycodes.rs
Unescape Escape View File

@ -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.

8
rust/src/nc.rs
Unescape Escape View File

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

14
rust/src/palette.rs
Unescape Escape View File

@ -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)
// - implement : 1 / 0 / 2
// - unit tests: 0 / 0 / 3
// --------------- (+) implemented (#) + unit test (x) wont implement
// ----------------------------------------- (done / (x) wont / remaining)
// (+) implement : 1 / 0 / 2
// (#) unit tests: 0 / 0 / 3
// -----------------------------------------
//+palette256_get_rgb
//+palette256_set
//+palette256_set_rgb

8
rust/src/pixel.rs
Unescape Escape View File

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

115
rust/src/plane.rs
Unescape Escape View File

@ -88,27 +88,27 @@
// ncplane_yx
//
// static inline functions to reimplement: 42
// ------------------------------------------ (done / wont / remaining)
// - implement : 4 / 0 / 38
// - unit tests: 0 / 0 / 42
// --------------- (+) implemented (#) + unit test (x) wont implement
// ------------------------------------------ (done / (x) wont / remaining)
// (+) implement : 10 / … / 32
// (#) unit tests: 0 / … / 42
// ------------------------------------------
// ncplane_align
// ncplane_at_cursor_cell
// ncplane_at_yx_cell
// ncplane_bchannel
// ncplane_bg
// ncplane_bg_alpha
// ncplane_bg_default_p
//+ncplane_bchannel
//+ncplane_bg
//+ncplane_bg_alpha
//+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_fg
// ncplane_fg_alpha
// ncplane_fg_default_p
//+ncplane_fchannel
//+ncplane_fg
//+ncplane_fg_alpha
//+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.
// static inline unsigned
// ncplane_bchannel(const struct ncplane* nc){
// return channels_bchannel(ncplane_channels(nc));
// }
/// Extract the 32-bit working foreground channel from an ncplane.
// TODO: TEST
#[inline]
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.
// static inline unsigned
// ncplane_fchannel(const struct ncplane* nc){
// return channels_fchannel(ncplane_channels(nc));
// }
/// Extract the 32-bit working background channel from an ncplane.
// TODO: TEST
#[inline]
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.
// static inline unsigned
// ncplane_fg(const struct ncplane* nc){
// return channels_fg(ncplane_channels(nc));
// }
/// Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs.
// TODO: TEST
#[inline]
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.
// static inline unsigned
// ncplane_fg_alpha(const struct ncplane* nc){
// return channels_fg_alpha(ncplane_channels(nc));
// }
/// Extract 24 bits of working background RGB from an ncplane, shifted to LSBs.
// TODO: TEST
#[inline]
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"?
// static inline bool
// ncplane_fg_default_p(const struct ncplane* nc){
// return channels_fg_default_p(ncplane_channels(nc));
// }
/// Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs.
// TODO: TEST
#[inline]
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.
// static inline unsigned
// ncplane_bg_alpha(const struct ncplane* nc){
// return channels_bg_alpha(ncplane_channels(nc));
// }
/// Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs.
// TODO: TEST
#[inline]
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"?
// static inline bool
// ncplane_bg_default_p(const struct ncplane* nc){
// return channels_bg_default_p(ncplane_channels(nc));
// }
/// Is the plane's foreground using the "default foreground color"?
// TODO: TEST
#[inline]
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

Write Preview
Loading…
Cancel
Save