From c07e8b6aee3e8637f444d8ccd11dd1abffa3e6f0 Mon Sep 17 00:00:00 2001 From: Alexandre Bury Date: Sun, 10 Jul 2016 19:11:21 -0700 Subject: [PATCH] Rustfmt --- src/align.rs | 16 +++++++++---- src/backend/curses.rs | 50 +++++++++++++++++++-------------------- src/event.rs | 1 - src/lib.rs | 2 +- src/orientation.rs | 6 +++-- src/theme.rs | 6 +++-- src/utf8.rs | 5 +++- src/view/linear_layout.rs | 9 ++++--- src/view/scroll.rs | 11 ++++++--- src/view/view_wrapper.rs | 7 +++--- 10 files changed, 66 insertions(+), 47 deletions(-) diff --git a/src/align.rs b/src/align.rs index b30672d..8d80bd9 100644 --- a/src/align.rs +++ b/src/align.rs @@ -7,7 +7,7 @@ pub struct Align { } impl Align { - /// Creates a new Align object from the given horizontal and vertical alignments. + /// Creates a new Align object from the given alignments. pub fn new(h: HAlign, v: VAlign) -> Self { Align { h: h, v: v } } @@ -53,8 +53,11 @@ pub enum VAlign { } impl HAlign { - /// To draw a view with size `content` in a printer with size `container`, this returns the - /// offset to start printing the view at. + /// Returns the offset required to position a view. + /// + /// When drawing a view with size `content` when the available size is + /// `container`, printing at the resulting offset will align the view as + /// desired. pub fn get_offset(&self, content: usize, container: usize) -> usize { match *self { HAlign::Left => 0, @@ -65,8 +68,11 @@ impl HAlign { } impl VAlign { - /// To draw a view with size `content` in a printer with size `container`, this returns the - /// offset to start printing the view at. + /// Returns the offset required to position a view. + /// + /// When drawing a view with size `content` when the available size is + /// `container`, printing at the resulting offset will align the view as + /// desired. pub fn get_offset(&self, content: usize, container: usize) -> usize { match *self { VAlign::Top => 0, diff --git a/src/backend/curses.rs b/src/backend/curses.rs index d79974f..45babec 100644 --- a/src/backend/curses.rs +++ b/src/backend/curses.rs @@ -1,6 +1,6 @@ use backend; use event::{Event, Key}; -use theme; +use theme::{Color, ColorStyle, Effect}; use utf8; use ncurses; @@ -18,7 +18,7 @@ impl backend::Backend for NcursesBackend { ncurses::start_color(); ncurses::curs_set(ncurses::CURSOR_VISIBILITY::CURSOR_INVISIBLE); ncurses::wbkgd(ncurses::stdscr, - ncurses::COLOR_PAIR(theme::ColorStyle::Background.id())); + ncurses::COLOR_PAIR(ColorStyle::Background.id())); } fn screen_size() -> (usize, usize) { @@ -37,8 +37,8 @@ impl backend::Backend for NcursesBackend { } - fn init_color_style(style: theme::ColorStyle, foreground: &theme::Color, - background: &theme::Color) { + fn init_color_style(style: ColorStyle, foreground: &Color, + background: &Color) { // TODO: build the color on the spot ncurses::init_pair(style.id(), @@ -46,7 +46,7 @@ impl backend::Backend for NcursesBackend { find_closest(background) as i16); } - fn with_color(color: theme::ColorStyle, f: F) { + fn with_color(color: ColorStyle, f: F) { let mut current_style: ncurses::attr_t = 0; let mut current_color: i16 = 0; ncurses::attr_get(&mut current_style, &mut current_color); @@ -58,10 +58,10 @@ impl backend::Backend for NcursesBackend { ncurses::attron(current_style); } - fn with_effect(effect: theme::Effect, f: F) { + fn with_effect(effect: Effect, f: F) { let style = match effect { - theme::Effect::Reverse => ncurses::A_REVERSE(), - theme::Effect::Simple => ncurses::A_NORMAL(), + Effect::Reverse => ncurses::A_REVERSE(), + Effect::Simple => ncurses::A_NORMAL(), }; ncurses::attron(style); f(); @@ -84,9 +84,8 @@ impl backend::Backend for NcursesBackend { let ch: i32 = ncurses::getch(); // Is it a UTF-8 starting point? - if 32 <= ch && ch < 0x100 && ch != 127 { - Event::Char(utf8::read_char(ch as u8, - || ncurses::getch() as u8) + if 32 <= ch && ch <= 255 && ch != 127 { + Event::Char(utf8::read_char(ch as u8, || ncurses::getch() as u8) .unwrap()) } else { parse_ncurses_char(ch) @@ -214,30 +213,29 @@ fn parse_ncurses_char(ch: i32) -> Event { f @ 289...300 => Event::Ctrl(Key::from_f((f - 288) as u8)), f @ 301...312 => Event::CtrlShift(Key::from_f((f - 300) as u8)), f @ 313...324 => Event::Alt(Key::from_f((f - 312) as u8)), - // Values 8-10 (H,I,J) are used by other commands, so we won't receive them. - c @ 1...25 => { - Event::CtrlChar((b'a' + (c - 1) as u8) as char) - } + // Values 8-10 (H,I,J) are used by other commands, + // so we probably won't receive them. Meh~ + c @ 1...25 => Event::CtrlChar((b'a' + (c - 1) as u8) as char), _ => Event::Unknown(ch), } } -fn find_closest(color: &theme::Color) -> u8 { +fn find_closest(color: &Color) -> u8 { match *color { - theme::Color::Black => 0, - theme::Color::Red => 1, - theme::Color::Green => 2, - theme::Color::Yellow => 3, - theme::Color::Blue => 4, - theme::Color::Magenta => 5, - theme::Color::Cyan => 6, - theme::Color::White => 7, - theme::Color::Rgb(r, g, b) => { + Color::Black => 0, + Color::Red => 1, + Color::Green => 2, + Color::Yellow => 3, + Color::Blue => 4, + Color::Magenta => 5, + Color::Cyan => 6, + Color::White => 7, + Color::Rgb(r, g, b) => { let r = 6 * r as u16 / 256; let g = 6 * g as u16 / 256; let b = 6 * b as u16 / 256; (16 + 36 * r + 6 * g + b) as u8 } - theme::Color::RgbLowRes(r, g, b) => (16 + 36 * r + 6 * g + b) as u8, + Color::RgbLowRes(r, g, b) => (16 + 36 * r + 6 * g + b) as u8, } } diff --git a/src/event.rs b/src/event.rs index 468d8e8..e7ed369 100644 --- a/src/event.rs +++ b/src/event.rs @@ -141,7 +141,6 @@ pub enum Event { /// A non-character key was pressed with the Ctrl and Alt keys pressed CtrlAlt(Key), - /// An unknown event was received. Unknown(i32), } diff --git a/src/lib.rs b/src/lib.rs index c5dc13e..fa11cfc 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,7 +20,7 @@ //! siv.run(); //! } //! ``` -// #![deny(missing_docs)] +//! #![deny(missing_docs)] extern crate ncurses; extern crate toml; diff --git a/src/orientation.rs b/src/orientation.rs index b0fb06b..8b26282 100644 --- a/src/orientation.rs +++ b/src/orientation.rs @@ -11,8 +11,10 @@ pub enum Orientation { } impl Orientation { - /// Returns the component of the given vector corresponding to this orientation. - /// (Horizontal will return the x value, and Vertical will return the y value.) + /// Returns the component of `v` corresponding to this orientation. + /// + /// (`Horizontal` will return the x value, + /// and `Vertical` will return the y value.) pub fn get(&self, v: &Vec2) -> usize { match *self { Orientation::Horizontal => v.x, diff --git a/src/theme.rs b/src/theme.rs index 5febce3..ca96e36 100644 --- a/src/theme.rs +++ b/src/theme.rs @@ -314,9 +314,11 @@ impl Color { } -/// Loads a theme file, and returns its representation if everything worked well. +/// Loads a theme file, and returns its representation. /// -/// The file should be a toml file. All fields are optional. Here is are the possible entries: +/// The file should be a toml file. All fields are optional. +/// +/// Here are the possible entries: /// /// ```text /// # Every field in a theme file is optional. diff --git a/src/utf8.rs b/src/utf8.rs index 2f05c00..8141281 100644 --- a/src/utf8.rs +++ b/src/utf8.rs @@ -1,6 +1,9 @@ use std::char::from_u32; -/// Reads a char from a first byte, and a function to fetch next bytes as required. +/// Reads a potentially multi-bytes utf8 codepoint. +/// +/// Reads the given first byte, and uses the given +/// function to get more if needed. /// /// Returns an error if the stream is invalid utf-8. pub fn read_char(first: u8, next: F) -> Result diff --git a/src/view/linear_layout.rs b/src/view/linear_layout.rs index 8aede83..8a79015 100644 --- a/src/view/linear_layout.rs +++ b/src/view/linear_layout.rs @@ -117,7 +117,9 @@ impl View for LinearLayout { // Use pre-computed sizes let mut offset = Vec2::zero(); for (i, child) in self.children.iter_mut().enumerate() { - child.view.draw(&printer.sub_printer(offset, child.size, i == self.focus)); + let printer = + &printer.sub_printer(offset, child.size, i == self.focus); + child.view.draw(printer); // On the axis given by the orientation, // add the child size to the offset. @@ -151,7 +153,8 @@ impl View for LinearLayout { let min_size = self.orientation.stack(min_sizes.iter()); // Emulate 'non-strict inequality' on integers - // (default comparison on Vec2 is strict, and (0,1).cmp((1,1)) is undefined) + // (default comparison on Vec2 is strict, + // and (0,1).cmp((1,1)) is undefined) if !(min_size < size + (1, 1)) { // Error! Not enough space! Emergency procedures! return; @@ -208,7 +211,7 @@ impl View for LinearLayout { EventResult::Consumed(None) } Event::Shift(Key::Tab) if self.focus + 1 < - self.children.len() => { + self.children.len() => { self.focus += 1; EventResult::Consumed(None) } diff --git a/src/view/scroll.rs b/src/view/scroll.rs index 689cb94..16111ae 100644 --- a/src/view/scroll.rs +++ b/src/view/scroll.rs @@ -75,13 +75,17 @@ impl ScrollBase { self.start_line = self.content_height - self.view_height; } - /// Scroll down by the given number of line, never going further than the bottom of the view. + /// Scroll down by the given number of line. + /// + /// Never further than the bottom of the view. pub fn scroll_down(&mut self, n: usize) { self.start_line = min(self.start_line + n, self.content_height - self.view_height); } - /// Scroll up by the given number of lines, never going above the top of the view. + /// Scroll up by the given number of lines. + /// + /// Never above the top of the view. pub fn scroll_up(&mut self, n: usize) { self.start_line -= min(self.start_line, n); } @@ -130,7 +134,8 @@ impl ScrollBase { // And draw the scrollbar if needed if self.view_height < self.content_height { - // We directly compute the size of the scrollbar (this allow use to avoid using floats). + // We directly compute the size of the scrollbar + // (that way we avoid using floats). // (ratio) * max_height // Where ratio is ({start or end} / content.height) let height = max(1, diff --git a/src/view/view_wrapper.rs b/src/view/view_wrapper.rs index 2d96e76..c3a74f4 100644 --- a/src/view/view_wrapper.rs +++ b/src/view/view_wrapper.rs @@ -10,9 +10,10 @@ use event::{Event, EventResult}; /// Default implementation forwards all calls to the child view. /// Overrides some methods as desired. pub trait ViewWrapper { - /// Get an immutable reference to the wrapped view, so that we can forward some calls to it. + /// Get an immutable reference to the wrapped view. fn get_view(&self) -> &View; - /// Get a mutable reference to the wrapped view, for the mutable methods. + + /// Get a mutable reference to the wrapped view. fn get_view_mut(&mut self) -> &mut View; /// Wraps the draw method. @@ -79,7 +80,7 @@ impl View for T { } } -/// Convenient macro to implement to two methods required for the ViewWrapper trait. +/// Convenient macro to implement the ViewWrapper trait. /// /// # Examples ///