Struct nannou::ui::widget::scroll::State

pub struct State<A> {
    pub offset: f64,
    pub offset_bounds: Range,
    pub scrollable_range_len: f64,
    pub is_scrolling: bool,
    // some fields omitted
}

Scroll state calculated for a single axis.

Fields

offset: f64

The distance that has been scrolled from the origin.

A positive offset pushes the scrollable range that is under the kid_area upwards.

A negative offset pushes the scrollable range that is under the kid_area downwards.

offset_bounds: Range

The start and end bounds for the offset along the axis.

scrollable_range_len: f64

The total range which may be “offset” from the “root” range (aka the kid_area).

The scrollable_range is determined as the bounding range around both the kid_area and all un-scrolled visible children widgets.

is_scrolling: bool

Whether or not the this axis is currently scrolling.

Implementations

impl<A> State<A> where
    A: Axis, 

pub fn update(
    ui: &Ui,
    idx: NodeIndex<u32>,
    kid_area: &KidArea,
    maybe_prev_scroll_state: Option<State<A>>,
    additional_offset: f64
) -> State<A>

Calculate the new scroll state for the single axis of a Widget.

          >     +---+
          |     |   |
          |   =========================
          |   | | a | scroll root     |
          |   | +---+ aka `kid_area`  |
          |   |            +--------+ |
          |   |            |        | |
          |   =========================
          |                |   b    |
          |                +--------+
scrollable|    +--------+
   range y|    |        |
          |    |        | +------+
          |    |    c   | |      |
          |    +--------+ |  d   |
          |               |      |
          >               +------+

               ^--------------------^
                    scrollable
                     range x

• kid_area is the cropped area of the container widget in which kid widgets may be viewed.
• a, b, c and d are widgets that are kids of the “scroll root” widget in their original, un-scrolled positions.
• scrollable_range is the total range occuppied by all children widgets in their original, un-scrolled positions.

Everything above and below the set of ==== bars of the parent widget is hidden, i.e:

=========================
| | a | scroll root     |
| +---+ aka `kid_area`  |
|            +--------+ |
|            |   b    | |
=========================

The scrollable_range on each axis only becomes scrollable if its length exceeds the length of the kid_area on the same axis. Thus, in the above example, only the y scrollable_range is scrollable.

The offset_bounds are calculated as the amount which the original, un-scrolled, scrollable_range may be offset from its origin.

  offset +              >
  bounds v              |
  .start >              |   =========================
                        |   |                       |
                        |   |        kid_area       |
                        |   |                       |
                        |   |                       |
         >   scrollable |   =========================
         ^      range y |
         ^              |    
         ^              |    
  offset ^              |    
  bounds ^              |    
    .end ^              |    
         ^              |    
         ^              |    
         +              >    

Trait Implementations

impl<A> Clone for State<A> where
    A: Clone, 

pub fn clone(&self) -> State<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Debug for State<A> where
    A: Debug, 

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

Formats the value using the given formatter.

impl<A> PartialEq<State<A>> for State<A> where
    A: PartialEq<A>, 

pub fn eq(&self, other: &State<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &State<A>) -> bool

This method tests for !=.

impl<A> Copy for State<A> where
    A: Copy, 

impl<A> StructuralPartialEq for State<A>