Struct ScrollView 

pub struct ScrollView { /* private fields */ }

A widget that can scroll its contents

Allows you to render a widget into a buffer larger than the area it is rendered into, and then scroll the contents of that buffer around.

Note that the origin of the buffer is always at (0, 0), and the buffer is always the size of the size passed to new. The ScrollView widget itself is responsible for rendering the visible area of the buffer into the main buffer.

Examples

use ratatui::{prelude::*, layout::Size, widgets::*};
use tui_scrollview::{ScrollView, ScrollViewState};

let mut scroll_view = ScrollView::new(Size::new(20, 20));

// render a few widgets into the buffer at various positions
scroll_view.render_widget(Paragraph::new("Hello, world!"), Rect::new(0, 0, 20, 1));
scroll_view.render_widget(Paragraph::new("Hello, world!"), Rect::new(10, 10, 20, 1));
scroll_view.render_widget(Paragraph::new("Hello, world!"), Rect::new(15, 15, 20, 1));

// You can also render widgets into the buffer programmatically
Line::raw("Hello, world!").render(Rect::new(0, 0, 20, 1), scroll_view.buf_mut());

// usually you would store the state of the scroll view in a struct that implements
// StatefulWidget (or in your app state if you're using an `App` struct)
let mut state = ScrollViewState::default();

// you can also scroll the view programmatically
state.scroll_down();

// render the scroll view into the main buffer at the given position within a widget
let scroll_view_area = Rect::new(0, 0, 10, 10);
scroll_view.render(scroll_view_area, buf, &mut state);
// or if you're rendering in a terminal draw closure instead of from within another widget:
frame.render_stateful_widget(scroll_view, frame.size(), state);

Implementations

impl ScrollView

pub fn new(size: Size) -> Self

Create a new scroll view with a buffer of the given size

The buffer will be empty, with coordinates ranging from (0, 0) to (size.width, size.height).

pub const fn size(&self) -> Size

The content size of the scroll view

pub const fn area(&self) -> Rect

The area of the buffer that is available to be scrolled

pub const fn buf(&self) -> &Buffer

The buffer containing the contents of the scroll view

pub const fn buf_mut(&mut self) -> &mut Buffer

The mutable buffer containing the contents of the scroll view

This can be used to render widgets into the buffer programmatically

Examples

let mut scroll_view = ScrollView::new(Size::new(20, 20));
Line::raw("Hello, world!").render(Rect::new(0, 0, 20, 1), scroll_view.buf_mut());

pub const fn vertical_scrollbar_visibility( self, visibility: ScrollbarVisibility, ) -> Self

Set the visibility of the vertical scrollbar

See ScrollbarVisibility for all the options.

This is a fluent setter method which must be chained or used as it consumes self

Examples

let mut scroll_view = ScrollView::new(Size::new(20, 20))
    .vertical_scrollbar_visibility(ScrollbarVisibility::Always);

pub const fn horizontal_scrollbar_visibility( self, visibility: ScrollbarVisibility, ) -> Self

Set the visibility of the horizontal scrollbar

See ScrollbarVisibility for all the options.

This is a fluent setter method which must be chained or used as it consumes self

Examples

let mut scroll_view = ScrollView::new(Size::new(20, 20))
    .horizontal_scrollbar_visibility(ScrollbarVisibility::Never);

pub const fn scrollbars_visibility( self, visibility: ScrollbarVisibility, ) -> Self

Set the visibility of both vertical and horizontal scrollbars

See ScrollbarVisibility for all the options.

This is a fluent setter method which must be chained or used as it consumes self

Examples

let mut scroll_view =
    ScrollView::new(Size::new(20, 20)).scrollbars_visibility(ScrollbarVisibility::Automatic);

pub fn render_widget<W: Widget>(&mut self, widget: W, area: Rect)

Render a widget into the scroll buffer

This is the equivalent of Frame::render_widget, but renders the widget into the scroll buffer rather than the main buffer. The widget will be rendered into the area of the buffer specified by the area parameter.

This should not be confused with the render method, which renders the visible area of the ScrollView into the main buffer.

pub fn render_stateful_widget<W: StatefulWidget>( &mut self, widget: W, area: Rect, state: &mut W::State, )

Render a stateful widget into the scroll buffer

This is the equivalent of Frame::render_stateful_widget, but renders the stateful widget into the scroll buffer rather than the main buffer. The stateful widget will be rendered into the area of the buffer specified by the area parameter.

This should not be confused with the render method, which renders the visible area of the ScrollView into the main buffer.

Trait Implementations

impl Clone for ScrollView

fn clone(&self) -> ScrollView

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScrollView

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ScrollView

fn default() -> ScrollView

Returns the “default value” for a type.

impl Hash for ScrollView

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ScrollView

fn eq(&self, other: &ScrollView) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StatefulWidget for ScrollView

type State = ScrollViewState

State associated with the stateful widget.

fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom stateful widget.

impl Eq for ScrollView

impl StructuralPartialEq for ScrollView