From 9c08411e279a9d9fa1d54ec131e371b77e6cf24e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?joseLu=C3=ADs?= Date: Tue, 18 Aug 2020 18:28:17 +0200 Subject: [PATCH] rust: rustfmt --- rust/src/cells.rs | 29 ++++++++++------- rust/src/lib.rs | 1 - rust/src/nc.rs | 5 ++- rust/src/palette.rs | 2 +- rust/src/plane.rs | 79 ++++++++++++++++++++++++++++++--------------- rust/src/types.rs | 4 --- 6 files changed, 76 insertions(+), 44 deletions(-) diff --git a/rust/src/cells.rs b/rust/src/cells.rs index 54c74b98a..ea027950b 100644 --- a/rust/src/cells.rs +++ b/rust/src/cells.rs @@ -55,10 +55,10 @@ //+cell_wide_left_p //+cell_wide_right_p -use cstr_core::CString; - use crate as ffi; -use ffi::types::{AlphaBits, Channel, ChannelPair, Color, GraphemeCluster, IntResult, PaletteIndex, StyleMask}; +use ffi::types::{ + AlphaBits, Channel, ChannelPair, Color, GraphemeCluster, PaletteIndex, StyleMask, +}; use ffi::{cell, ncplane}; /* @@ -139,7 +139,6 @@ pub fn cells_load_box( return -1; */ - // TODO: TEST #[inline] pub fn cell_init(cell: &mut cell) { @@ -232,15 +231,18 @@ pub fn cell_wide_left_p(cell: &cell) -> bool { // TODO: TEST #[inline] pub fn cell_strdup(plane: &ncplane, cell: &cell) -> *mut i8 { - unsafe{ - libc::strdup(ffi::cell_extended_gcluster(plane, cell)) - } + unsafe { libc::strdup(ffi::cell_extended_gcluster(plane, cell)) } } /// Extract the three elements of a cell. // TODO: TEST #[inline] -pub fn cell_extract(plane: &ncplane, cell: &cell, stylemask: &mut StyleMask, channels: &mut ChannelPair) -> *mut i8 { +pub fn cell_extract( + plane: &ncplane, + cell: &cell, + stylemask: &mut StyleMask, + channels: &mut ChannelPair, +) -> *mut i8 { if *stylemask != 0 { *stylemask = cell.stylemask; } @@ -264,7 +266,10 @@ pub fn cellcmp(plane1: &ncplane, cell1: &cell, plane2: &ncplane, cell2: &cell) - return true; } unsafe { - libc::strcmp(ffi::cell_extended_gcluster(plane1, cell1), ffi::cell_extended_gcluster(plane2, cell2)) != 0 + libc::strcmp( + ffi::cell_extended_gcluster(plane1, cell1), + ffi::cell_extended_gcluster(plane2, cell2), + ) != 0 } } @@ -272,7 +277,9 @@ pub fn cellcmp(plane1: &ncplane, cell1: &cell, plane2: &ncplane, cell2: &cell) - // NOTE: remove casting when fixed: https://github.com/rust-lang/rust-bindgen/issues/1875 #[inline] pub fn cell_load_simple(plane: &mut ncplane, cell: &mut cell, ch: char) -> i32 { - unsafe { ffi::cell_release(plane, cell); } + unsafe { + ffi::cell_release(plane, cell); + } cell.channels &= !(ffi::CELL_WIDEASIAN_MASK as u64 | ffi::CELL_NOBACKGROUND_MASK); cell.gcluster = ch as GraphemeCluster; 1 @@ -407,7 +414,7 @@ pub fn cell_set_bg(cell: &mut cell, channel: Channel) { // NOTE: this function now can't fail #[inline] pub fn cell_set_bg_palindex(cell: &mut cell, index: PaletteIndex) { - cell.channels |= ffi::CELL_BGDEFAULT_MASK as u64 ; + cell.channels |= ffi::CELL_BGDEFAULT_MASK as u64; cell.channels |= ffi::CELL_BG_PALETTE as u64; cell_set_bg_alpha(cell, ffi::CELL_ALPHA_OPAQUE); cell.channels &= 0xffffffffff000000; diff --git a/rust/src/lib.rs b/rust/src/lib.rs index c2dc2f6f1..c9bbef67d 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -2,7 +2,6 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![no_std] - #![allow(clippy::too_many_arguments)] // see https://github.com/rust-lang/rust-bindgen/issues/1470 diff --git a/rust/src/nc.rs b/rust/src/nc.rs index 03db61b3d..fdfd693de 100644 --- a/rust/src/nc.rs +++ b/rust/src/nc.rs @@ -59,7 +59,10 @@ pub fn notcurses_getc_nblock(nc: &mut notcurses, input: &mut ncinput) -> ffi::ch unsafe { let mut sigmask = ffi::sigset_t { __val: [0; 16] }; ffi::sigfillset(&mut sigmask); - let ts = ffi::timespec {tv_sec: 0, tv_nsec: 0}; + let ts = ffi::timespec { + tv_sec: 0, + tv_nsec: 0, + }; ffi::notcurses_getc(nc, &ts, &mut sigmask, input) } } diff --git a/rust/src/palette.rs b/rust/src/palette.rs index a5d7e97b6..bc22990b6 100644 --- a/rust/src/palette.rs +++ b/rust/src/palette.rs @@ -10,7 +10,7 @@ // // static inline functions to reimplement: 3 // ----------------------------------------- (done / (x) wont / remaining) -// (+) implement : 1 / 0 / 2 +// (+) implement : 3 / 0 / 0 // (#) unit tests: 0 / 0 / 3 // ----------------------------------------- //+palette256_get_rgb diff --git a/rust/src/plane.rs b/rust/src/plane.rs index b5d0eae66..cb8a3684f 100644 --- a/rust/src/plane.rs +++ b/rust/src/plane.rs @@ -139,7 +139,7 @@ use cstr_core::CString; use crate as ffi; use ffi::types::{AlphaBits, Channel, Color, IntResult}; -use ffi::{cell, ncplane, ncalign_e}; +use ffi::{cell, ncalign_e, ncplane}; /// Return the column at which 'cols' columns ought start in order to be aligned /// according to 'align' within ncplane 'n'. Returns INT_MAX on invalid 'align'. @@ -148,10 +148,14 @@ use ffi::{cell, ncplane, ncalign_e}; // TODO: TEST #[inline] pub fn ncplane_align(plane: &ncplane, align: ncalign_e, cols: i32) -> i32 { - if align == ffi::ncalign_e_NCALIGN_LEFT { return 0; } + if align == ffi::ncalign_e_NCALIGN_LEFT { + return 0; + } let plane_cols = ncplane_dim_x(plane); - if cols > plane_cols { return 0; } + if cols > plane_cols { + return 0; + } if align == ffi::ncalign_e_NCALIGN_CENTER { return plane_cols - cols / 2; @@ -215,11 +219,33 @@ pub fn ncplane_align(plane: &ncplane, align: ncalign_e, cols: i32) -> i32 { /// minimum box size is 2x2, and it cannot be drawn off-screen. // TODO: TEST #[inline] -pub fn ncplane_box_sized(plane: &mut ncplane, ul: &cell, ur: &cell, ll: &cell, lr: &cell, hline: &cell, vline: &cell, ylen: i32, xlen: i32, ctrlword: u32) -> IntResult { +pub fn ncplane_box_sized( + plane: &mut ncplane, + ul: &cell, + ur: &cell, + ll: &cell, + lr: &cell, + hline: &cell, + vline: &cell, + ylen: i32, + xlen: i32, + ctrlword: u32, +) -> IntResult { unsafe { - let (mut y, mut x) = (0,0); + let (mut y, mut x) = (0, 0); ffi::ncplane_cursor_yx(plane, &mut y, &mut x); - ffi::ncplane_box(plane, ul, ur, ll, lr, hline, vline, y + ylen -1, x + xlen -1, ctrlword) + ffi::ncplane_box( + plane, + ul, + ur, + ll, + lr, + hline, + vline, + y + ylen - 1, + x + xlen - 1, + ctrlword, + ) } } @@ -250,18 +276,25 @@ pub fn ncplane_dim_y(plane: &ncplane) -> i32 { // TODO: TEST #[inline] pub fn ncplane_hline(plane: &mut ncplane, cell: &cell, len: i32) -> i32 { - unsafe { - ffi::ncplane_hline_interp(plane, cell, len, cell.channels, cell.channels) - } + unsafe { ffi::ncplane_hline_interp(plane, cell, len, cell.channels, cell.channels) } } /// // TODO: TEST #[inline] -pub fn ncplane_perimeter(plane: &mut ncplane, ul: &cell, ur: &cell, ll: &cell, lr: &cell, hline: &cell, vline: &cell, ctlword: u32) -> IntResult { +pub fn ncplane_perimeter( + plane: &mut ncplane, + ul: &cell, + ur: &cell, + ll: &cell, + lr: &cell, + hline: &cell, + vline: &cell, + ctlword: u32, +) -> IntResult { unsafe { ffi::ncplane_cursor_move_yx(plane, 0, 0); - let (mut dimy, mut dimx) = (0,0); + let (mut dimy, mut dimx) = (0, 0); ffi::ncplane_dim_yx(plane, &mut dimy, &mut dimx); ncplane_box_sized(plane, ul, ur, ll, lr, hline, vline, dimy, dimx, ctlword) } @@ -291,7 +324,6 @@ pub fn ncplane_perimeter(plane: &mut ncplane, ul: &cell, ur: &cell, ll: &cell, l // return r; // } - // static inline int // ncplane_perimeter_rounded(struct ncplane* n, uint32_t attrword, // uint64_t channels, unsigned ctlword){ @@ -316,7 +348,6 @@ pub fn ncplane_perimeter(plane: &mut ncplane, ul: &cell, ur: &cell, ll: &cell, l // return r; // } - // // Call ncplane_putc_yx() for the current cursor location. // static inline int // ncplane_putc(struct ncplane* n, const cell* c){ @@ -519,9 +550,7 @@ pub fn ncplane_putstr(plane: &mut ncplane, _str: &str) -> i32 { // TODO: TEST #[inline] pub fn ncplane_vline(plane: &mut ncplane, cell: &cell, len: i32) -> i32 { - unsafe { - ffi::ncplane_vline_interp(plane, cell, len, cell.channels, cell.channels) - } + unsafe { ffi::ncplane_vline_interp(plane, cell, len, cell.channels, cell.channels) } } // static inline int @@ -529,7 +558,6 @@ pub fn ncplane_vline(plane: &mut ncplane, cell: &cell, len: i32) -> i32 { // return ncplane_vprintf_yx(n, -1, -1, format, ap); // } - // // Draw a gradient with its upper-left corner at the current cursor position, // // having dimensions 'ylen'x'xlen'. See ncplane_gradient for more information. // static inline int @@ -564,57 +592,56 @@ pub fn ncplane_vline(plane: &mut ncplane, cell: &cell, len: i32) -> i32 { // TODO: TEST #[inline] pub fn ncplane_fchannel(plane: &ncplane) -> Channel { - ffi::channels_fchannel(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_fchannel(unsafe { ffi::ncplane_channels(plane) }) } /// Extract the 32-bit working background channel from an ncplane. // TODO: TEST #[inline] pub fn ncplane_bchannel(plane: &ncplane) -> Channel { - ffi::channels_bchannel(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_bchannel(unsafe { ffi::ncplane_channels(plane) }) } /// Extract 24 bits of working foreground RGB from an ncplane, shifted to LSBs. // TODO: TEST #[inline] pub fn ncplane_fg(plane: &ncplane) -> Channel { - ffi::channels_fg(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_fg(unsafe { ffi::ncplane_channels(plane) }) } - /// Extract 24 bits of working background RGB from an ncplane, shifted to LSBs. // TODO: TEST #[inline] pub fn ncplane_bg(plane: &ncplane) -> Channel { - ffi::channels_bg(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_bg(unsafe { ffi::ncplane_channels(plane) }) } /// Extract 2 bits of foreground alpha from 'struct ncplane', shifted to LSBs. // TODO: TEST #[inline] pub fn ncplane_fg_alpha(plane: &ncplane) -> AlphaBits { - ffi::channels_fg_alpha(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_fg_alpha(unsafe { ffi::ncplane_channels(plane) }) } /// Extract 2 bits of background alpha from 'struct ncplane', shifted to LSBs. // TODO: TEST #[inline] pub fn ncplane_bg_alpha(plane: &ncplane) -> AlphaBits { - ffi::channels_bg_alpha(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_bg_alpha(unsafe { ffi::ncplane_channels(plane) }) } /// Is the plane's foreground using the "default foreground color"? // TODO: TEST #[inline] pub fn ncplane_fg_default_p(plane: &ncplane) -> bool { - ffi::channels_fg_default_p(unsafe { ffi::ncplane_channels(plane)}) + 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: &ncplane) -> bool { - ffi::channels_bg_default_p(unsafe { ffi::ncplane_channels(plane)}) + ffi::channels_bg_default_p(unsafe { ffi::ncplane_channels(plane) }) } /// Extract 24 bits of foreground RGB from a plane, split into components. diff --git a/rust/src/types.rs b/rust/src/types.rs index a97b39392..320101526 100644 --- a/rust/src/types.rs +++ b/rust/src/types.rs @@ -1,7 +1,6 @@ //! The notcurses types are defined and/or explained here //! - /// RGB: 24 bits broken into 3x 8bpp channels. /// /// -------- RRRRRRRR GGGGGGGG BBBBBBBB @@ -10,7 +9,6 @@ /// pub type Rgb = u32; - /// 8 bpp channel /// /// CCCCCCCC (1 Byte) @@ -185,7 +183,6 @@ pub type GraphemeClusterBackStop = u8; /// pub type StyleMask = u16; - // Plane: fundamental drawing surface. unites a: // // - CellMatrix @@ -197,7 +194,6 @@ pub type StyleMask = u16; // // type in C: egcpool (struct) - // CellMatrix: rectilinear array of Cells // one -- fb per plane, and transients show up ?