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

Merge branch 'master' of github.com:dankamongmen/notcurses into master

Browse Source
pull/885/head
nick black 4 years ago
parent 172ef7580f d0f691af5f
commit 097bf20d07
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
8 changed files with 111 additions and 123 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;

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

@ -1,37 +1,27 @@
// ---------------------------------------------------------------------------------------
// - NOTE: The channel components are u8 instead of u32.
// - The channel components are u8 instead of u32.
// Because of type enforcing, some runtime checks are now unnecessary.
//
// - NOTE: These functions now can't fail and don't have to return an error:
// - `channel_set_rgb()`
// - `channels_set_fg_rgb()`
// - `channels_set_bg_rgb()`
// - `channel_set()`
// - `channels_set_fg()`
// - `channels_set_bg()`
// - None of the functions can't fail now. The original checks for dirty bits
// have been substitued by mask cleaning (bitwise and)
//
// - NOTE: These functions were therefore deemed unnecessary to implement:
// - These functions were deemed unnecessary to implement:
// - `channel_set_rgb_clipped()`
// - `channels_set_fg_rgb_clipped()`
// - `channels_set_bg_rgb_clipped()`
//
// - These functions still return an integer error result:
// - `channel_set_alpha()`
// - `channels_set_fg_alpha()`
// - `channels_set_bg_alpha()`
// ---------------------------------------------------------------------------------------
//
// functions already exported by bindgen : 0
// ------------------------------------------
//
// 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 // FIXME TEST
//#channel_default_p
//#channel_g
//+channel_palindex_p
//#channel_r
@ -42,7 +32,7 @@
//+channels_bg_default_p
//+channels_bg_palindex_p
//+channels_bg_rgb
// channels_blend // TODO
// channels_blend // TODO
//#channels_combine
//+channel_set
//#channel_set_alpha
@ -67,12 +57,12 @@
//+channels_set_fg_default
//+channels_set_fg_rgb
//xchannels_set_fg_rgb_clipped
//
#![allow(dead_code)]
use crate as ffi;
use crate::types::{Alpha, Channel, ChannelPair, Color, IntResult, Rgb};
use crate::types::{Alpha, Channel, ChannelPair, Color, Rgb};
/// Extract the 8-bit red component from a 32-bit channel.
#[inline]
@ -124,16 +114,14 @@ 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) -> IntResult {
if (alpha & !ffi::NCCHANNEL_ALPHA_MASK) != 0 {
return -1;
}
*channel = alpha | (*channel & !ffi::NCCHANNEL_ALPHA_MASK);
pub fn channel_set_alpha(channel: &mut Channel, alpha: Alpha) {
let alpha_clean = alpha & ffi::NCCHANNEL_ALPHA_MASK;
*channel = alpha_clean | (*channel & !ffi::NCCHANNEL_ALPHA_MASK);
if alpha != ffi::CELL_ALPHA_OPAQUE {
// indicate that we are *not* using the default background color
*channel |= ffi::CELL_BGDEFAULT_MASK;
}
0
}
/// Is this channel using the "default color" rather than RGB/palette-indexed?
@ -285,29 +273,24 @@ pub fn channels_set_bg(channels: &mut ChannelPair, rgb: Rgb) {
/// Set the 2-bit alpha component of the foreground channel.
// TODO: TEST
#[inline]
pub fn channels_set_fg_alpha(channels: &mut ChannelPair, alpha: Alpha) -> IntResult {
pub fn channels_set_fg_alpha(channels: &mut ChannelPair, alpha: Alpha) {
let mut channel = channels_fchannel(*channels);
if channel_set_alpha(&mut channel, alpha) < 0 {
return -1;
}
channel_set_alpha(&mut channel, alpha);
*channels = (channel as ChannelPair) << 32 | *channels & 0xffffffff_u64;
0
}
/// Set the 2-bit alpha component of the background channel.
// TODO: TEST
#[inline]
pub fn channels_set_bg_alpha(channels: &mut ChannelPair, alpha: Alpha) -> IntResult {
pub fn channels_set_bg_alpha(channels: &mut ChannelPair, alpha: Alpha) {
let mut alpha_clean = alpha;
if alpha == ffi::CELL_ALPHA_HIGHCONTRAST {
// forbidden for background alpha
return -1;
// forbidden for background alpha, so makes it opaque
alpha_clean = ffi::CELL_ALPHA_OPAQUE;
}
let mut channel = channels_bchannel(*channels);
if channel_set_alpha(&mut channel, alpha) < 0 {
return -1;
}
channel_set_alpha(&mut channel, alpha_clean);
channels_set_bchannel(channels, channel);
0
}
/// Is the foreground using the "default foreground color"?
@ -490,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