Unable to fine-tune when images are loaded

[nagy135]

Unable to fine-tune when images are loaded

[fogarecious]

You can try release mode:

cargo run --release

If the performance is still not good, you can try loading the image asynchronously:

use iced::{
    widget::{button, column, container, image, image::Handle},
    Application, Command,
};
use tokio::{fs::File, io::AsyncReadExt};

const PATH_TO_YOUR_IMAGE: &str = "/path/to/your/image";

fn main() -> iced::Result {
    App::run(iced::Settings::default())
}

#[derive(Debug, Clone)]
enum Message {
    Load,
    Loaded(Vec<u8>),
}

struct App {
    image_handle: Option<Handle>,
    show_container: bool,
}

impl Application for App {
    type Executor = iced::executor::Default;
    type Message = Message;
    type Theme = iced::Theme;
    type Flags = ();

    fn new(_flags: Self::Flags) -> (Self, iced::Command<Self::Message>) {
        (
            Self {
                image_handle: None,
                show_container: false,
            },
            Command::none(),
        )
    }

    fn title(&self) -> String {
        "Lazily load image".into()
    }

    fn update(&mut self, message: Self::Message) -> iced::Command<Self::Message> {
        match message {
            Message::Load => {
                self.show_container = true;
                return Command::perform(
                    async {
                        let mut file = File::open(PATH_TO_YOUR_IMAGE).await.unwrap();
                        let mut buffer = Vec::new();
                        file.read_to_end(&mut buffer).await.unwrap();
                        buffer
                    },
                    Message::Loaded,
                )
            }
            Message::Loaded(data) => self.image_handle = Some(Handle::from_memory(data)),
        }
        Command::none()
    }

    fn view(&self) -> iced::Element<'_, Self::Message, iced::Renderer<Self::Theme>> {
        column![
            button("Load").on_press(Message::Load),
            if self.show_container {
                match &self.image_handle {
                    Some(h) => container(image(h.clone())),
                    None => container("Loading..."),
                }
            } else {
                container("")
            },
        ]
        .into()
    }
}

with the dependencies:

[dependencies]
iced = { version = "0.10.0", features = ["image", "advanced", "tokio"] }
tokio = { version = "1.35.1", features = ["full"] }

See if this method solves your problem.

[nagy135]

Hmm i think this is way too complex to what i was trying to accomplish, but with release mode it feels fast enough, its like 100-200ms to load 3 more images, which is fine. Thanks for suggestion