Struct kas_core::theme::DrawMgr

pub struct DrawMgr<'a> { /* private fields */ }

Draw interface

This interface is provided to widgets in crate::Layout::draw. Lower-level interfaces may be accessed through Self::draw_device.

DrawMgr is not a Copy or Clone type; instead it may be “reborrowed” via Self::re_id or Self::re_clone.

• draw.check_box(&*self, self.state); — note &*self to convert from to &W from &mut W, since the latter would cause borrow conflicts

Implementations

impl<'a> DrawMgr<'a>

pub fn re_id<'b>(&'b mut self, id: WidgetId) -> DrawMgr<'b>where
    'a: 'b,

Reborrow with a new lifetime and new id

Rust allows references like &T or &mut T to be “reborrowed” through coercion: essentially, the pointer is copied under a new, shorter, lifetime. Until rfcs#1403 lands, reborrows on user types require a method call.

Examples found in repository

src/theme/draw.rs (line 85)

    pub fn recurse(&mut self, child: &mut dyn Widget) {
        child.draw(self.re_id(child.id()));
    }

pub fn re_clone<'b>(&'b mut self) -> DrawMgr<'b>where
    'a: 'b,

Reborrow with a new lifetime and same id

Rust allows references like &T or &mut T to be “reborrowed” through coercion: essentially, the pointer is copied under a new, shorter, lifetime. Until rfcs#1403 lands, reborrows on user types require a method call.

Examples found in repository

src/layout/visitor.rs (line 366)

    fn draw(&mut self, mut draw: DrawMgr) {
        for child in &mut self.children {
            child.draw(draw.re_clone());
        }
    }
}

/// Float layout
struct Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    children: I,
}

impl<'a, I> Layout for Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let mut rules = SizeRules::EMPTY;
        for child in &mut self.children {
            rules = rules.max(child.size_rules(mgr.re(), axis));
        }
        rules
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        for child in &mut self.children {
            child.set_rect(mgr, rect);
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        self.children.find_map(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let mut iter = (&mut self.children).rev();
        if let Some(first) = iter.next() {
            first.draw(draw.re_clone());
        }
        for child in iter {
            draw.with_pass(|draw| child.draw(draw));
        }
    }
}

/// A row/column over a slice
struct Slice<'a, W: Widget, D: Directional> {
    data: &'a mut DynRowStorage,
    direction: D,
    children: &'a mut [W],
}

impl<'a, W: Widget, D: Directional> Layout for Slice<'a, W, D> {
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let dim = (self.direction, self.children.len());
        let mut solver = RowSolver::new(axis, dim, self.data);
        for (n, child) in self.children.iter_mut().enumerate() {
            solver.for_child(self.data, n, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let dim = (self.direction, self.children.len());
        let mut setter = RowSetter::<D, Vec<i32>, _>::new(rect, dim, self.data);

        for (n, child) in self.children.iter_mut().enumerate() {
            child.set_rect(mgr, setter.child_rect(self.data, n));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        let solver = RowPositionSolver::new(self.direction);
        solver
            .find_child_mut(self.children, coord)
            .and_then(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let solver = RowPositionSolver::new(self.direction);
        solver.for_children(self.children, draw.get_clip_rect(), |w| draw.recurse(w));
    }
}

/// Implement grid layout for children
struct Grid<'a, S, I> {
    data: &'a mut S,
    dim: GridDimensions,
    children: I,
}

impl<'a, S: GridStorage, I> Layout for Grid<'a, S, I>
where
    I: Iterator<Item = (GridChildInfo, Visitor<'a>)>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let mut solver = GridSolver::<Vec<_>, Vec<_>, _>::new(axis, self.dim, self.data);
        for (info, child) in &mut self.children {
            solver.for_child(self.data, info, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let mut setter = GridSetter::<Vec<_>, Vec<_>, _>::new(rect, self.dim, self.data);
        for (info, child) in &mut self.children {
            child.set_rect(mgr, setter.child_rect(self.data, info));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        // TODO(opt): more efficient search strategy?
        self.children.find_map(|(_, child)| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        for (_, child) in &mut self.children {
            child.draw(draw.re_clone());
        }
    }

pub fn recurse(&mut self, child: &mut dyn Widget)

Recurse drawing to a child

Examples found in repository

src/root.rs (line 60)

        fn draw(&mut self, mut draw: DrawMgr) {
            draw.recurse(&mut self.w);
            for (_, popup) in &self.popups {
                if let Some(widget) = self.w.find_widget_mut(&popup.id) {
                    draw.with_overlay(widget.rect(), |mut draw| {
                        draw.recurse(widget);
                    });
                }
            }
        }

src/layout/visitor.rs (line 310)

    fn draw_(&mut self, mut draw: DrawMgr) {
        match &mut self.layout {
            LayoutType::None => (),
            LayoutType::Component(component) => component.draw(draw),
            LayoutType::BoxComponent(layout) => layout.draw(draw),
            LayoutType::Single(child) | LayoutType::AlignSingle(child, _) => draw.recurse(*child),
            LayoutType::Align(layout, _) => layout.draw_(draw),
            LayoutType::Pack(layout, _, _) => layout.draw_(draw),
            LayoutType::Margins(layout, _, _) => layout.draw_(draw),
            LayoutType::Frame(child, storage, style) => {
                draw.frame(storage.rect, *style, Background::Default);
                child.draw_(draw);
            }
            LayoutType::Button(child, storage, color) => {
                let bg = match color {
                    Some(rgb) => Background::Rgb(*rgb),
                    None => Background::Default,
                };
                draw.frame(storage.rect, FrameStyle::Button, bg);
                child.draw_(draw);
            }
        }
    }
}

/// Implement row/column layout for children
struct List<'a, S, D, I> {
    data: &'a mut S,
    direction: D,
    children: I,
}

impl<'a, S: RowStorage, D: Directional, I> Layout for List<'a, S, D, I>
where
    I: ExactSizeIterator<Item = Visitor<'a>>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let dim = (self.direction, self.children.len());
        let mut solver = RowSolver::new(axis, dim, self.data);
        for (n, child) in (&mut self.children).enumerate() {
            solver.for_child(self.data, n, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let dim = (self.direction, self.children.len());
        let mut setter = RowSetter::<D, Vec<i32>, _>::new(rect, dim, self.data);

        for (n, child) in (&mut self.children).enumerate() {
            child.set_rect(mgr, setter.child_rect(self.data, n));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        // TODO(opt): more efficient search strategy?
        self.children.find_map(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        for child in &mut self.children {
            child.draw(draw.re_clone());
        }
    }
}

/// Float layout
struct Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    children: I,
}

impl<'a, I> Layout for Float<'a, I>
where
    I: DoubleEndedIterator<Item = Visitor<'a>>,
{
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let mut rules = SizeRules::EMPTY;
        for child in &mut self.children {
            rules = rules.max(child.size_rules(mgr.re(), axis));
        }
        rules
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        for child in &mut self.children {
            child.set_rect(mgr, rect);
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        self.children.find_map(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let mut iter = (&mut self.children).rev();
        if let Some(first) = iter.next() {
            first.draw(draw.re_clone());
        }
        for child in iter {
            draw.with_pass(|draw| child.draw(draw));
        }
    }
}

/// A row/column over a slice
struct Slice<'a, W: Widget, D: Directional> {
    data: &'a mut DynRowStorage,
    direction: D,
    children: &'a mut [W],
}

impl<'a, W: Widget, D: Directional> Layout for Slice<'a, W, D> {
    fn size_rules(&mut self, mgr: SizeMgr, axis: AxisInfo) -> SizeRules {
        let dim = (self.direction, self.children.len());
        let mut solver = RowSolver::new(axis, dim, self.data);
        for (n, child) in self.children.iter_mut().enumerate() {
            solver.for_child(self.data, n, |axis| child.size_rules(mgr.re(), axis));
        }
        solver.finish(self.data)
    }

    fn set_rect(&mut self, mgr: &mut ConfigMgr, rect: Rect) {
        let dim = (self.direction, self.children.len());
        let mut setter = RowSetter::<D, Vec<i32>, _>::new(rect, dim, self.data);

        for (n, child) in self.children.iter_mut().enumerate() {
            child.set_rect(mgr, setter.child_rect(self.data, n));
        }
    }

    fn find_id(&mut self, coord: Coord) -> Option<WidgetId> {
        let solver = RowPositionSolver::new(self.direction);
        solver
            .find_child_mut(self.children, coord)
            .and_then(|child| child.find_id(coord))
    }

    fn draw(&mut self, mut draw: DrawMgr) {
        let solver = RowPositionSolver::new(self.direction);
        solver.for_children(self.children, draw.get_clip_rect(), |w| draw.recurse(w));
    }

pub fn ev_state(&mut self) -> &EventState

Access event-management state

pub fn size_mgr(&mut self) -> SizeMgr<'_>

Access a SizeMgr

pub fn config_mgr<F: FnMut(&mut ConfigMgr<'_>) -> T, T>(&mut self, f: F) -> T

Access a ConfigMgr

pub fn draw_shared(&mut self) -> &mut dyn DrawShared

Access a DrawShared

pub fn draw_device(&mut self) -> &mut dyn Draw

Access the low-level draw device

Note: this drawing API is modular, with limited functionality in the base trait Draw. To access further functionality, it is necessary to downcast with crate::draw::DrawIface::downcast_from.

Examples found in repository

src/theme/draw.rs (line 130)

    pub fn draw_iface<DS: DrawSharedImpl>(&mut self) -> Option<DrawIface<DS>> {
        DrawIface::downcast_from(self.draw_device())
    }

pub fn draw_iface<DS: DrawSharedImpl>(&mut self) -> Option<DrawIface<'_, DS>>

Access the low-level draw device (implementation type)

The implementing type must be specified. See DrawIface::downcast_from.

pub fn with_pass<F: FnOnce(DrawMgr<'_>)>(&mut self, f: F)

Draw to a new pass

Adds a new draw pass for purposes of enforcing draw order. Content of the new pass will be drawn after content in the parent pass.

Examples found in repository

src/layout/visitor.rs (line 407)

    fn draw(&mut self, mut draw: DrawMgr) {
        let mut iter = (&mut self.children).rev();
        if let Some(first) = iter.next() {
            first.draw(draw.re_clone());
        }
        for child in iter {
            draw.with_pass(|draw| child.draw(draw));
        }
    }

pub fn with_clip_region<F: FnOnce(DrawMgr<'_>)>(
    &mut self,
    rect: Rect,
    offset: Offset,
    f: F
)

Draw to a new pass with clipping and offset (e.g. for scrolling)

Adds a new draw pass of type PassType::Clip, with draw operations clipped to rect and translated by `offset.

pub fn with_overlay<F: FnOnce(DrawMgr<'_>)>(&mut self, rect: Rect, f: F)

Draw to a new pass as an overlay (e.g. for pop-up menus)

Adds a new draw pass of type PassType::Overlay, with draw operations clipped to rect.

The theme is permitted to enlarge the rect for the purpose of drawing a frame or shadow around this overlay, thus the Self::get_clip_rect may be larger than expected.

Examples found in repository

src/root.rs (lines 63-65)

        fn draw(&mut self, mut draw: DrawMgr) {
            draw.recurse(&mut self.w);
            for (_, popup) in &self.popups {
                if let Some(widget) = self.w.find_widget_mut(&popup.id) {
                    draw.with_overlay(widget.rect(), |mut draw| {
                        draw.recurse(widget);
                    });
                }
            }
        }

pub fn get_clip_rect(&mut self) -> Rect

Target area for drawing

Drawing is restricted to this Rect, which may be the whole window, a clip region or an overlay. This may be used to cull hidden items from lists inside a scrollable view.

Examples found in repository

src/layout/visitor.rs (line 447)

    fn draw(&mut self, mut draw: DrawMgr) {
        let solver = RowPositionSolver::new(self.direction);
        solver.for_children(self.children, draw.get_clip_rect(), |w| draw.recurse(w));
    }

pub fn frame(&mut self, rect: Rect, style: FrameStyle, bg: Background)

Draw a frame inside the given rect

The frame dimensions are given by SizeMgr::frame.

Examples found in repository

src/layout/visitor.rs (line 315)

    fn draw_(&mut self, mut draw: DrawMgr) {
        match &mut self.layout {
            LayoutType::None => (),
            LayoutType::Component(component) => component.draw(draw),
            LayoutType::BoxComponent(layout) => layout.draw(draw),
            LayoutType::Single(child) | LayoutType::AlignSingle(child, _) => draw.recurse(*child),
            LayoutType::Align(layout, _) => layout.draw_(draw),
            LayoutType::Pack(layout, _, _) => layout.draw_(draw),
            LayoutType::Margins(layout, _, _) => layout.draw_(draw),
            LayoutType::Frame(child, storage, style) => {
                draw.frame(storage.rect, *style, Background::Default);
                child.draw_(draw);
            }
            LayoutType::Button(child, storage, color) => {
                let bg = match color {
                    Some(rgb) => Background::Rgb(*rgb),
                    None => Background::Default,
                };
                draw.frame(storage.rect, FrameStyle::Button, bg);
                child.draw_(draw);
            }
        }
    }

pub fn separator(&mut self, rect: Rect)

Draw a separator in the given rect

pub fn selection_box(&mut self, rect: Rect)

Draw a selection box

This appears as a dashed box or similar around this rect. Note that the selection indicator is drawn outside of this rect, within a margin of size SizeMgr::inner_margins that is expected to be present around this box.

pub fn text(&mut self, rect: Rect, text: impl AsRef<TextDisplay>, class: TextClass)

Draw text

Text is drawn from rect.pos and clipped to rect. If the text scrolls, rect should be the size of the whole text, not the window.

ConfigMgr::text_set_size should be called prior to this method to select a font, font size and wrap options (based on the TextClass).

Examples found in repository

src/label.rs (line 60)

        fn draw(&mut self, mut draw: DrawMgr) {
            draw.text(self.rect(), &self.label, Self::CLASS);
        }

pub fn text_effects(&mut self, rect: Rect, text: &dyn TextApi, class: TextClass)

Draw text with effects

Text is drawn from rect.pos and clipped to rect. If the text scrolls, rect should be the size of the whole text, not the window.

Self::text already supports font effects: bold, emphasis, text size. In addition, this method supports underline and strikethrough effects.

ConfigMgr::text_set_size should be called prior to this method to select a font, font size and wrap options (based on the TextClass).

pub fn text_selected<R: RangeBounds<usize>>(
    &mut self,
    rect: Rect,
    text: impl AsRef<TextDisplay>,
    range: R,
    class: TextClass
)

Draw some text using the standard font, with a subset selected

Other than visually highlighting the selection, this method behaves identically to Self::text. It is likely to be replaced in the future by a higher-level API.

pub fn text_cursor(
    &mut self,
    rect: Rect,
    text: impl AsRef<TextDisplay>,
    class: TextClass,
    byte: usize
)

Draw an edit marker at the given byte index on this text

The text cursor is draw from rect.pos and clipped to rect. If the text scrolls, rect should be the size of the whole text, not the window.

ConfigMgr::text_set_size should be called prior to this method to select a font, font size and wrap options (based on the TextClass).

pub fn check_box(
    &mut self,
    rect: Rect,
    checked: bool,
    last_change: Option<Instant>
)

Draw UI element: check box (without label)

The check box is a small visual element, typically a distinctive square box with or without a “check” selection mark.

The theme may animate transitions. To achieve this, last_change should be the time of the last state change caused by the user, or none when the last state change was programmatic.

pub fn radio_box(
    &mut self,
    rect: Rect,
    checked: bool,
    last_change: Option<Instant>
)

Draw UI element: radio box (without label)

The radio box is a small visual element, typically a disinctive circular box with or without a “radio” selection mark.

The theme may animate transitions. To achieve this, last_change should be the time of the last state change caused by the user, or none when the last state change was programmatic.

pub fn mark(&mut self, rect: Rect, style: MarkStyle)

Draw UI element: mark

pub fn scroll_bar<W: Widget>(
    &mut self,
    track_rect: Rect,
    handle: &W,
    dir: Direction
)

Draw UI element: scroll bar

pub fn slider<W: Widget>(&mut self, track_rect: Rect, handle: &W, dir: Direction)

Draw UI element: slider

pub fn progress_bar(&mut self, rect: Rect, dir: Direction, value: f32)

Draw UI element: progress bar

• rect: area of whole widget
• dir: direction of progress bar
• state: highlighting information
• value: progress value, between 0.0 and 1.0

pub fn image(&mut self, rect: Rect, id: ImageId)

Draw an image

Trait Implementations

impl<'a> BitOrAssign<TkAction> for DrawMgr<'a>

fn bitor_assign(&mut self, action: TkAction)

Performs the |= operation.