wombat 1.3.0

Hex file viewer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Preview

use std::sync::Arc;

use bladvak::eframe::egui;
use bladvak::{ErrorManager, image};

/// Previewer
#[derive(serde::Deserialize, serde::Serialize, Default)]
pub(crate) struct Previewer {
    /// open
    pub(crate) is_open: bool,
    /// egui texture
    #[serde(skip)]
    texture: Option<Result<egui::TextureHandle, String>>,
}

impl std::fmt::Debug for Previewer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Previewer")
            .field("is_open", &self.is_open)
            .finish_non_exhaustive()
    }
}

impl Previewer {
    /// ui
    pub(crate) fn ui(
        &mut self,
        ui: &mut egui::Ui,
        _error_manager: &mut ErrorManager,
        binary_file: &Arc<Vec<u8>>,
    ) {
        if self.texture.is_none() {
            if let Ok(img) = image::load_from_memory(binary_file) {
                let img = img.to_rgba8();
                let size = [img.width() as usize, img.height() as usize];

                let color_image = egui::ColorImage::from_rgba_unmultiplied(size, &img);

                self.texture = Some(Ok(ui.ctx().load_texture(
                    "image",
                    color_image,
                    egui::TextureOptions::LINEAR,
                )));
            } else {
                self.texture = Some(Err("Failed to load image from memory".to_string()));
            }
        }
        if self.is_open {
            let mut is_open = self.is_open;
            egui::Window::new("Previewer")
                .open(&mut is_open)
                .vscroll(true)
                .show(ui.ctx(), |ui| {
                    if let Some(res_texture) = &self.texture {
                        match res_texture {
                            Ok(texture) => {
                                ui.image(texture);
                            }
                            Err(e) => {
                                ui.label(e);
                            }
                        }
                    } else {
                        ui.label("Nothing to show");
                    }
                });
            self.is_open = is_open;
        }
    }

    /// reset
    pub(crate) fn reset(&mut self) {
        self.texture = None;
    }
}