Struct Progress 

pub struct Progress { /* private fields */ }

Available on crate feature winio only.

A progress bar.

Implementations

impl Progress

pub fn minimum(&self) -> Result<usize, Error>

Value minimum.

pub fn set_minimum(&mut self, v: usize) -> Result<(), Error>

Set value minimum.

pub fn maximum(&self) -> Result<usize, Error>

Value maximum.

pub fn set_maximum(&mut self, v: usize) -> Result<(), Error>

Set value maximum.

pub fn pos(&self) -> Result<usize, Error>

Current position.

pub fn set_pos(&mut self, pos: usize) -> Result<(), Error>

Set current position.

pub fn is_indeterminate(&self) -> Result<bool, Error>

Get if the progress bar is in indeterminate state.

pub fn set_indeterminate(&mut self, v: bool) -> Result<(), Error>

Set if the progress bar is in indeterminate state.

Examples found in repository

examples/test/widgets.rs (line 118)

    async fn init(
        mut init: Self::Init<'_>,
        sender: &ComponentSender<Self>,
    ) -> Result<Self, Self::Error> {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender).await?;
        // window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));

        let canvas = Child::<Canvas>::init(&window).await?;
        let mut ulabel = Child::<Label>::init(&window).await?;
        ulabel.set_text("Username:");
        ulabel.set_halign(HAlign::Right);
        let mut plabel = Child::<Label>::init(&window).await?;
        plabel.set_text("Password:");
        plabel.set_halign(HAlign::Right);
        let mut uentry = Child::<Edit>::init(&window).await?;
        uentry.set_text("AAA");
        let mut pentry = Child::<Edit>::init(&window).await?;
        pentry.set_text("123456");
        pentry.set_password(true);
        let mut pcheck = Child::<CheckBox>::init(&window).await?;
        pcheck.set_text("Show");
        pcheck.set_checked(false);
        let combo = Child::<ComboBox>::init(&window).await?;
        let mut list = Child::<ObservableVec<String>>::init(Vec::new())
            .await
            .unwrap();
        // https://www.zhihu.com/question/23600507/answer/140640887
        list.push("烫烫烫".to_string());
        list.push("昍昍昍".to_string());
        list.push("ﾌﾌﾌﾌﾌﾌ".to_string());
        list.push("쳌쳌쳌".to_string());
        let mut r1 = Child::<RadioButton>::init(&window).await?;
        r1.set_text("屯屯屯");
        r1.set_checked(true);
        let mut r2 = Child::<RadioButton>::init(&window).await?;
        r2.set_text("锟斤拷");
        let mut r3 = Child::<RadioButton>::init(&window).await?;
        r3.set_text("╠╠╠");
        // Initialize radio group with the radio buttons
        let radio_group = Child::<RadioButtonGroup>::init(vec![r1, r2, r3]).await?;

        let mut push_button = Child::<Button>::init(&window).await?;
        push_button.set_text("Push");
        let mut pop_button = Child::<Button>::init(&window).await?;
        pop_button.set_text("Pop");
        let mut show_button = Child::<Button>::init(&window).await?;
        show_button.set_text("Show");
        let mut progress = Child::<Progress>::init(&window).await?;
        progress.set_indeterminate(true);
        let mut mltext = Child::<TextBox>::init(&window).await?;
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Ok(Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            radio_group,
            rindex: 0,
            push_button,
            pop_button,
            show_button,
            progress,
            mltext,
        })
    }

Trait Implementations

impl AsWidget for Progress

fn as_widget(&self) -> BorrowedWidget<'_>

Get the widget handle.

impl Component for Progress

type Error = Error

The error type.

type Event = ProgressEvent

The output event type to the parent.

type Init<'a> = BorrowedContainer<'a>

Initial parameter type.

type Message = ProgressMessage

The input message type to update.

async fn init( init: <Progress as Component>::Init<'_>, _sender: &ComponentSender<Progress>, ) -> Result<Progress, Error>

Create the initial component.

async fn start(&mut self, sender: &ComponentSender<Self>) -> !

Start the event listening.

async fn update( &mut self, message: Self::Message, sender: &ComponentSender<Self>, ) -> Result<bool, Self::Error>

Respond to the message. Return true if need render.

fn render(&mut self, sender: &ComponentSender<Self>) -> Result<(), Self::Error>

Render the widgets.

async fn update_children(&mut self) -> Result<bool, Self::Error>

Update the children components. Return true if any child needs render.

fn render_children(&mut self) -> Result<(), Self::Error>

Render the children components. It will be called if any child or self needs render.

impl Debug for Progress

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

Formats the value using the given formatter.

impl Enable for Progress

fn is_enabled(&self) -> Result<bool, Error>

If the widget is enabled.

fn set_enabled(&mut self, v: bool) -> Result<(), Error>

Set if the widget is enabled.

fn enable(&mut self) -> Result<(), Self::Error>

Enable the widget.

fn disable(&mut self) -> Result<(), Self::Error>

Disable the widget.

impl Failable for Progress

type Error = Error

The error type associated.

impl Layoutable for Progress

fn loc(&self) -> Result<Point2D<f64, LogicalSpace>, Error>

The left top location.

fn set_loc(&mut self, p: Point2D<f64, LogicalSpace>) -> Result<(), Error>

Move the location.

fn size(&self) -> Result<Size2D<f64, LogicalSpace>, Error>

The size.

fn set_size(&mut self, v: Size2D<f64, LogicalSpace>) -> Result<(), Error>

Resize.

fn preferred_size(&self) -> Result<Size2D<f64, LogicalSpace>, Error>

The preferred size.

fn rect(&self) -> Result<Rect<f64, LogicalSpace>, Self::Error>

The bounding rectangle.

fn set_rect(&mut self, r: Rect<f64, LogicalSpace>) -> Result<(), Self::Error>

Set the location and size.

fn min_size(&self) -> Result<Size2D<f64, LogicalSpace>, Self::Error>

Min acceptable size.

impl ToolTip for Progress

fn tooltip(&self) -> Result<String, Error>

Get the tooltip text of the widget.

fn set_tooltip(&mut self, s: impl AsRef<str>) -> Result<(), Error>

Set the tooltip text of the widget.

impl Visible for Progress

fn is_visible(&self) -> Result<bool, Error>

If the widget is visible.

fn set_visible(&mut self, v: bool) -> Result<(), Error>

Set the visibility.

fn show(&mut self) -> Result<(), Self::Error>

Show the widget.

fn hide(&mut self) -> Result<(), Self::Error>

Hide the widget.