@akiojin/gwt 9.0.4 → 9.2.0

package/vendor/ratatui-core/src/text.rs

@@ -1,64 +0,0 @@
-//! Primitives for styled text.
-//!
-//! A terminal UI is at its root a lot of strings. In order to make it accessible and stylish, those
-//! strings may be associated to a set of styles. `ratatui` has three ways to represent them:
-//! - A single line string where all graphemes have the same style is represented by a [`Span`].
-//! - A single line string where each grapheme may have its own style is represented by [`Line`].
-//! - A multiple line string where each grapheme may have its own style is represented by a
-//!   [`Text`].
-//!
-//! These types form a hierarchy: [`Line`] is a collection of [`Span`] and each line of [`Text`] is
-//! a [`Line`].
-//!
-//! Keep it mind that a lot of widgets will use those types to advertise what kind of string is
-//! supported for their properties. Moreover, `ratatui` provides convenient `From` implementations
-//! so that you can start by using simple `String` or `&str` and then promote them to the previous
-//! primitives when you need additional styling capabilities.
-//!
-//! For example, for the `Block` widget, all the following calls are valid to set its `title`
-//! property (which is a [`Line`] under the hood):
-//!
-//! ```rust,ignore
-//! use ratatui_core::{
-//!     style::{Color, Style},
-//!     text::{Line, Span},
-//!     widgets::Block,
-//! };
-//!
-//! // A simple string with no styling.
-//! // Converted to Line(vec![
-//! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
-//! // ])
-//! let block = Block::new().title("My title");
-//!
-//! // A simple string with a unique style.
-//! // Converted to Line(vec![
-//! //   Span { content: Cow::Borrowed("My title"), style: Style { fg: Some(Color::Yellow), .. }
-//! // ])
-//! let block = Block::new().title(Span::styled("My title", Style::default().fg(Color::Yellow)));
-//!
-//! // A string with multiple styles.
-//! // Converted to Line(vec![
-//! //   Span { content: Cow::Borrowed("My"), style: Style { fg: Some(Color::Yellow), .. } },
-//! //   Span { content: Cow::Borrowed(" title"), .. }
-//! // ])
-//! let block = Block::new().title(vec![
-//!     Span::styled("My", Style::default().fg(Color::Yellow)),
-//!     Span::raw(" title"),
-//! ]);
-//! ```
-
-mod grapheme;
-pub use grapheme::StyledGrapheme;
-
-mod line;
-pub use line::{Line, ToLine};
-
-mod masked;
-pub use masked::Masked;
-
-mod span;
-pub use span::{Span, ToSpan};
-
-mod text;
-pub use text::{Text, ToText};

package/vendor/ratatui-core/src/widgets/stateful_widget.rs

@@ -1,193 +0,0 @@
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-
-/// A `StatefulWidget` is a widget that can take advantage of some local state to remember things
-/// between two draw calls.
-///
-/// For a comprehensive guide to widgets, including trait explanations, implementation patterns,
-/// and available widgets, see the [`widgets`] module documentation.
-///
-/// [`widgets`]: ../../ratatui/widgets/index.html
-///
-/// Most widgets can be drawn directly based on the input parameters. However, some features may
-/// require some kind of associated state to be implemented.
-///
-/// For example, the `List` widget can highlight the item currently selected. This can be translated
-/// in an offset, which is the number of elements to skip in order to have the selected item within
-/// the viewport currently allocated to this widget. The widget can therefore only provide the
-/// following behavior: whenever the selected item is out of the viewport scroll to a predefined
-/// position (making the selected item the last viewable item or the one in the middle for example).
-/// Nonetheless, if the widget has access to the last computed offset then it can implement a
-/// natural scrolling experience where the last offset is reused until the selected item is out of
-/// the viewport.
-///
-/// ## Examples
-///
-/// ```rust,ignore
-/// use std::io;
-///
-/// use ratatui::{
-///     backend::TestBackend,
-///     widgets::{List, ListItem, ListState, StatefulWidget, Widget},
-///     Terminal,
-/// };
-///
-/// // Let's say we have some events to display.
-/// struct Events {
-///     // `items` is the state managed by your application.
-///     items: Vec<String>,
-///     // `state` is the state that can be modified by the UI. It stores the index of the selected
-///     // item as well as the offset computed during the previous draw call (used to implement
-///     // natural scrolling).
-///     state: ListState,
-/// }
-///
-/// impl Events {
-///     fn new(items: Vec<String>) -> Events {
-///         Events {
-///             items,
-///             state: ListState::default(),
-///         }
-///     }
-///
-///     pub fn set_items(&mut self, items: Vec<String>) {
-///         self.items = items;
-///         // We reset the state as the associated items have changed. This effectively reset
-///         // the selection as well as the stored offset.
-///         self.state = ListState::default();
-///     }
-///
-///     // Select the next item. This will not be reflected until the widget is drawn in the
-///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
-///     pub fn next(&mut self) {
-///         let i = match self.state.selected() {
-///             Some(i) => {
-///                 if i >= self.items.len() - 1 {
-///                     0
-///                 } else {
-///                     i + 1
-///                 }
-///             }
-///             None => 0,
-///         };
-///         self.state.select(Some(i));
-///     }
-///
-///     // Select the previous item. This will not be reflected until the widget is drawn in the
-///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
-///     pub fn previous(&mut self) {
-///         let i = match self.state.selected() {
-///             Some(i) => {
-///                 if i == 0 {
-///                     self.items.len() - 1
-///                 } else {
-///                     i - 1
-///                 }
-///             }
-///             None => 0,
-///         };
-///         self.state.select(Some(i));
-///     }
-///
-///     // Unselect the currently selected item if any. The implementation of `ListState` makes
-///     // sure that the stored offset is also reset.
-///     pub fn unselect(&mut self) {
-///         self.state.select(None);
-///     }
-/// }
-///
-/// # let backend = TestBackend::new(5, 5);
-/// # let mut terminal = Terminal::new(backend).unwrap();
-///
-/// let mut events = Events::new(vec![String::from("Item 1"), String::from("Item 2")]);
-///
-/// loop {
-///     terminal.draw(|f| {
-///         // The items managed by the application are transformed to something
-///         // that is understood by ratatui.
-///         let items: Vec<ListItem> = events
-///             .items
-///             .iter()
-///             .map(|i| ListItem::new(i.as_str()))
-///             .collect();
-///         // The `List` widget is then built with those items.
-///         let list = List::new(items);
-///         // Finally the widget is rendered using the associated state. `events.state` is
-///         // effectively the only thing that we will "remember" from this draw call.
-///         f.render_stateful_widget(list, f.size(), &mut events.state);
-///     });
-///
-///     // In response to some input events or an external http request or whatever:
-///     events.next();
-/// }
-/// ```
-pub trait StatefulWidget {
-    /// State associated with the stateful widget.
-    ///
-    /// If you don't need this then you probably want to implement [`Widget`] instead.
-    ///
-    /// [`Widget`]: super::Widget
-    type State: ?Sized;
-    /// Draws the current state of the widget in the given buffer. That is the only method required
-    /// to implement a custom stateful widget.
-    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
-}
-
-#[cfg(test)]
-mod tests {
-    use alloc::format;
-    use alloc::string::{String, ToString};
-
-    use rstest::{fixture, rstest};
-
-    use super::*;
-    use crate::buffer::Buffer;
-    use crate::layout::Rect;
-    use crate::text::Line;
-    use crate::widgets::Widget;
-
-    #[fixture]
-    fn buf() -> Buffer {
-        Buffer::empty(Rect::new(0, 0, 20, 1))
-    }
-
-    #[fixture]
-    fn state() -> String {
-        "world".to_string()
-    }
-
-    struct PersonalGreeting;
-
-    impl StatefulWidget for PersonalGreeting {
-        type State = String;
-        fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-            Line::from(format!("Hello {state}")).render(area, buf);
-        }
-    }
-
-    #[rstest]
-    fn render(mut buf: Buffer, mut state: String) {
-        let widget = PersonalGreeting;
-        widget.render(buf.area, &mut buf, &mut state);
-        assert_eq!(buf, Buffer::with_lines(["Hello world         "]));
-    }
-
-    struct Bytes;
-
-    /// A widget with an unsized state type.
-    impl StatefulWidget for Bytes {
-        type State = [u8];
-        fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-            let slice = core::str::from_utf8(state).unwrap();
-            Line::from(format!("Bytes: {slice}")).render(area, buf);
-        }
-    }
-
-    #[rstest]
-    fn render_unsized_state_type(mut buf: Buffer) {
-        let widget = Bytes;
-        let state = b"hello";
-        widget.render(buf.area, &mut buf, &mut state.clone());
-        assert_eq!(buf, Buffer::with_lines(["Bytes: hello        "]));
-    }
-}

package/vendor/ratatui-core/src/widgets/widget.rs

@@ -1,174 +0,0 @@
-use alloc::string::String;
-
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-
-/// A `Widget` is a type that can be drawn on a [`Buffer`] in a given [`Rect`].
-///
-/// For a comprehensive guide to widgets, including trait explanations, implementation patterns,
-/// and available widgets, see the [`widgets`] module documentation.
-///
-/// [`widgets`]: ../../ratatui/widgets/index.html
-///
-/// Prior to Ratatui 0.26.0, widgets generally were created for each frame as they were consumed
-/// during rendering. This meant that they were not meant to be stored but used as *commands* to
-/// draw common figures in the UI.
-///
-/// Starting with Ratatui 0.26.0, all the internal widgets implement Widget for a reference to
-/// themselves. This allows you to store a reference to a widget and render it later. Widget crates
-/// should consider also doing this to allow for more flexibility in how widgets are used.
-///
-/// In Ratatui 0.26.0, we also added an unstable `WidgetRef` trait and implemented this on all the
-/// internal widgets. In addition to the above benefit of rendering references to widgets, this also
-/// allows you to render boxed widgets. This is useful when you want to store a collection of
-/// widgets with different types. You can then iterate over the collection and render each widget.
-/// See <https://github.com/ratatui/ratatui/issues/1287> for more information.
-///
-/// In general where you expect a widget to immutably work on its data, we recommended to implement
-/// `Widget` for a reference to the widget (`impl Widget for &MyWidget`). If you need to store state
-/// between draw calls, implement `StatefulWidget` if you want the Widget to be immutable, or
-/// implement `Widget` for a mutable reference to the widget (`impl Widget for &mut MyWidget`) if
-/// you want the widget to be mutable. The mutable widget pattern is used infrequently in apps, but
-/// can be quite useful.
-///
-/// A blanket implementation of `Widget` for `&W` where `W` implements `WidgetRef` is provided.
-/// Widget is also implemented for `&str` and `String` types.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// use ratatui::{
-///     backend::TestBackend,
-///     widgets::{Clear, Widget},
-///     Terminal,
-/// };
-/// # let backend = TestBackend::new(5, 5);
-/// # let mut terminal = Terminal::new(backend).unwrap();
-///
-/// terminal.draw(|frame| {
-///     frame.render_widget(Clear, frame.area());
-/// });
-/// ```
-///
-/// It's common to render widgets inside other widgets:
-///
-/// ```rust
-/// use ratatui_core::buffer::Buffer;
-/// use ratatui_core::layout::Rect;
-/// use ratatui_core::text::Line;
-/// use ratatui_core::widgets::Widget;
-///
-/// struct MyWidget;
-///
-/// impl Widget for MyWidget {
-///     fn render(self, area: Rect, buf: &mut Buffer) {
-///         Line::raw("Hello").render(area, buf);
-///     }
-/// }
-/// ```
-pub trait Widget {
-    /// Draws the current state of the widget in the given buffer. That is the only method required
-    /// to implement a custom widget.
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized;
-}
-
-/// Renders a string slice as a widget.
-///
-/// This implementation allows a string slice (`&str`) to act as a widget, meaning it can be drawn
-/// onto a [`Buffer`] in a specified [`Rect`]. The slice represents a static string which can be
-/// rendered by reference, thereby avoiding the need for string cloning or ownership transfer when
-/// drawing the text to the screen.
-impl Widget for &str {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        buf.set_stringn(area.x, area.y, self, area.width as usize, Style::new());
-    }
-}
-
-/// Renders a `String` object as a widget.
-///
-/// This implementation enables an owned `String` to be treated as a widget, which can be rendered
-/// on a [`Buffer`] within the bounds of a given [`Rect`].
-impl Widget for String {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        buf.set_stringn(area.x, area.y, self, area.width as usize, Style::new());
-    }
-}
-
-impl<W: Widget> Widget for Option<W> {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        if let Some(widget) = self {
-            widget.render(area, buf);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::{fixture, rstest};
-
-    use super::*;
-    use crate::buffer::Buffer;
-    use crate::layout::Rect;
-    use crate::text::Line;
-
-    #[fixture]
-    fn buf() -> Buffer {
-        Buffer::empty(Rect::new(0, 0, 20, 1))
-    }
-
-    struct Greeting;
-
-    impl Widget for Greeting {
-        fn render(self, area: Rect, buf: &mut Buffer) {
-            Line::from("Hello").render(area, buf);
-        }
-    }
-
-    #[rstest]
-    fn render(mut buf: Buffer) {
-        let widget = Greeting;
-        widget.render(buf.area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["Hello               "]));
-    }
-
-    #[rstest]
-    fn render_str(mut buf: Buffer) {
-        "hello world".render(buf.area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-
-    #[rstest]
-    fn render_str_truncate(mut buf: Buffer) {
-        let area = Rect::new(buf.area.x, buf.area.y, 11, buf.area.height);
-        "hello world, just hello".render(area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-
-    #[rstest]
-    fn render_option_str(mut buf: Buffer) {
-        Some("hello world").render(buf.area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-
-    #[rstest]
-    fn render_string(mut buf: Buffer) {
-        String::from("hello world").render(buf.area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-
-    #[rstest]
-    fn render_string_truncate(mut buf: Buffer) {
-        let area = Rect::new(buf.area.x, buf.area.y, 11, buf.area.height);
-        String::from("hello world, just hello").render(area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-
-    #[rstest]
-    fn render_option_string(mut buf: Buffer) {
-        Some(String::from("hello world")).render(buf.area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
-    }
-}

package/vendor/ratatui-core/src/widgets.rs

@@ -1,9 +0,0 @@
-#![warn(missing_docs)]
-//! The `widgets` module contains the `Widget` and `StatefulWidget` traits, which are used to
-//! render UI elements on the screen.
-
-pub use self::stateful_widget::StatefulWidget;
-pub use self::widget::Widget;
-
-mod stateful_widget;
-mod widget;