How to draw image in actual size when pixels_per_point != 1.0?

[aemarkov]

I am working on a screenshot utility using EGUI, so I want to display an image (screenshot) in its actual size, pixel to pixel. However, when I display an image using widgets::Image it is slightly bigger than its resolution.

This is because pixel_per_point value is set to ~1.08 . I am on Linux with X11, and this value is calculated in the winit library here. It takes monitor resolution and physical size from xrandr, calculate dpi and divide to the reference DPI 96. As far I understand, it's expected behavior for winit library used to make GUIs have some physical size across multi-DPI displays.

So my question is:
Is it possible to draw an image (texture) in it's actual size without scaling, but don't loose high-dpi support by forcing scale factor to 1.0? E.g. draw image in actual size and keep widgets scalin.g

[rustbasic]

See examples below

// use eframe::egui::*;

fn main() -> eframe::Result {
    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default().with_inner_size([800.0, 600.0]),
        ..Default::default()
    };
    eframe::run_native(
        "My egui App",
        options,
        Box::new(|cc| {
            egui_extras::install_image_loaders(&cc.egui_ctx);
            Ok(Box::<MyApp>::default())
        }),
    )
}

#[derive(Default)]
struct MyApp {
    _temp_value: usize,
    _text: String,
    image_data: Option<egui::Image<'static>>,
    image_scale: f32,
}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            let filename = "./a-image.png";
            let image_data = match std::fs::read(filename) {
                Ok(filedata) => Some(filedata),
                Err(err) => {
                    println!("Don't loading image file: {}", err);
                    None
                }
            };

            if let Some(image_data) = image_data {
                self.image_data = Some(egui::Image::from_bytes(filename, image_data));
            }

            if let Some(image) = self.image_data.clone() {
                self.image_scale = 1.0;

                let texture_lr = image.load_for_size(ui.ctx(), ui.available_size());
                let original_image_size = texture_lr.as_ref().ok().and_then(|t| t.size());
                let image_size = original_image_size.unwrap_or_default();

                let scale_x = image_size[0] as f32 / ui.available_width();
                let scale_y = image_size[1] as f32 / ui.available_height();
                self.image_scale = scale_x.min(scale_y);
                let size = self.image_scale * ui.available_size();

                // --------------------------------------
                // Show Image
                // --------------------------------------
                let fit_image = image.clone().fit_to_exact_size(size);
                let _response = ui.add(fit_image.show_loading_spinner(false));
                // --------------------------------------
                // Show Image
                // --------------------------------------
                let fit_image = image.clone().fit_to_exact_size(image_size);
                let response = ui.add(fit_image.clone().show_loading_spinner(false));

                let response = response.interact(egui::Sense::click_and_drag());
                if response.clicked() {}
            }
        });
    }
}