Struct conrod::widget::scroll::State

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

Scroll state calculated for a single axis.

Fields

offset: Scalar

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: Scalar

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.

Methods

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

pub fn update(
    ui: &Ui,
    idx: Id,
    kid_area: &KidArea,
    maybe_prev_scroll_state: Option<Self>,
    additional_offset: Scalar
) -> Self

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: Copy> Copy for State<A>

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

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> Debug for State<A>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

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

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

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

This method tests for !=.