use crate::error::Error;
use crate::i18n::{I18N, Language};
use crate::messages::Msg;
use crate::theme::shadcn_theme_ext::ShadcnThemeExt;
use crate::widgets::qr_scanner::qr_scanner_state::QrScannerState;
use std::sync::Arc;
type ScanFn = Arc<dyn Fn(String) + Send + Sync>;
type ErrorFn = Arc<dyn Fn(&Error) + Send + Sync>;
#[must_use]
pub struct QrScanner {
desired_size: Option<egui::Vec2>,
fps: f32,
decode_fps: f32,
dedupe_ms: u64,
continuous: bool,
auto_start: bool,
on_scan: Option<ScanFn>,
on_error: Option<ErrorFn>,
}
impl Default for QrScanner {
fn default() -> Self {
Self {
desired_size: None,
fps: 10.0,
decode_fps: 5.0,
dedupe_ms: 1500,
continuous: false,
auto_start: true,
on_scan: None,
on_error: None,
}
}
}
impl QrScanner {
pub fn new() -> Self {
Self::default()
}
pub fn desired_size(mut self, size: egui::Vec2) -> Self {
self.desired_size = Some(size);
self
}
pub fn fps(mut self, fps: f32) -> Self {
self.fps = fps;
self
}
pub fn decode_fps(mut self, decode_fps: f32) -> Self {
self.decode_fps = decode_fps;
self
}
pub fn dedupe_ms(mut self, ms: u64) -> Self {
self.dedupe_ms = ms;
self
}
pub fn continuous(mut self, yes: bool) -> Self {
self.continuous = yes;
self
}
pub fn auto_start(mut self, yes: bool) -> Self {
self.auto_start = yes;
self
}
pub fn on_scan(mut self, f: impl Fn(String) + Send + Sync + 'static) -> Self {
self.on_scan = Some(Arc::new(f));
self
}
pub fn on_error(mut self, f: impl Fn(&Error) + Send + Sync + 'static) -> Self {
self.on_error = Some(Arc::new(f));
self
}
pub fn show(
self,
ui: &mut egui::Ui,
state: &mut QrScannerState,
lang: Language,
) -> egui::Response {
let theme = ui.ctx().shadcn_theme();
state.configure(
self.fps,
self.decode_fps,
self.dedupe_ms,
self.continuous,
self.on_scan.clone(),
self.on_error.clone(),
);
if self.auto_start && !state.is_scanning() && state.error().is_none() {
let _ = state.start(ui.ctx());
}
state.show_picked_preview(ui.ctx());
egui::Frame::new()
.fill(theme.card)
.stroke(egui::Stroke::new(1.0, theme.border))
.corner_radius(crate::paint::corner_radius(theme.radius))
.inner_margin(egui::Margin::same(12))
.show(ui, |inner| {
let desired_opt = self.desired_size;
let fresh = state.drain_rgba().is_some_and(|(rgba, w, h)| {
state.store_preview(inner.ctx(), &rgba, w, h);
true
});
let viewport = inner.ctx().input(egui::InputState::viewport_rect);
let fitted = desired_opt.map_or_else(
|| {
let (frame_w, frame_h) = state.preview_size().unwrap_or((4, 3));
crate::utils::responsive_preview_size(
inner.available_width(),
inner.available_height(),
viewport.width(),
viewport.height(),
frame_w,
frame_h,
)
},
|desired| {
let capped =
crate::frame::cap_preview_size(desired, inner.available_width());
state.preview_size().map_or(capped, |(frame_w, frame_h)| {
crate::frame::fit_preview_size(capped, frame_w, frame_h)
})
},
);
let running = state.is_scanning();
if let Some(tex) = state.preview_texture() {
let id = tex.id();
let _ = inner.add(
egui::Image::new((id, fitted)).corner_radius(egui::CornerRadius::same(8)),
);
if running && fresh {
inner.ctx().request_repaint();
}
} else {
placeholder(inner, fitted, &theme, &Msg::CameraStarting.render(lang));
if running {
inner.ctx().request_repaint();
}
}
if let Some(err) = state.error() {
inner.add_space(6.0);
fire_on_error(state, &err);
let _ = inner.label(
egui::RichText::new(err.render(lang))
.color(theme.destructive)
.size(12.0),
);
}
if let Some(txt) = state.decoded() {
inner.add_space(4.0);
let _ = inner.label(
egui::RichText::new(format!("{}: {txt}", Msg::Decoded.render(lang)))
.color(theme.foreground)
.size(13.0)
.strong(),
);
}
#[cfg(any(
all(target_arch = "wasm32", feature = "web"),
not(any(target_arch = "wasm32", target_os = "android"))
))]
{
inner.add_space(8.0);
if inner
.add(
crate::Button::new(Msg::PickImage.render(lang))
.variant(crate::ButtonVariant::Outline),
)
.clicked()
{
spawn_pick_image(state, inner.ctx());
}
}
})
.response
}
}
fn placeholder(
ui: &mut egui::Ui,
size: egui::Vec2,
theme: &crate::theme::shadcn_theme::ShadcnTheme,
text: &str,
) {
let (rect, _) = ui.allocate_exact_size(size, egui::Sense::hover());
if ui.is_rect_visible(rect) {
let _ = ui
.painter()
.rect_filled(rect, egui::CornerRadius::same(8), theme.muted);
let _ = ui.painter().text(
rect.center(),
egui::Align2::CENTER_CENTER,
text,
egui::FontId::proportional(13.0),
theme.muted_foreground,
);
}
}
fn fire_on_error(state: &QrScannerState, err: &Error) {
if let Some(cb) = state.on_error_callback() {
cb(err);
}
}
#[cfg(any(
all(target_arch = "wasm32", feature = "web"),
not(any(target_arch = "wasm32", target_os = "android"))
))]
fn spawn_pick_image(state: &mut QrScannerState, ui_ctx: &egui::Context) {
let slots = state.pick_slots();
let ctx = (*ui_ctx).clone();
#[cfg(all(target_arch = "wasm32", feature = "web"))]
{
wasm_bindgen_futures::spawn_local(async move {
match crate::files::pick_files(false).await {
Ok(files) => {
for (_, data) in files {
let Some((text, rgba, width, height)) = decode_bytes(&data) else {
continue;
};
slots.set_picked(rgba, width, height);
if let Some(code) = text {
slots.set_decoded(code);
ctx.request_repaint();
return;
}
}
slots.set_error(&crate::error::Error::QrNotFound);
ctx.request_repaint();
}
Err(e) => {
slots.set_error(&e);
ctx.request_repaint();
}
}
});
}
#[cfg(not(any(target_arch = "wasm32", target_os = "android")))]
{
let _ = std::thread::spawn(move || {
let picked = rfd::FileDialog::new()
.add_filter("Image", &["png", "jpg", "jpeg"])
.pick_file();
if let Some(path) = picked {
let data = std::fs::read(&path).unwrap_or_default();
match decode_bytes(&data) {
Some((text, rgba, width, height)) => {
slots.set_picked(rgba, width, height);
if let Some(code) = text {
slots.set_decoded(code);
} else {
slots.set_error(&crate::error::Error::QrNotFound);
}
}
None => {
slots.set_error(&crate::error::Error::QrNotFound);
}
}
ctx.request_repaint();
}
});
}
}
#[cfg(all(
feature = "camera",
feature = "qr",
any(
all(target_arch = "wasm32", feature = "web"),
not(any(target_arch = "wasm32", target_os = "android"))
)
))]
fn decode_bytes(data: &[u8]) -> Option<(Option<String>, Vec<u8>, u32, u32)> {
let img = image::load_from_memory(data).ok()?;
let rgba = img.to_rgba8();
let (w, h) = (rgba.width(), rgba.height());
let raw = rgba.into_raw();
let text = crate::qr::decode_qr_rgba(&raw, w, h);
Some((text, raw, w, h))
}
#[cfg(all(
not(all(feature = "camera", feature = "qr")),
any(
all(target_arch = "wasm32", feature = "web"),
not(any(target_arch = "wasm32", target_os = "android"))
)
))]
fn decode_bytes(_data: &[u8]) -> Option<(Option<String>, Vec<u8>, u32, u32)> {
None
}