@akiojin/gwt 9.0.4 → 9.2.0

package/vendor/ratatui-core/src/layout/margin.rs

@@ -1,79 +0,0 @@
-use core::fmt;
-
-/// Represents spacing around rectangular areas.
-///
-/// `Margin` defines the horizontal and vertical spacing that should be applied around a rectangular
-/// area. It's commonly used with [`Layout`](crate::layout::Layout) to add space between the
-/// layout's boundaries and its contents, or with [`Rect::inner`](crate::layout::Rect::inner) and
-/// [`Rect::outer`](crate::layout::Rect::outer) to create padded areas.
-///
-/// The margin values represent the number of character cells to add on each side. For horizontal
-/// margin, the space is applied to both the left and right sides. For vertical margin, the space
-/// is applied to both the top and bottom sides.
-///
-/// # Construction
-///
-/// - [`new`](Self::new) - Create a new margin with horizontal and vertical spacing
-/// - [`default`](Default::default) - Create with zero margin
-///
-/// # Examples
-///
-/// ```rust
-/// use ratatui_core::layout::{Constraint, Layout, Margin, Rect};
-///
-/// // Create a margin of 2 cells horizontally and 1 cell vertically
-/// let margin = Margin::new(2, 1);
-///
-/// // Apply directly to a rectangle
-/// let area = Rect::new(0, 0, 80, 24);
-/// let inner_area = area.inner(margin);
-///
-/// // Or use with a layout (which only accepts uniform margins)
-/// let layout = Layout::vertical([Constraint::Fill(1)]).margin(2);
-/// ```
-///
-/// For comprehensive layout documentation and examples, see the [`layout`](crate::layout) module.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Margin {
-    pub horizontal: u16,
-    pub vertical: u16,
-}
-
-impl Margin {
-    pub const fn new(horizontal: u16, vertical: u16) -> Self {
-        Self {
-            horizontal,
-            vertical,
-        }
-    }
-}
-
-impl fmt::Display for Margin {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}x{}", self.horizontal, self.vertical)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use alloc::string::ToString;
-
-    use super::*;
-
-    #[test]
-    fn margin_to_string() {
-        assert_eq!(Margin::new(1, 2).to_string(), "1x2");
-    }
-
-    #[test]
-    fn margin_new() {
-        assert_eq!(
-            Margin::new(1, 2),
-            Margin {
-                horizontal: 1,
-                vertical: 2
-            }
-        );
-    }
-}

package/vendor/ratatui-core/src/layout/offset.rs

@@ -1,66 +0,0 @@
-use crate::layout::Position;
-
-/// Amounts by which to move a [`Rect`](crate::layout::Rect).
-///
-/// Positive numbers move to the right/bottom and negative to the left/top.
-///
-/// See [`Rect::offset`](crate::layout::Rect::offset) for usage.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Offset {
-    /// How much to move on the X axis
-    pub x: i32,
-
-    /// How much to move on the Y axis
-    pub y: i32,
-}
-
-impl Offset {
-    /// A zero offset
-    pub const ZERO: Self = Self::new(0, 0);
-
-    /// The minimum offset
-    pub const MIN: Self = Self::new(i32::MIN, i32::MIN);
-
-    /// The maximum offset
-    pub const MAX: Self = Self::new(i32::MAX, i32::MAX);
-
-    /// Creates a new `Offset` with the given values.
-    pub const fn new(x: i32, y: i32) -> Self {
-        Self { x, y }
-    }
-}
-
-impl From<Position> for Offset {
-    fn from(position: Position) -> Self {
-        Self {
-            x: i32::from(position.x),
-            y: i32::from(position.y),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn new_sets_components() {
-        assert_eq!(Offset::new(-3, 7), Offset { x: -3, y: 7 });
-    }
-
-    #[test]
-    fn constants_match_expected_values() {
-        assert_eq!(Offset::ZERO, Offset::new(0, 0));
-        assert_eq!(Offset::MIN, Offset::new(i32::MIN, i32::MIN));
-        assert_eq!(Offset::MAX, Offset::new(i32::MAX, i32::MAX));
-    }
-
-    #[test]
-    fn from_position_converts_coordinates() {
-        let position = Position::new(4, 9);
-        let offset = Offset::from(position);
-
-        assert_eq!(offset, Offset::new(4, 9));
-    }
-}

package/vendor/ratatui-core/src/layout/position.rs

@@ -1,253 +0,0 @@
-#![warn(missing_docs)]
-use core::fmt;
-use core::ops::{Add, AddAssign, Sub, SubAssign};
-
-use crate::layout::{Offset, Rect};
-
-/// Position in the terminal coordinate system.
-///
-/// The position is relative to the top left corner of the terminal window, with the top left corner
-/// being (0, 0). The x axis is horizontal increasing to the right, and the y axis is vertical
-/// increasing downwards.
-///
-/// `Position` is used throughout the layout system to represent specific points in the terminal.
-/// It can be created from coordinates, tuples, or extracted from rectangular areas.
-///
-/// # Construction
-///
-/// - [`new`](Self::new) - Create a new position from x and y coordinates
-/// - [`default`](Default::default) - Create at origin (0, 0)
-///
-/// # Conversion
-///
-/// - [`from((u16, u16))`](Self::from) - Create from `(u16, u16)` tuple
-/// - [`from(Rect)`](Self::from) - Create from [`Rect`] (uses top-left corner)
-/// - [`into((u16, u16))`] - Convert to `(u16, u16)` tuple
-///
-/// # Movement
-///
-/// - [`offset`](Self::offset) - Move by an [`Offset`]
-/// - [`Add<Offset>`](core::ops::Add) and [`Sub<Offset>`](core::ops::Sub) - Shift by offsets with
-///   clamping
-/// - [`AddAssign<Offset>`](core::ops::AddAssign) and [`SubAssign<Offset>`](core::ops::SubAssign) -
-///   In-place shifting
-///
-/// # Examples
-///
-/// ```
-/// use ratatui_core::layout::{Offset, Position, Rect};
-///
-/// // the following are all equivalent
-/// let position = Position { x: 1, y: 2 };
-/// let position = Position::new(1, 2);
-/// let position = Position::from((1, 2));
-/// let position = Position::from(Rect::new(1, 2, 3, 4));
-///
-/// // position can be converted back into the components when needed
-/// let (x, y) = position.into();
-///
-/// // movement by offsets
-/// let position = Position::new(5, 5) + Offset::new(2, -3);
-/// assert_eq!(position, Position::new(7, 2));
-/// ```
-///
-/// For comprehensive layout documentation and examples, see the [`layout`](crate::layout) module.
-#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Position {
-    /// The x coordinate of the position
-    ///
-    /// The x coordinate is relative to the left edge of the terminal window, with the left edge
-    /// being 0.
-    pub x: u16,
-
-    /// The y coordinate of the position
-    ///
-    /// The y coordinate is relative to the top edge of the terminal window, with the top edge
-    /// being 0.
-    pub y: u16,
-}
-
-impl Position {
-    /// Position at the origin, the top left edge at 0,0
-    pub const ORIGIN: Self = Self::new(0, 0);
-
-    /// Position at the minimum x and y values
-    pub const MIN: Self = Self::ORIGIN;
-
-    /// Position at the maximum x and y values
-    pub const MAX: Self = Self::new(u16::MAX, u16::MAX);
-
-    /// Create a new position
-    pub const fn new(x: u16, y: u16) -> Self {
-        Self { x, y }
-    }
-
-    /// Moves the position by the given offset.
-    ///
-    /// Positive offsets move right and down, negative offsets move left and up. Values that would
-    /// move the position outside the `u16` range are clamped to the nearest edge.
-    #[must_use = "method returns the modified value"]
-    pub fn offset(self, offset: Offset) -> Self {
-        self + offset
-    }
-}
-
-impl From<(u16, u16)> for Position {
-    fn from((x, y): (u16, u16)) -> Self {
-        Self { x, y }
-    }
-}
-
-impl From<Position> for (u16, u16) {
-    fn from(position: Position) -> Self {
-        (position.x, position.y)
-    }
-}
-
-impl From<Rect> for Position {
-    fn from(rect: Rect) -> Self {
-        rect.as_position()
-    }
-}
-
-impl fmt::Display for Position {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({}, {})", self.x, self.y)
-    }
-}
-
-impl Add<Offset> for Position {
-    type Output = Self;
-
-    /// Moves the position by the given offset.
-    ///
-    /// Values that would move the position outside the `u16` range are clamped to the nearest
-    /// edge.
-    fn add(self, offset: Offset) -> Self {
-        let max = i32::from(u16::MAX);
-        let x = i32::from(self.x).saturating_add(offset.x).clamp(0, max) as u16;
-        let y = i32::from(self.y).saturating_add(offset.y).clamp(0, max) as u16;
-        Self { x, y }
-    }
-}
-
-impl Add<Position> for Offset {
-    type Output = Position;
-
-    /// Moves the position by the given offset.
-    ///
-    /// Values that would move the position outside the `u16` range are clamped to the nearest
-    /// edge.
-    fn add(self, position: Position) -> Position {
-        position + self
-    }
-}
-
-impl Sub<Offset> for Position {
-    type Output = Self;
-
-    /// Moves the position by the inverse of the given offset.
-    ///
-    /// Values that would move the position outside the `u16` range are clamped to the nearest
-    /// edge.
-    fn sub(self, offset: Offset) -> Self {
-        let max = i32::from(u16::MAX);
-        let x = i32::from(self.x).saturating_sub(offset.x).clamp(0, max) as u16;
-        let y = i32::from(self.y).saturating_sub(offset.y).clamp(0, max) as u16;
-        Self { x, y }
-    }
-}
-
-impl AddAssign<Offset> for Position {
-    /// Moves the position in place by the given offset.
-    ///
-    /// Values that would move the position outside the `u16` range are clamped to the nearest
-    /// edge.
-    fn add_assign(&mut self, offset: Offset) {
-        *self = *self + offset;
-    }
-}
-
-impl SubAssign<Offset> for Position {
-    /// Moves the position in place by the inverse of the given offset.
-    ///
-    /// Values that would move the position outside the `u16` range are clamped to the nearest
-    /// edge.
-    fn sub_assign(&mut self, offset: Offset) {
-        *self = *self - offset;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use alloc::string::ToString;
-
-    use super::*;
-
-    #[test]
-    fn new() {
-        let position = Position::new(1, 2);
-
-        assert_eq!(position, Position { x: 1, y: 2 });
-    }
-
-    #[test]
-    fn from_tuple() {
-        let position = Position::from((1, 2));
-
-        assert_eq!(position, Position { x: 1, y: 2 });
-    }
-
-    #[test]
-    fn into_tuple() {
-        let position = Position::new(1, 2);
-        let (x, y) = position.into();
-        assert_eq!(x, 1);
-        assert_eq!(y, 2);
-    }
-
-    #[test]
-    fn from_rect() {
-        let rect = Rect::new(1, 2, 3, 4);
-        let position = Position::from(rect);
-
-        assert_eq!(position, Position { x: 1, y: 2 });
-    }
-
-    #[test]
-    fn to_string() {
-        let position = Position::new(1, 2);
-        assert_eq!(position.to_string(), "(1, 2)");
-    }
-
-    #[test]
-    fn offset_moves_position() {
-        let position = Position::new(2, 3).offset(Offset::new(5, 7));
-
-        assert_eq!(position, Position::new(7, 10));
-    }
-
-    #[test]
-    fn offset_clamps_to_bounds() {
-        let position = Position::new(1, 1).offset(Offset::MAX);
-
-        assert_eq!(position, Position::MAX);
-    }
-
-    #[test]
-    fn add_and_subtract_offset() {
-        let position = Position::new(10, 10) + Offset::new(-3, 4) - Offset::new(5, 20);
-
-        assert_eq!(position, Position::new(2, 0));
-    }
-
-    #[test]
-    fn add_assign_and_sub_assign_offset() {
-        let mut position = Position::new(5, 5);
-        position += Offset::new(2, 3);
-        position -= Offset::new(10, 1);
-
-        assert_eq!(position, Position::new(0, 7));
-    }
-}