793 lines
40 KiB
Rust
793 lines
40 KiB
Rust
// 檔案卡片和預覽 (the original: a rounded card with the file's icon, name and size; clicking it
|
||
// opens a large viewer — spreadsheets as a grid with row numbers, documents rendered, pictures
|
||
// shown — with download and close at the top right).
|
||
|
||
use super::*;
|
||
use crate::preview::{self, Preview};
|
||
use std::sync::{Arc, Mutex};
|
||
|
||
pub struct FileView {
|
||
pub name: String,
|
||
pub path: String,
|
||
preview: Preview,
|
||
sheet: usize,
|
||
image: Option<egui::TextureHandle>,
|
||
/// PDF pages (or a video's first frame) drawn on a worker thread.
|
||
job: Option<Arc<Mutex<PageJob>>>,
|
||
pages: Vec<egui::TextureHandle>,
|
||
audio: Option<AudioPlay>,
|
||
audio_err: Option<String>,
|
||
/// The audio's length, known before it plays.
|
||
audio_len: Option<std::time::Duration>,
|
||
}
|
||
|
||
/// Pictures made on a worker thread for the viewer.
|
||
#[derive(Default)]
|
||
pub struct PageJob {
|
||
ready: Vec<image::RgbaImage>,
|
||
total: usize,
|
||
done: bool,
|
||
error: Option<String>,
|
||
}
|
||
|
||
/// An audio file playing inside AnyBot (rodio: the same on macOS, Windows and Linux).
|
||
pub struct AudioPlay {
|
||
_sink: rodio::MixerDeviceSink,
|
||
player: rodio::Player,
|
||
total: Option<std::time::Duration>,
|
||
}
|
||
|
||
impl AudioPlay {
|
||
fn start(path: &str) -> Result<Self, String> {
|
||
let mut sink = rodio::DeviceSinkBuilder::open_default_sink().map_err(|_| t("找不到可以播放聲音的裝置").to_string())?;
|
||
sink.log_on_drop(false);
|
||
let file = std::fs::File::open(path).map_err(|e| format!("{}：{e}", t("讀不到檔案")))?;
|
||
let dec = match rodio::Decoder::try_from(file) {
|
||
Ok(d) => d,
|
||
// Opus and the rarer formats: let ffmpeg (when installed) turn it into WAV first.
|
||
Err(_) => {
|
||
let wav = std::env::temp_dir().join(format!("anybot-audio-{}.wav", std::process::id()));
|
||
let ok = std::process::Command::new("ffmpeg")
|
||
.env("PATH", crate::cloudbox::tool_path())
|
||
.args(["-loglevel", "error", "-y", "-i", path])
|
||
.arg(&wav)
|
||
.stdin(std::process::Stdio::null())
|
||
.output()
|
||
.map(|o| o.status.success())
|
||
.unwrap_or(false);
|
||
let f = std::fs::File::open(&wav).ok().filter(|_| ok);
|
||
f.and_then(|f| rodio::Decoder::try_from(f).ok()).ok_or_else(|| t("這種音訊格式沒辦法在 AnyBot 裡播放，可以用其他 App 打開。").to_string())?
|
||
}
|
||
};
|
||
let total = rodio::Source::total_duration(&dec);
|
||
let player = rodio::Player::connect_new(sink.mixer());
|
||
player.append(dec);
|
||
Ok(AudioPlay { _sink: sink, player, total })
|
||
}
|
||
}
|
||
|
||
fn clock(d: std::time::Duration) -> String {
|
||
let s = d.as_secs();
|
||
if s >= 3600 {
|
||
format!("{}:{:02}:{:02}", s / 3600, s / 60 % 60, s % 60)
|
||
} else {
|
||
format!("{}:{:02}", s / 60, s % 60)
|
||
}
|
||
}
|
||
|
||
/// Draw a PDF's pages, or a video's first frame (with ffmpeg when it is installed), off the UI thread.
|
||
fn start_job(kind: &str, path: &str) -> Option<Arc<Mutex<PageJob>>> {
|
||
let job = Arc::new(Mutex::new(PageJob::default()));
|
||
let j = job.clone();
|
||
let path = std::path::PathBuf::from(path);
|
||
match kind {
|
||
"pdf" => {
|
||
std::thread::spawn(move || {
|
||
let r = preview::pdf_pages(&path, 1400.0, 300, |_, total, img| {
|
||
let mut g = j.lock().unwrap();
|
||
g.total = total;
|
||
g.ready.push(img);
|
||
drop(g);
|
||
// Stop when the viewer was closed.
|
||
Arc::strong_count(&j) > 1
|
||
});
|
||
let mut g = j.lock().unwrap();
|
||
g.error = r.err();
|
||
g.done = true;
|
||
});
|
||
}
|
||
"image" => {
|
||
// Decoding (a 6000×4000 photo, a big SVG) on the UI thread froze the window;
|
||
// the viewer shows a spinner until this thread is done.
|
||
std::thread::spawn(move || {
|
||
let img = preview::decode_image(&path);
|
||
let mut g = j.lock().unwrap();
|
||
if let Some(img) = img {
|
||
g.ready.push(img);
|
||
}
|
||
g.done = true;
|
||
});
|
||
}
|
||
"video" => {
|
||
std::thread::spawn(move || {
|
||
let out = std::env::temp_dir().join(format!("anybot-poster-{}-{}.png", std::process::id(), crate::model::now_ms()));
|
||
let ok = std::process::Command::new("ffmpeg")
|
||
.env("PATH", crate::cloudbox::tool_path())
|
||
.args(["-loglevel", "error", "-y", "-ss", "0.5", "-i"])
|
||
.arg(&path)
|
||
.args(["-frames:v", "1", "-vf", "scale='min(1280,iw)':-2"])
|
||
.arg(&out)
|
||
.stdin(std::process::Stdio::null())
|
||
.output()
|
||
.map(|o| o.status.success())
|
||
.unwrap_or(false);
|
||
let mut g = j.lock().unwrap();
|
||
if ok {
|
||
if let Ok(img) = image::open(&out) {
|
||
g.ready.push(img.to_rgba8());
|
||
}
|
||
}
|
||
let _ = std::fs::remove_file(&out);
|
||
g.done = true;
|
||
});
|
||
}
|
||
_ => return None,
|
||
}
|
||
Some(job)
|
||
}
|
||
|
||
fn texture(ctx: &egui::Context, name: &str, img: &image::RgbaImage) -> egui::TextureHandle {
|
||
let size = [img.width() as usize, img.height() as usize];
|
||
ctx.load_texture(name, egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR)
|
||
}
|
||
|
||
const CARD_W: f32 = 320.0;
|
||
const CARD_H: f32 = 64.0;
|
||
|
||
/// The grey of the bot's bubbles (rgb 31 in dark mode like the original; a light grey in light).
|
||
pub fn agent_fill(p: Palette) -> Color32 {
|
||
if p.pane.r() < 128 {
|
||
Color32::from_rgb(0x21, 0x21, 0x21)
|
||
} else {
|
||
Color32::from_rgb(0xf1, 0xf1, 0xf1)
|
||
}
|
||
}
|
||
|
||
impl App {
|
||
/// A file in the chat. Click: preview. Right side on hover: save a copy.
|
||
pub(super) fn file_card(&mut self, ui: &mut egui::Ui, a: &crate::attach::Attachment) {
|
||
let p = self.pal;
|
||
let (rect, r) = ui.allocate_exact_size(vec2(CARD_W.min(ui.available_width()), CARD_H), egui::Sense::click());
|
||
let fill = agent_fill(p);
|
||
ui.painter().rect_filled(rect, 16, if r.hovered() { fill.gamma_multiply(0.9).to_opaque() } else { fill });
|
||
let icon = egui::Rect::from_min_size(rect.left_top() + vec2(14.0, 12.0), vec2(34.0, 40.0));
|
||
big_file_icon(ui.painter(), icon, &a.name, p);
|
||
let tx = icon.right() + 14.0;
|
||
let max_w = rect.right() - tx - 12.0;
|
||
let name = fit_name(ui, &a.name, max_w);
|
||
ui.painter().text(egui::pos2(tx, rect.top() + 16.0), egui::Align2::LEFT_TOP, name, egui::FontId::proportional(14.0), p.text);
|
||
let sub = if a.bytes > 0 { crate::attach::human(a.bytes) } else { preview::kind_label(&a.name) };
|
||
ui.painter().text(egui::pos2(tx, rect.top() + 36.0), egui::Align2::LEFT_TOP, sub, egui::FontId::proportional(12.0), p.text3);
|
||
if r.on_hover_text(format!("{}（{}）", a.name, t("點一下預覽"))).on_hover_cursor(egui::CursorIcon::PointingHand).clicked() {
|
||
self.open_file(&a.name, &a.path);
|
||
}
|
||
}
|
||
|
||
pub(super) fn open_file(&mut self, name: &str, path: &str) {
|
||
let preview = preview::load(std::path::Path::new(path), name);
|
||
let job = start_job(preview::kind_of(name), path);
|
||
self.file_view = Some(FileView { name: name.to_string(), path: path.to_string(), preview, sheet: 0, image: None, job, pages: vec![], audio: None, audio_err: None, audio_len: None });
|
||
if let Some(fv) = self.file_view.as_mut().filter(|_| preview::kind_of(name) == "audio") {
|
||
fv.audio_len = std::fs::File::open(path).ok().and_then(|f| rodio::Decoder::try_from(f).ok()).and_then(|d| rodio::Source::total_duration(&d));
|
||
}
|
||
}
|
||
|
||
/// The large viewer.
|
||
pub(super) fn file_viewer(&mut self, ctx: &egui::Context) {
|
||
let Some(fv) = self.file_view.as_mut() else { return };
|
||
let p = self.pal;
|
||
let screen = ctx.content_rect();
|
||
let w = (screen.width() - 80.0).clamp(320.0, 1100.0);
|
||
let h = (screen.height() - 80.0).max(300.0);
|
||
let dark = p.pane.r() < 128;
|
||
let mut close = false;
|
||
let mut save = false;
|
||
let mut open_app = false;
|
||
let resp = egui::Modal::new(egui::Id::unique("file-viewer"))
|
||
.backdrop_color(Color32::from_black_alpha(if dark { 150 } else { 80 }))
|
||
.frame(Frame::new().fill(p.pane).stroke(Stroke::new(1.0, p.border)).corner_radius(14).shadow(egui::epaint::Shadow { offset: [0, 12], blur: 40, spread: 0, color: Color32::from_black_alpha(90) }))
|
||
.show(ctx, |ui| {
|
||
ui.set_width(w);
|
||
ui.set_height(h);
|
||
ui.spacing_mut().item_spacing.y = 0.0;
|
||
// Title, what it is, and download / close.
|
||
Frame::new().inner_margin(Margin { left: 16, right: 10, top: 12, bottom: 10 }).show(ui, |ui| {
|
||
ui.set_width(ui.available_width());
|
||
ui.horizontal(|ui| {
|
||
ui.vertical(|ui| {
|
||
ui.spacing_mut().item_spacing.y = 2.0;
|
||
ui.add(egui::Label::new(RichText::new(&fv.name).size(14.0).strong().color(p.text)).truncate());
|
||
let sub = match &fv.preview {
|
||
Preview::Table(s) => format!("{} {}", s.get(fv.sheet).map(|x| x.1.len().saturating_sub(1)).unwrap_or(0), t("列")),
|
||
Preview::Pdf => match fv.job.as_ref().map(|j| j.lock().unwrap().total) {
|
||
Some(n) if n > 0 => format!("PDF · {n} {}", t("頁")),
|
||
_ => "PDF".into(),
|
||
},
|
||
_ => preview::kind_label(&fv.name),
|
||
};
|
||
ui.label(RichText::new(sub).size(12.0).color(p.text3));
|
||
});
|
||
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
|
||
close = crate::icons::button(ui, crate::icons::Icon::Close, 32.0, p.text2, p.hover).on_hover_text(t("關閉預覽")).clicked();
|
||
save = crate::icons::button(ui, crate::icons::Icon::Download, 32.0, p.text2, p.hover).on_hover_text(t("下載檔案")).clicked();
|
||
open_app = small_button(ui, "用其他 App 打開", p).clicked();
|
||
});
|
||
});
|
||
});
|
||
let r = ui.min_rect();
|
||
ui.painter().hline(r.x_range(), r.bottom(), Stroke::new(1.0, p.border));
|
||
let body_h = ui.available_height();
|
||
match &fv.preview {
|
||
Preview::Table(sheets) => {
|
||
let tabs = sheets.len() > 1;
|
||
let grid_h = body_h - if tabs { 40.0 } else { 0.0 };
|
||
if let Some((_, rows)) = sheets.get(fv.sheet) {
|
||
Frame::new().inner_margin(Margin::same(12)).show(ui, |ui| sheet_grid(ui, rows, grid_h - 24.0, p));
|
||
}
|
||
if tabs {
|
||
ui.horizontal(|ui| {
|
||
ui.add_space(12.0);
|
||
for (i, (name, _)) in sheets.iter().enumerate() {
|
||
if ui.selectable_label(fv.sheet == i, name).clicked() {
|
||
fv.sheet = i;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
Preview::Markdown(md) => {
|
||
egui::ScrollArea::vertical().max_height(body_h).auto_shrink([false, false]).show(ui, |ui| {
|
||
Frame::new().inner_margin(Margin::symmetric(28, 20)).show(ui, |ui| {
|
||
ui.set_max_width(760.0);
|
||
doc_markdown(ui, md, p);
|
||
});
|
||
});
|
||
}
|
||
Preview::Html(text) => {
|
||
Frame::new().inner_margin(Margin::symmetric(16, 10)).show(ui, |ui| {
|
||
ui.horizontal(|ui| {
|
||
if ui.add(primary_button("在瀏覽器開啟", p)).clicked() {
|
||
open_app = true;
|
||
}
|
||
ui.label(RichText::new(t("下面是網頁的內容（版面以瀏覽器為準）")).size(12.0).color(p.text3));
|
||
});
|
||
});
|
||
egui::ScrollArea::vertical().max_height(body_h - 52.0).auto_shrink([false, false]).show(ui, |ui| {
|
||
Frame::new().inner_margin(Margin::symmetric(28, 8)).show(ui, |ui| {
|
||
ui.set_max_width(760.0);
|
||
doc_markdown(ui, text, p);
|
||
});
|
||
});
|
||
}
|
||
Preview::Image => {
|
||
// The picture is decoded on a worker thread (start_job "image").
|
||
if fv.image.is_none() {
|
||
if let Some(job) = fv.job.clone() {
|
||
let (imgs, done) = {
|
||
let mut g = job.lock().unwrap();
|
||
(std::mem::take(&mut g.ready), g.done)
|
||
};
|
||
match imgs.into_iter().next() {
|
||
Some(img) => fv.image = Some(texture(ui.ctx(), "file-view", &img)),
|
||
None => {
|
||
ui.add_space(40.0);
|
||
ui.vertical_centered(|ui| {
|
||
if done {
|
||
ui.label(RichText::new(t("這張圖片打不開")).color(p.text3));
|
||
} else {
|
||
ui.spinner();
|
||
ui.ctx().request_repaint_after(std::time::Duration::from_millis(80));
|
||
}
|
||
});
|
||
}
|
||
}
|
||
} else {
|
||
fv.image = load_texture(ui.ctx(), &fv.path);
|
||
}
|
||
}
|
||
match &fv.image {
|
||
Some(tex) => {
|
||
let avail = vec2(ui.available_width() - 24.0, body_h - 24.0);
|
||
let size = tex.size_vec2();
|
||
let s = (avail.x / size.x).min(avail.y / size.y).min(1.0);
|
||
ui.vertical_centered(|ui| {
|
||
ui.add_space(12.0);
|
||
ui.add(egui::Image::new((tex.id(), size * s)).corner_radius(8));
|
||
});
|
||
}
|
||
None => {
|
||
ui.add_space(20.0);
|
||
ui.vertical_centered(|ui| ui.label(RichText::new(t("這張圖片打不開")).color(p.text3)));
|
||
}
|
||
}
|
||
}
|
||
Preview::Pdf => {
|
||
let (mut done, mut err, mut total) = (true, None, 0);
|
||
if let Some(job) = &fv.job {
|
||
let mut g = job.lock().unwrap();
|
||
for (i, img) in g.ready.drain(..).enumerate() {
|
||
let n = fv.pages.len() + i;
|
||
fv.pages.push(texture(ui.ctx(), &format!("pdf-page-{n}"), &img));
|
||
}
|
||
done = g.done;
|
||
err = g.error.clone();
|
||
total = g.total;
|
||
}
|
||
if !done {
|
||
ui.ctx().request_repaint_after(std::time::Duration::from_millis(80));
|
||
}
|
||
if fv.pages.is_empty() {
|
||
ui.add_space(40.0);
|
||
ui.vertical_centered(|ui| match err {
|
||
Some(e) if done => {
|
||
ui.label(RichText::new(t(&e)).color(p.text2));
|
||
ui.add_space(10.0);
|
||
if ui.add(secondary_button("用其他 App 打開")).clicked() {
|
||
open_app = true;
|
||
}
|
||
}
|
||
_ => {
|
||
ui.add(egui::Spinner::new().size(22.0).color(p.text3));
|
||
ui.add_space(8.0);
|
||
ui.label(RichText::new(t("正在打開 PDF…")).size(13.0).color(p.text3));
|
||
}
|
||
});
|
||
} else {
|
||
egui::ScrollArea::vertical().max_height(body_h).auto_shrink([false, false]).show(ui, |ui| {
|
||
let page_w = (ui.available_width() - 48.0).min(900.0);
|
||
ui.vertical_centered(|ui| {
|
||
ui.spacing_mut().item_spacing.y = 14.0;
|
||
ui.add_space(16.0);
|
||
for (i, tex) in fv.pages.iter().enumerate() {
|
||
let size = tex.size_vec2() * (page_w / tex.size_vec2().x);
|
||
let r = ui.add(egui::Image::new((tex.id(), size)).corner_radius(4));
|
||
ui.painter().rect_stroke(r.rect, 4, Stroke::new(1.0, p.border), egui::StrokeKind::Outside);
|
||
if total > 1 {
|
||
r.on_hover_text(format!("{} {} / {total}", t("第"), i + 1));
|
||
}
|
||
}
|
||
if !done {
|
||
ui.add(egui::Spinner::new().size(18.0).color(p.text3));
|
||
} else if total > fv.pages.len() {
|
||
ui.label(RichText::new(format!("{} {} {}", t("只顯示前"), fv.pages.len(), t("頁，完整內容請用其他 App 打開"))).size(12.0).color(p.text3));
|
||
}
|
||
ui.add_space(16.0);
|
||
});
|
||
});
|
||
}
|
||
}
|
||
Preview::Audio => {
|
||
ui.add_space((body_h * 0.28).max(30.0));
|
||
ui.vertical_centered(|ui| {
|
||
let (tile, _) = ui.allocate_exact_size(vec2(88.0, 88.0), egui::Sense::hover());
|
||
let accent = Color32::from_rgb(0x0e, 0xa5, 0xe9);
|
||
ui.painter().rect_filled(tile, 22, accent.gamma_multiply(0.16));
|
||
crate::icons::paint(ui.painter(), egui::Rect::from_center_size(tile.center(), vec2(40.0, 40.0)), crate::icons::Icon::FileAudio, accent);
|
||
ui.add_space(18.0);
|
||
let playing = fv.audio.as_ref().is_some_and(|a| !a.player.is_paused() && !a.player.empty());
|
||
let (pos, total) = fv.audio.as_ref().map(|a| (a.player.get_pos(), a.total.or(fv.audio_len))).unwrap_or((Default::default(), fv.audio_len));
|
||
let (btn, br) = ui.allocate_exact_size(vec2(56.0, 56.0), egui::Sense::click());
|
||
ui.painter().circle_filled(btn.center(), 28.0, if br.hovered() { p.text } else { p.text.gamma_multiply(0.92) });
|
||
let icon = if playing { crate::icons::Icon::Pause } else { crate::icons::Icon::Play };
|
||
let off = if playing { 0.0 } else { 2.0 };
|
||
crate::icons::paint(ui.painter(), egui::Rect::from_center_size(btn.center() + vec2(off, 0.0), vec2(22.0, 22.0)), icon, p.pane);
|
||
if br.on_hover_text(if playing { t("暫停") } else { t("播放") }).on_hover_cursor(egui::CursorIcon::PointingHand).clicked() {
|
||
match &fv.audio {
|
||
Some(a) if a.player.empty() => fv.audio = None,
|
||
Some(a) if playing => a.player.pause(),
|
||
Some(a) => a.player.play(),
|
||
None => {}
|
||
}
|
||
if fv.audio.is_none() {
|
||
match AudioPlay::start(&fv.path) {
|
||
Ok(a) => fv.audio = Some(a),
|
||
Err(e) => fv.audio_err = Some(e),
|
||
}
|
||
}
|
||
}
|
||
ui.add_space(16.0);
|
||
// Progress: drag to jump.
|
||
let bar_w = (ui.available_width() - 120.0).min(420.0);
|
||
let (bar, bresp) = ui.allocate_exact_size(vec2(bar_w, 18.0), egui::Sense::click_and_drag());
|
||
let line = egui::Rect::from_center_size(bar.center(), vec2(bar_w, 4.0));
|
||
ui.painter().rect_filled(line, 2, p.hover);
|
||
let frac = match total {
|
||
Some(t) if t.as_secs_f32() > 0.0 => (pos.as_secs_f32() / t.as_secs_f32()).clamp(0.0, 1.0),
|
||
_ => 0.0,
|
||
};
|
||
let mut done_part = line;
|
||
done_part.set_right(line.left() + line.width() * frac);
|
||
ui.painter().rect_filled(done_part, 2, p.text);
|
||
ui.painter().circle_filled(egui::pos2(done_part.right(), line.center().y), 6.0, p.text);
|
||
if let (Some(a), Some(tot), Some(at)) = (&fv.audio, total, bresp.interact_pointer_pos()) {
|
||
let f = ((at.x - line.left()) / line.width()).clamp(0.0, 1.0);
|
||
let _ = a.player.try_seek(tot.mul_f32(f));
|
||
}
|
||
ui.add_space(6.0);
|
||
let time = match total {
|
||
Some(tot) => format!("{} / {}", clock(pos), clock(tot)),
|
||
None => clock(pos),
|
||
};
|
||
ui.label(RichText::new(time).size(12.0).color(p.text3));
|
||
if let Some(e) = &fv.audio_err {
|
||
ui.add_space(10.0);
|
||
ui.label(RichText::new(e).size(13.0).color(p.danger));
|
||
ui.add_space(6.0);
|
||
if ui.add(secondary_button("用其他 App 打開")).clicked() {
|
||
open_app = true;
|
||
}
|
||
}
|
||
if playing {
|
||
ui.ctx().request_repaint_after(std::time::Duration::from_millis(200));
|
||
}
|
||
});
|
||
}
|
||
Preview::Video => {
|
||
let mut done = true;
|
||
if let Some(job) = &fv.job {
|
||
let mut g = job.lock().unwrap();
|
||
if let Some(img) = g.ready.pop() {
|
||
fv.image = Some(texture(ui.ctx(), "video-poster", &img));
|
||
}
|
||
done = g.done;
|
||
}
|
||
if !done {
|
||
ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
|
||
}
|
||
ui.vertical_centered(|ui| {
|
||
ui.add_space(16.0);
|
||
let avail = vec2(ui.available_width() - 48.0, body_h - 90.0);
|
||
let (rect, resp) = match &fv.image {
|
||
Some(tex) => {
|
||
let size = tex.size_vec2();
|
||
let s = (avail.x / size.x).min(avail.y / size.y).min(1.5);
|
||
let r = ui.add(egui::Image::new((tex.id(), size * s)).corner_radius(10).sense(egui::Sense::click()));
|
||
(r.rect, r)
|
||
}
|
||
None => {
|
||
let size = vec2(avail.x.min(640.0), (avail.x.min(640.0) * 9.0 / 16.0).min(avail.y));
|
||
let (r, resp) = ui.allocate_exact_size(size, egui::Sense::click());
|
||
ui.painter().rect_filled(r, 10, Color32::from_rgb(0x10, 0x10, 0x10));
|
||
if !done {
|
||
egui::Spinner::new().size(20.0).color(Color32::from_gray(150)).paint_at(ui, egui::Rect::from_center_size(r.center() + vec2(0.0, 52.0), vec2(20.0, 20.0)));
|
||
}
|
||
(r, resp)
|
||
}
|
||
};
|
||
// The play button in the middle.
|
||
ui.painter().circle_filled(rect.center(), 32.0, Color32::from_black_alpha(if resp.hovered() { 200 } else { 150 }));
|
||
crate::icons::paint(ui.painter(), egui::Rect::from_center_size(rect.center() + vec2(2.0, 0.0), vec2(26.0, 26.0)), crate::icons::Icon::Play, Color32::WHITE);
|
||
if resp.on_hover_text(t("播放影片")).on_hover_cursor(egui::CursorIcon::PointingHand).clicked() {
|
||
open_app = true;
|
||
}
|
||
ui.add_space(12.0);
|
||
ui.label(RichText::new(t("影片會用電腦的播放器播放")).size(12.0).color(p.text3));
|
||
});
|
||
}
|
||
Preview::Text(text) => {
|
||
egui::ScrollArea::both().max_height(body_h).auto_shrink([false, false]).show(ui, |ui| {
|
||
Frame::new().inner_margin(Margin::symmetric(16, 12)).show(ui, |ui| {
|
||
ui.add(egui::Label::new(RichText::new(text).monospace().size(12.5).color(p.text)).extend());
|
||
});
|
||
});
|
||
}
|
||
Preview::Other(msg) => {
|
||
ui.add_space(40.0);
|
||
ui.vertical_centered(|ui| {
|
||
ui.label(RichText::new(t(msg)).color(p.text2));
|
||
ui.add_space(10.0);
|
||
if ui.add(secondary_button("用其他 App 打開")).clicked() {
|
||
open_app = true;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
});
|
||
let path = fv.path.clone();
|
||
let name = fv.name.clone();
|
||
if open_app {
|
||
preview::open_with_system(&path);
|
||
}
|
||
if save {
|
||
// 下載: save a copy where the person picks (Downloads by default).
|
||
std::thread::spawn(move || {
|
||
if let Some(to) = crate::share::choose_save(&name) {
|
||
let _ = std::fs::copy(&path, to);
|
||
}
|
||
});
|
||
}
|
||
if close || resp.should_close() {
|
||
self.file_view = None;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn load_texture(ctx: &egui::Context, path: &str) -> Option<egui::TextureHandle> {
|
||
let img = preview::decode_image(std::path::Path::new(path))?;
|
||
Some(texture(ctx, "file-view", &img))
|
||
}
|
||
|
||
/// A document in the viewer (Markdown, Word and web pages): headings, paragraphs with bold,
|
||
/// italics and `code`, bulleted and numbered lists, quotes, rules, code blocks and tables.
|
||
pub(super) fn doc_markdown(ui: &mut egui::Ui, md: &str, p: Palette) {
|
||
ui.spacing_mut().item_spacing.y = 6.0;
|
||
let lines: Vec<&str> = md.lines().collect();
|
||
let mut i = 0;
|
||
while i < lines.len() {
|
||
let line = lines[i].trim_end();
|
||
let t = line.trim_start();
|
||
if t.starts_with("```") {
|
||
let mut code = String::new();
|
||
i += 1;
|
||
while i < lines.len() && !lines[i].trim_start().starts_with("```") {
|
||
code.push_str(lines[i]);
|
||
code.push('\n');
|
||
i += 1;
|
||
}
|
||
Frame::new().fill(p.hover).corner_radius(8).inner_margin(Margin::same(12)).show(ui, |ui| {
|
||
ui.set_width(ui.available_width());
|
||
ui.add(egui::Label::new(RichText::new(code.trim_end()).monospace().size(12.5).color(p.text)).wrap());
|
||
});
|
||
} else if t.starts_with('|') && i + 1 < lines.len() && is_rule_row(lines[i + 1]) {
|
||
let mut rows = vec![table_cells(t)];
|
||
i += 2;
|
||
while i < lines.len() && lines[i].trim_start().starts_with('|') {
|
||
rows.push(table_cells(lines[i].trim()));
|
||
i += 1;
|
||
}
|
||
doc_table(ui, &rows, p);
|
||
continue;
|
||
} else if t.is_empty() {
|
||
ui.add_space(2.0);
|
||
} else if t == "---" || t == "***" || t == "___" {
|
||
let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 12.0), egui::Sense::hover());
|
||
ui.painter().hline(r.x_range(), r.center().y, Stroke::new(1.0, p.border));
|
||
} else if let Some((level, h)) = heading(t) {
|
||
ui.add_space(if level == 1 { 10.0 } else { 6.0 });
|
||
let size = [24.0, 20.0, 17.0][level - 1];
|
||
ui.add(egui::Label::new(inline_job(h, size, p.text, p, true)).wrap());
|
||
ui.add_space(2.0);
|
||
} else if let Some(q) = t.strip_prefix("> ").or_else(|| t.strip_prefix('>')) {
|
||
ui.horizontal_top(|ui| {
|
||
let (bar, _) = ui.allocate_exact_size(vec2(3.0, 22.0), egui::Sense::hover());
|
||
ui.painter().rect_filled(bar, 2, p.border);
|
||
ui.add_space(8.0);
|
||
ui.add(egui::Label::new(inline_job(q, 15.0, p.text2, p, false)).wrap());
|
||
});
|
||
} else if let Some((marker, item)) = list_item(t) {
|
||
let indent = (line.len() - t.len()) as f32 * 8.0;
|
||
ui.horizontal_top(|ui| {
|
||
ui.add_space(6.0 + indent);
|
||
ui.add_sized(vec2(22.0, 22.0), egui::Label::new(RichText::new(marker).size(15.0).color(p.text2)));
|
||
ui.add(egui::Label::new(inline_job(item, 15.0, p.text, p, false)).wrap());
|
||
});
|
||
} else {
|
||
ui.add(egui::Label::new(inline_job(t, 15.0, p.text, p, false)).wrap());
|
||
}
|
||
i += 1;
|
||
}
|
||
}
|
||
|
||
fn heading(t: &str) -> Option<(usize, &str)> {
|
||
let n = t.chars().take_while(|c| *c == '#').count();
|
||
(1..=6).contains(&n).then(|| t[n..].strip_prefix(' ')).flatten().map(|h| (n.min(3), h))
|
||
}
|
||
|
||
fn list_item(t: &str) -> Option<(String, &str)> {
|
||
for b in ["- ", "* ", "+ "] {
|
||
if let Some(rest) = t.strip_prefix(b) {
|
||
return Some(("•".into(), rest));
|
||
}
|
||
}
|
||
let digits = t.chars().take_while(|c| c.is_ascii_digit()).count();
|
||
if digits > 0 && digits < 4 {
|
||
if let Some(rest) = t[digits..].strip_prefix(". ").or_else(|| t[digits..].strip_prefix(") ")) {
|
||
return Some((format!("{}.", &t[..digits]), rest));
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn is_rule_row(l: &str) -> bool {
|
||
let t = l.trim();
|
||
t.starts_with('|') && t.contains('-') && t.chars().all(|c| matches!(c, '|' | '-' | ':' | ' '))
|
||
}
|
||
|
||
fn table_cells(l: &str) -> Vec<String> {
|
||
let inner = l.trim().trim_start_matches('|').trim_end_matches('|');
|
||
let mut cells = vec![];
|
||
let mut cur = String::new();
|
||
let mut esc = false;
|
||
for c in inner.chars() {
|
||
match c {
|
||
'\\' if !esc => esc = true,
|
||
'|' if !esc => cells.push(std::mem::take(&mut cur).trim().to_string()),
|
||
c => {
|
||
if esc && c != '|' {
|
||
cur.push('\\');
|
||
}
|
||
esc = false;
|
||
cur.push(c);
|
||
}
|
||
}
|
||
}
|
||
cells.push(cur.trim().to_string());
|
||
cells
|
||
}
|
||
|
||
fn doc_table(ui: &mut egui::Ui, rows: &[Vec<String>], p: Palette) {
|
||
let n = rows.iter().map(|r| r.len()).max().unwrap_or(0);
|
||
egui::ScrollArea::horizontal().id_salt(ui.next_auto_id()).auto_shrink([false, true]).show(ui, |ui| {
|
||
Frame::new().stroke(Stroke::new(1.0, p.border)).corner_radius(8).show(ui, |ui| {
|
||
egui::Grid::new(ui.next_auto_id()).spacing(vec2(0.0, 0.0)).show(ui, |ui| {
|
||
for (ri, r) in rows.iter().enumerate() {
|
||
for ci in 0..n {
|
||
let cell = r.get(ci).map(String::as_str).unwrap_or("");
|
||
let fill = if ri == 0 { p.hover } else { Color32::TRANSPARENT };
|
||
Frame::new().fill(fill).inner_margin(Margin::symmetric(12, 8)).show(ui, |ui| {
|
||
ui.set_min_width(60.0);
|
||
ui.set_max_width(320.0);
|
||
ui.add(egui::Label::new(inline_job(cell, 14.0, if ri == 0 { p.text } else { p.text2 }, p, ri == 0)).wrap());
|
||
});
|
||
}
|
||
ui.end_row();
|
||
}
|
||
});
|
||
});
|
||
});
|
||
ui.add_space(4.0);
|
||
}
|
||
|
||
/// One line of Markdown text with **bold**, *italics* and `code`.
|
||
fn inline_job(s: &str, size: f32, col: Color32, p: Palette, strong: bool) -> egui::text::LayoutJob {
|
||
use egui::text::{LayoutJob, TextFormat};
|
||
let mut job = LayoutJob::default();
|
||
let (mut bold, mut italic, mut code) = (strong, false, false);
|
||
let mut buf = String::new();
|
||
let flush = |job: &mut LayoutJob, buf: &mut String, bold: bool, italic: bool, code: bool| {
|
||
if buf.is_empty() {
|
||
return;
|
||
}
|
||
let mut f = TextFormat { font_id: if code { egui::FontId::monospace(size - 1.5) } else { egui::FontId::proportional(size) }, color: if bold { p.text } else { col }, italics: italic, ..Default::default() };
|
||
if code {
|
||
f.background = p.hover;
|
||
}
|
||
job.append(buf, 0.0, f);
|
||
buf.clear();
|
||
};
|
||
let chars: Vec<char> = s.chars().collect();
|
||
let mut i = 0;
|
||
while i < chars.len() {
|
||
let c = chars[i];
|
||
if c == '`' {
|
||
flush(&mut job, &mut buf, bold, italic, code);
|
||
code = !code;
|
||
} else if !code && c == '*' && chars.get(i + 1) == Some(&'*') {
|
||
flush(&mut job, &mut buf, bold, italic, code);
|
||
bold = !bold;
|
||
i += 1;
|
||
} else if !code && c == '*' && (italic || chars.get(i + 1).is_some_and(|n| !n.is_whitespace())) {
|
||
flush(&mut job, &mut buf, bold, italic, code);
|
||
italic = !italic;
|
||
} else {
|
||
buf.push(c);
|
||
}
|
||
i += 1;
|
||
}
|
||
flush(&mut job, &mut buf, bold, italic, code);
|
||
job
|
||
}
|
||
|
||
/// A spreadsheet grid like the original's: row numbers on the left, the first row as header,
|
||
/// columns sized to their contents (60–260 px), long cells cut with "…" (full text on hover).
|
||
fn sheet_grid(ui: &mut egui::Ui, rows: &[Vec<String>], height: f32, p: Palette) {
|
||
let font = egui::FontId::proportional(13.0);
|
||
let ncols = rows.iter().map(|r| r.len()).max().unwrap_or(0);
|
||
let mut widths = vec![60.0f32; ncols];
|
||
for r in rows.iter().take(60) {
|
||
for (i, c) in r.iter().enumerate() {
|
||
let w = ui.painter().layout_no_wrap(c.clone(), font.clone(), p.text).size().x + 20.0;
|
||
widths[i] = widths[i].max(w.min(260.0));
|
||
}
|
||
}
|
||
let num_w = 44.0;
|
||
let row_h = 28.0;
|
||
let total_w = num_w + widths.iter().sum::<f32>();
|
||
let line = Stroke::new(1.0, p.border);
|
||
egui::ScrollArea::both().max_height(height.max(100.0)).auto_shrink([false, false]).show_rows(ui, row_h, rows.len(), |ui, range| {
|
||
for ri in range {
|
||
let (rect, resp) = ui.allocate_exact_size(vec2(total_w, row_h), egui::Sense::hover());
|
||
let header = ri == 0;
|
||
if header {
|
||
ui.painter().rect_filled(rect, 0, p.hover);
|
||
}
|
||
// Row number.
|
||
let nr = egui::Rect::from_min_size(rect.min, vec2(num_w, row_h));
|
||
ui.painter().rect_filled(nr, 0, p.hover);
|
||
ui.painter().text(nr.right_center() - vec2(8.0, 0.0), egui::Align2::RIGHT_CENTER, format!("{}", ri + 1), egui::FontId::proportional(12.0), p.text3);
|
||
let mut x = rect.left() + num_w;
|
||
let mut hovered_cell: Option<String> = None;
|
||
for (ci, w) in widths.iter().enumerate() {
|
||
let cell = egui::Rect::from_min_size(egui::pos2(x, rect.top()), vec2(*w, row_h));
|
||
let text = rows[ri].get(ci).cloned().unwrap_or_default();
|
||
let shown = fit_text(ui, &text, w - 16.0, &font);
|
||
let col = if header { p.text } else { p.text2 };
|
||
ui.painter().with_clip_rect(cell).text(cell.left_center() + vec2(8.0, 0.0), egui::Align2::LEFT_CENTER, shown, font.clone(), col);
|
||
ui.painter().vline(cell.right(), cell.y_range(), line);
|
||
if resp.hovered() && cell.contains(ui.ctx().pointer_hover_pos().unwrap_or_default()) && !text.is_empty() {
|
||
hovered_cell = Some(text);
|
||
}
|
||
x += w;
|
||
}
|
||
ui.painter().hline(rect.x_range(), rect.bottom(), line);
|
||
ui.painter().vline(nr.right(), nr.y_range(), line);
|
||
if let Some(full) = hovered_cell {
|
||
resp.on_hover_text(full);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
fn fit_text(ui: &egui::Ui, s: &str, max_w: f32, font: &egui::FontId) -> String {
|
||
if ui.painter().layout_no_wrap(s.to_string(), font.clone(), Color32::WHITE).size().x <= max_w {
|
||
return s.to_string();
|
||
}
|
||
let chars: Vec<char> = s.chars().collect();
|
||
let mut n = chars.len();
|
||
while n > 1 {
|
||
n -= 1;
|
||
let c: String = chars[..n].iter().collect::<String>() + "…";
|
||
if ui.painter().layout_no_wrap(c.clone(), font.clone(), Color32::WHITE).size().x <= max_w {
|
||
return c;
|
||
}
|
||
}
|
||
"…".into()
|
||
}
|
||
|
||
/// "orders_20261102_packa… .xlsx": keep the extension like the original.
|
||
fn fit_name(ui: &egui::Ui, name: &str, max_w: f32) -> String {
|
||
let font = egui::FontId::proportional(14.0);
|
||
if ui.painter().layout_no_wrap(name.to_string(), font.clone(), Color32::WHITE).size().x <= max_w {
|
||
return name.to_string();
|
||
}
|
||
let (stem, ext) = name.rsplit_once('.').map(|(a, b)| (a.to_string(), format!(" .{b}"))).unwrap_or((name.to_string(), String::new()));
|
||
let chars: Vec<char> = stem.chars().collect();
|
||
let mut n = chars.len();
|
||
while n > 1 {
|
||
n -= 1;
|
||
let c = chars[..n].iter().collect::<String>() + "…" + &ext;
|
||
if ui.painter().layout_no_wrap(c.clone(), font.clone(), Color32::WHITE).size().x <= max_w {
|
||
return c;
|
||
}
|
||
}
|
||
name.to_string()
|
||
}
|
||
|
||
/// The card's icon: the file kind's Lucide icon on a soft tile of the kind's colour
|
||
/// (spreadsheets green, Markdown purple, web pages orange, PDF red, documents blue).
|
||
fn big_file_icon(painter: &egui::Painter, r: egui::Rect, name: &str, p: Palette) {
|
||
let col = match preview::kind_of(name) {
|
||
"sheet" => Color32::from_rgb(0x1f, 0xb3, 0x5d),
|
||
"markdown" => Color32::from_rgb(0x8b, 0x5c, 0xf6),
|
||
"html" => Color32::from_rgb(0xf9, 0x73, 0x16),
|
||
"pdf" => Color32::from_rgb(0xe5, 0x48, 0x4d),
|
||
"doc" | "docx" => Color32::from_rgb(0x16, 0x80, 0xf3),
|
||
"json" => Color32::from_rgb(0xea, 0xb3, 0x08),
|
||
"image" | "video" | "audio" => Color32::from_rgb(0x0e, 0xa5, 0xe9),
|
||
_ => p.text2,
|
||
};
|
||
let tile = egui::Rect::from_center_size(r.center(), vec2(40.0, 40.0));
|
||
painter.rect_filled(tile, 10, col.gamma_multiply(0.16));
|
||
crate::icons::paint(painter, egui::Rect::from_center_size(tile.center(), vec2(22.0, 22.0)), crate::icons::for_file(name), col);
|
||
}
|