Trait ViewSeq

pub trait ViewSeq<T> {
    type State;

    // Required methods
    fn len(&self) -> usize;
    fn build(
        &mut self,
        cx: &mut BuildCx<'_, '_>,
        data: &mut T,
    ) -> (Self::State, Vec<ViewState>);
    fn rebuild(
        &mut self,
        state: &mut Self::State,
        cx: &mut BuildCx<'_, '_>,
        data: &mut T,
        old: &Self,
    );
    fn rebuild_nth(
        &mut self,
        n: usize,
        state: &mut Self::State,
        cx: &mut RebuildCx<'_, '_>,
        data: &mut T,
        old: &Self,
    );
    fn event_nth(
        &mut self,
        n: usize,
        state: &mut Self::State,
        cx: &mut EventCx<'_, '_>,
        data: &mut T,
        event: &Event,
    ) -> bool;
    fn layout_nth(
        &mut self,
        n: usize,
        state: &mut Self::State,
        cx: &mut LayoutCx<'_, '_>,
        data: &mut T,
        space: Space,
    ) -> Size;
    fn draw_nth(
        &mut self,
        n: usize,
        state: &mut Self::State,
        cx: &mut DrawCx<'_, '_>,
        data: &mut T,
    );
}

A sequence of views.

Required Associated Types

type State

The state of the sequence.

Required Methods

fn len(&self) -> usize

The length of the sequence.

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (Self::State, Vec<ViewState>)

Build the sequence state.

fn rebuild( &mut self, state: &mut Self::State, cx: &mut BuildCx<'_, '_>, data: &mut T, old: &Self, )

Rebuild the sequence state.

fn rebuild_nth( &mut self, n: usize, state: &mut Self::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &Self, )

Rebuild the nth view.

fn event_nth( &mut self, n: usize, state: &mut Self::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

Handle an event for the nth view.

fn layout_nth( &mut self, n: usize, state: &mut Self::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

Layout the nth view.

fn draw_nth( &mut self, n: usize, state: &mut Self::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

Draw the nth view.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> ViewSeq<T> for ()

type State = ()

fn len(&self) -> usize

fn build( &mut self, _cx: &mut BuildCx<'_, '_>, _data: &mut T, ) -> (<() as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <() as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(), )

fn rebuild_nth( &mut self, _n: usize, _state: &mut <() as ViewSeq<T>>::State, _cx: &mut RebuildCx<'_, '_>, _data: &mut T, _old: &(), )

fn event_nth( &mut self, _n: usize, _state: &mut <() as ViewSeq<T>>::State, _cx: &mut EventCx<'_, '_>, _data: &mut T, _event: &Event, ) -> bool

fn layout_nth( &mut self, _n: usize, _state: &mut <() as ViewSeq<T>>::State, _cx: &mut LayoutCx<'_, '_>, _data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, _n: usize, _state: &mut <() as ViewSeq<T>>::State, _cx: &mut DrawCx<'_, '_>, _data: &mut T, )

impl<T, A> ViewSeq<T> for (A,)

where A: View<T>,

type State = (<A as View<T>>::State,)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A,) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A,) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A,), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A,) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A,), )

fn event_nth( &mut self, n: usize, state: &mut <(A,) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A,) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A,) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B> ViewSeq<T> for (A, B)

where A: View<T>, B: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C> ViewSeq<T> for (A, B, C)

where A: View<T>, B: View<T>, C: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D> ViewSeq<T> for (A, B, C, D)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E> ViewSeq<T> for (A, B, C, D, E)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F> ViewSeq<T> for (A, B, C, D, E, F)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G> ViewSeq<T> for (A, B, C, D, E, F, G)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H> ViewSeq<T> for (A, B, C, D, E, F, G, H)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I> ViewSeq<T> for (A, B, C, D, E, F, G, H, I)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>, U: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State, <U as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>, U: View<T>, V: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State, <U as View<T>>::State, <V as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>, U: View<T>, V: View<T>, W: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State, <U as View<T>>::State, <V as View<T>>::State, <W as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>, U: View<T>, V: View<T>, W: View<T>, X: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State, <U as View<T>>::State, <V as View<T>>::State, <W as View<T>>::State, <X as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z> ViewSeq<T> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z)

where A: View<T>, B: View<T>, C: View<T>, D: View<T>, E: View<T>, F: View<T>, G: View<T>, H: View<T>, I: View<T>, J: View<T>, K: View<T>, L: View<T>, M: View<T>, N: View<T>, O: View<T>, P: View<T>, Q: View<T>, R: View<T>, S: View<T>, U: View<T>, V: View<T>, W: View<T>, X: View<T>, Z: View<T>,

type State = (<A as View<T>>::State, <B as View<T>>::State, <C as View<T>>::State, <D as View<T>>::State, <E as View<T>>::State, <F as View<T>>::State, <G as View<T>>::State, <H as View<T>>::State, <I as View<T>>::State, <J as View<T>>::State, <K as View<T>>::State, <L as View<T>>::State, <M as View<T>>::State, <N as View<T>>::State, <O as View<T>>::State, <P as View<T>>::State, <Q as View<T>>::State, <R as View<T>>::State, <S as View<T>>::State, <U as View<T>>::State, <V as View<T>>::State, <W as View<T>>::State, <X as View<T>>::State, <Z as View<T>>::State)

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, _state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, _cx: &mut BuildCx<'_, '_>, _data: &mut T, _old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z), )

fn rebuild_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z), )

fn event_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, U, V, W, X, Z) as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

impl<T, V> ViewSeq<T> for Vec<V>

where V: View<T>,

type State = Vec<<V as View<T>>::State>

fn len(&self) -> usize

fn build( &mut self, cx: &mut BuildCx<'_, '_>, data: &mut T, ) -> (<Vec<V> as ViewSeq<T>>::State, Vec<ViewState>)

fn rebuild( &mut self, state: &mut <Vec<V> as ViewSeq<T>>::State, cx: &mut BuildCx<'_, '_>, data: &mut T, _old: &Vec<V>, )

fn rebuild_nth( &mut self, n: usize, state: &mut <Vec<V> as ViewSeq<T>>::State, cx: &mut RebuildCx<'_, '_>, data: &mut T, old: &Vec<V>, )

fn event_nth( &mut self, n: usize, state: &mut <Vec<V> as ViewSeq<T>>::State, cx: &mut EventCx<'_, '_>, data: &mut T, event: &Event, ) -> bool

fn layout_nth( &mut self, n: usize, state: &mut <Vec<V> as ViewSeq<T>>::State, cx: &mut LayoutCx<'_, '_>, data: &mut T, space: Space, ) -> Size

fn draw_nth( &mut self, n: usize, state: &mut <Vec<V> as ViewSeq<T>>::State, cx: &mut DrawCx<'_, '_>, data: &mut T, )

Implementors