julian/music-reader
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Managed to make async pdf loading work

Browse Source 
Major clean-up necessary!!!
This commit is contained in:
Julian Mutter 2023-11-21 12:58:12 +01:00
parent d71a2dab66
commit cea989f194
3 changed files with 296 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
flake.nix
View File

@ -17,7 +17,6 @@
pkg-config pkg-config
poppler poppler
wrapGAppsHook wrapGAppsHook
deepin.deepin-pdfium
]; ];
in { in {
defaultPackage = naersk-lib.buildPackage { defaultPackage = naersk-lib.buildPackage {

135
src/cache.rs
View File

@ -1,6 +1,8 @@
use glib::Bytes; use cairo::{Context, Format, ImageSurface, ImageSurfaceData, ImageSurfaceDataOwned};
use gtk::gdk::Texture; use glib::{clone, Bytes};
use gtk::{gdk::Texture, Picture};
use pdfium_render::{pdfium, prelude::*}; use pdfium_render::{pdfium, prelude::*};
use poppler::{Document, Page};
use std::{ use std::{
collections::BTreeMap, collections::BTreeMap,
path::{Path, PathBuf}, path::{Path, PathBuf},
@ -10,51 +12,67 @@ use std::{
use async_channel::{Receiver, Sender}; use async_channel::{Receiver, Sender};
type PageNumber = usize; type PageNumber = usize;
pub type MyPageType = Page;
pub struct PageCache<'a> { pub struct PageCache {
document: PdfDocument<'a>, document: Document,
render_config: PdfRenderConfig, // render_config: PdfRenderConfig,
max_num_stored_pages: usize, max_num_stored_pages: usize,
pages: BTreeMap<usize, Arc<Texture>>, pages: BTreeMap<usize, Arc<MyPageType>>,
} }
impl<'a> PageCache<'a> { impl PageCache {
pub fn new( pub fn new(
document: PdfDocument<'a>, document: Document,
render_config: PdfRenderConfig, // render_config: PdfRenderConfig,
max_num_stored_pages: usize, max_num_stored_pages: usize,
) -> Self { ) -> Self {
PageCache { PageCache {
document, document,
render_config, // render_config,
max_num_stored_pages, max_num_stored_pages,
pages: BTreeMap::new(), pages: BTreeMap::new(),
} }
} }
pub fn get_page(&self, page_number: usize) -> Option<Arc<Texture>> { pub fn get_page(&self, page_number: usize) -> Option<Arc<MyPageType>> {
self.pages.get(&page_number).map(Arc::clone) self.pages.get(&page_number).map(Arc::clone)
} }
pub fn cache_pages(&mut self, page_numbers: Vec<usize>) { pub fn cache_pages(&mut self, page_numbers: Vec<usize>) {
println!("Caching pages {:?}", page_numbers);
for page_number in page_numbers { for page_number in page_numbers {
if self.pages.contains_key(&page_number) { if self.pages.contains_key(&page_number) {
continue; continue;
} }
let page = self.document.pages().get(page_number as u16).unwrap(); // let page = self.document.pages().get(page_number as u16).unwrap();
let image = page.render_with_config(&self.render_config).unwrap(); // let image = page.render_with_config(&self.render_config).unwrap();
// TODO: does this clone? // // TODO: does this clone?
let bytes = Bytes::from(image.as_bytes()); // let bytes = Bytes::from(image.as_bytes());
let page = Texture::from_bytes(&bytes).unwrap(); // let page = Texture::from_bytes(&bytes).unwrap();
// let page = self.document.page(page_number as i32); if let Some(page) = self.document.page(page_number as i32) {
self.pages.insert(page_number, Arc::new(page)); // let image = Picture::new();
if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 { // // poppler.rend
let _result = self.remove_most_distant_page(page_number); // let surface = ImageSurface::create(Format::Rgb24, 10, 10).unwrap();
// let context = Context::new(&surface).unwrap();
// page.render(&context);
// context.paint().expect("Could not paint");
// println!("Surface: {:?}", surface);
// let page = surface;
// let page = surface.take_data().unwrap();
// context.draw
self.pages.insert(page_number, Arc::new(page));
if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 {
let _result = self.remove_most_distant_page(page_number);
}
} }
} }
println!("done caching");
} }
fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> { fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> {
@ -72,30 +90,34 @@ impl<'a> PageCache<'a> {
Ok(()) Ok(())
} }
fn process_command(&mut self, command: CacheCommand) -> Option<CacheResponse> { async fn process_command(&mut self, command: CacheCommand) -> Option<CacheResponse> {
println!("Processing command: {:?}...", command);
match command { match command {
CacheCommand::CachePages { pages } => { CacheCommand::CachePages { pages } => {
self.cache_pages(pages); self.cache_pages(pages);
None None
} }
CacheCommand::GetCurrentTwoPages { page_left_number } => { CacheCommand::GetCurrentTwoPages { page_left_number } => {
let page_left = self if let Some(page_left) = self.get_page(page_left_number) {
.get_page(page_left_number) if let Some(page_right) = self.get_page(page_left_number + 1) {
.expect("Requested page was not cached!!!"); Some(CacheResponse::TwoPagesLoaded {
page_left,
if let Some(page_right) = self.get_page(page_left_number + 1) { page_right,
Some(CacheResponse::TwoPagesLoaded { })
page_left, } else {
page_right, Some(CacheResponse::SinglePageLoaded { page: page_left })
}) }
} else { } else {
Some(CacheResponse::SinglePageLoaded { page: page_left }) // TODO: if page left was not empty, this could be because page turning was too quick.
// In this case, just not rendering the current page is okay, but when no more render requests are available, one would want to wait for the caching
None
} }
} }
} }
} }
} }
#[derive(Debug)]
pub enum CacheCommand { pub enum CacheCommand {
CachePages { pages: Vec<PageNumber> }, CachePages { pages: Vec<PageNumber> },
GetCurrentTwoPages { page_left_number: PageNumber }, GetCurrentTwoPages { page_left_number: PageNumber },
@ -106,47 +128,52 @@ pub enum CacheResponse {
num_pages: usize, num_pages: usize,
}, },
SinglePageLoaded { SinglePageLoaded {
page: Arc<Texture>, page: Arc<MyPageType>,
}, },
TwoPagesLoaded { TwoPagesLoaded {
page_left: Arc<Texture>, page_left: Arc<MyPageType>,
page_right: Arc<Texture>, page_right: Arc<MyPageType>,
}, },
} }
pub fn spawn_async_cache( pub fn spawn_async_cache<F>(file: impl AsRef<Path>, receiver: F) -> Sender<CacheCommand>
file: impl AsRef<Path>, where
) -> (Sender<CacheCommand>, Receiver<CacheResponse>) { F: Fn(CacheResponse) + 'static,
{
let (command_sender, command_receiver) = async_channel::unbounded(); let (command_sender, command_receiver) = async_channel::unbounded();
let (response_sender, response_receiver) = async_channel::unbounded(); // let (response_sender, response_receiver) = async_channel::unbounded();
let path: PathBuf = file.as_ref().to_path_buf(); let path: PathBuf = file.as_ref().to_path_buf();
std::thread::spawn(move || { glib::spawn_future_local(async move {
println!("async loading of document:...");
// Load pdf document here since Document is not thread safe and cannot be passed from main thread // Load pdf document here since Document is not thread safe and cannot be passed from main thread
let pdfium = Pdfium::default(); // let pdfium = Pdfium::default();
let document = pdfium.load_pdf_from_file(&path, None).unwrap(); // let document = pdfium.load_pdf_from_file(&path, None).unwrap();
let render_config = PdfRenderConfig::new() // let render_config = PdfRenderConfig::new()
.set_target_width(2000) // .set_target_width(2000)
.set_maximum_height(2000) // .set_maximum_height(2000)
.rotate_if_landscape(PdfPageRenderRotation::Degrees90, true); // .rotate_if_landscape(PdfPageRenderRotation::Degrees90, true);
let num_pages = document.pages().iter().count(); // let num_pages = document.pages().iter().count();
// let document = poppler::Document::from_file(&uri, None).unwrap(); let uri = format!("file://{}", path.to_str().unwrap());
// let num_pages = document.n_pages() as usize; let document = poppler::Document::from_file(&uri, None).unwrap();
response_sender.send(CacheResponse::DocumentLoaded { num_pages }); let num_pages = document.n_pages() as usize;
receiver(CacheResponse::DocumentLoaded { num_pages });
let mut cache = PageCache::new(document, render_config, 10); let mut cache = PageCache::new(document, 10);
loop { loop {
if let Ok(command) = command_receiver.recv_blocking() { if let Ok(command) = command_receiver.recv().await {
// if !command_receiver.is_empty() { // if !command_receiver.is_empty() {
// // ignore command if more up to date ones are available // // ignore command if more up to date ones are available
// continue; // continue;
// } // }
if let Some(response) = cache.process_command(command) { if let Some(response) = cache.process_command(command).await {
response_sender.send_blocking(response); // response_sender.send_blocking(response).unwrap();
println!("Command processed, activating receiver....");
receiver(response);
} }
} else { } else {
// Sender was closed, cache not needed anymore // Sender was closed, cache not needed anymore
@ -155,5 +182,5 @@ pub fn spawn_async_cache(
} }
}); });
(command_sender, response_receiver) command_sender
} }

365
src/ui.rs
View File

@ -1,15 +1,17 @@
use std::{cell::RefCell, collections::BTreeMap, path::Path, rc::Rc, thread, time::Duration}; use std::{
cell::RefCell, collections::BTreeMap, path::Path, rc::Rc, sync::Arc, thread, time::Duration,
};
use async_channel::Sender; use async_channel::Sender;
use cairo::{Context, Format, ImageSurface}; use cairo::{Context, Format, ImageSurface, ImageSurfaceData, ImageSurfaceDataOwned};
use gtk::{ use gtk::{
gdk::Paintable, gio, glib, prelude::*, Application, ApplicationWindow, Box, Button, gdk::Paintable, gio, glib, prelude::*, subclass::drawing_area, Application, ApplicationWindow,
DrawingArea, FileChooserAction, FileChooserDialog, HeaderBar, Label, Orientation, Picture, Box, Button, DrawingArea, FileChooserAction, FileChooserDialog, HeaderBar, Label, Orientation,
ResponseType, Picture, ResponseType,
}; };
use poppler::{Document, Page}; use poppler::{Document, Page};
use crate::cache::{self, CacheCommand, PageCache}; use crate::cache::{self, CacheCommand, MyPageType, PageCache};
use glib::clone; use glib::clone;
use gtk::prelude::*; use gtk::prelude::*;
@ -28,6 +30,8 @@ pub struct DocumentCanvas {
current_page_number: usize, current_page_number: usize,
num_pages: Option<usize>, num_pages: Option<usize>,
page_cache_sender: Sender<CacheCommand>, page_cache_sender: Sender<CacheCommand>,
left_page: Option<Arc<MyPageType>>,
right_page: Option<Arc<MyPageType>>,
} }
impl DocumentCanvas { impl DocumentCanvas {
@ -36,6 +40,8 @@ impl DocumentCanvas {
current_page_number: 0, current_page_number: 0,
num_pages: None, num_pages: None,
page_cache_sender, page_cache_sender,
left_page: None,
right_page: None,
} }
} }
@ -55,6 +61,14 @@ impl DocumentCanvas {
self.current_page_number -= 1; self.current_page_number -= 1;
} }
pub fn cache_initial_pages(&self) {
self.page_cache_sender
.send_blocking(CacheCommand::CachePages {
pages: vec![self.current_page_number, self.current_page_number + 1],
})
.unwrap();
}
pub fn cache_surrounding_pages(&self) { pub fn cache_surrounding_pages(&self) {
self.page_cache_sender self.page_cache_sender
.send_blocking(CacheCommand::CachePages { .send_blocking(CacheCommand::CachePages {
@ -66,14 +80,16 @@ impl DocumentCanvas {
self.current_page_number + 2, self.current_page_number + 2,
self.current_page_number + 3, self.current_page_number + 3,
], ],
}); })
.unwrap();
} }
pub fn request_to_draw_pages(&self) { pub fn request_to_draw_pages(&self) {
self.page_cache_sender self.page_cache_sender
.send_blocking(CacheCommand::GetCurrentTwoPages { .send_blocking(CacheCommand::GetCurrentTwoPages {
page_left_number: self.current_page_number, page_left_number: self.current_page_number,
}); })
.unwrap();
} }
} }
@ -95,6 +111,8 @@ pub fn toggle_fullscreen(ui: &Ui) {
fn update_page_status(ui: &Ui) { fn update_page_status(ui: &Ui) {
let page_status = match &ui.document_canvas { let page_status = match &ui.document_canvas {
Some(doc) => { Some(doc) => {
doc.request_to_draw_pages();
if doc.num_pages.unwrap_or(0) == 1 { if doc.num_pages.unwrap_or(0) == 1 {
format!( format!(
"{} / {}", "{} / {}",
@ -113,7 +131,6 @@ fn update_page_status(ui: &Ui) {
None => "No document loaded!".to_string(), None => "No document loaded!".to_string(),
}; };
ui.page_indicator.set_label(page_status.as_str()); ui.page_indicator.set_label(page_status.as_str());
ui.drawing_area.queue_draw();
} }
fn process_right_click(ui: &mut Ui, x: f64, y: f64) { fn process_right_click(ui: &mut Ui, x: f64, y: f64) {
@ -192,8 +209,8 @@ impl Ui {
let ui = Rc::new(RefCell::new(ui)); let ui = Rc::new(RefCell::new(ui));
ui.borrow().header_bar.pack_start(&open_file_button); ui.borrow().header_bar.pack_start(&open_file_button);
// app_wrapper.prepend(&ui.borrow().drawing_area); app_wrapper.prepend(&ui.borrow().drawing_area);
app_wrapper.prepend(&ui.borrow().picture); // app_wrapper.prepend(&ui.borrow().picture);
app_wrapper.append(&ui.borrow().bottom_bar); app_wrapper.append(&ui.borrow().bottom_bar);
ui.borrow().bottom_bar.append(&ui.borrow().page_indicator); ui.borrow().bottom_bar.append(&ui.borrow().page_indicator);
@ -209,14 +226,14 @@ impl Ui {
process_right_click(&mut ui.borrow_mut(), x, y); process_right_click(&mut ui.borrow_mut(), x, y);
})); }));
// ui.borrow().drawing_area.add_controller(click_left); ui.borrow().drawing_area.add_controller(click_left);
// ui.borrow().drawing_area.add_controller(click_right); ui.borrow().drawing_area.add_controller(click_right);
ui.borrow().picture.add_controller(click_left); // ui.borrow().picture.add_controller(click_left);
ui.borrow().picture.add_controller(click_right); // ui.borrow().picture.add_controller(click_right);
ui.borrow().drawing_area.set_draw_func( ui.borrow().drawing_area.set_draw_func(
glib::clone!(@weak ui => move |area, context, _, _| { glib::clone!(@weak ui => move |area, context, _, _| {
// draw(&mut ui.borrow_mut(), area, context, sender.clone()); draw(&mut ui.borrow_mut(), area, context);
}), }),
); );
@ -235,148 +252,167 @@ impl Ui {
} }
} }
// fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context, sender: Sender<String>) { fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context) {
// if ui.document_canvas.is_none() { println!("Draw");
// return; if ui.document_canvas.is_none() {
// } return;
// let document_canvas = ui.document_canvas.as_ref().unwrap(); }
// if document_canvas.num_pages.unwrap_or(0) > 1 { let document_canvas = ui.document_canvas.as_ref().unwrap();
// draw_two_pages(ui, area, context);
// } else {
// draw_single_page(ui, area, context);
// }
// // gio::spawn_blocking(move || { // let left_page = document_canvas.left_page.as_ref().unwrap();
// // ui.document_canvas // let left_page = left_page.as_ref();
// // .as_mut()
// // .unwrap()
// // .cache_surrounding_pages();
// // });
// }
// fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) { // let data: Vec<u8> = left_page.into_iter().map(|x| x.to_owned()).collect();
// if ui.document_canvas.is_none() {
// return;
// }
// let document_canvas = ui.document_canvas.as_ref().unwrap();
// let page_left = document_canvas.get_left_page(); // let data: Vec<u8> = page.iter().map(|x| x.clone()).collect();
// let page_right = document_canvas.get_right_page(); // let surface = ImageSurface::create_for_data(data, Format::Rgb24, 0, 0, 0).unwrap();
// if page_left.is_none() || page_right.is_none() { // context.set_source_surface(surface, 0.0, 0.0);
// // TODO: show error message // context.paint();
// return;
// }
// let page_left = page_left.unwrap(); if document_canvas.num_pages.unwrap_or(0) > 1 {
// let page_right = page_right.unwrap(); draw_two_pages(ui, area, context);
} else {
draw_single_page(ui, area, context);
}
// // Add white background // gio::spawn_blocking(move || {
// // context.set_source_rgba(1.0, 1.0, 1.0, 1.0); // ui.document_canvas
// // context.fill().unwrap(); // .as_mut()
// // context.paint().unwrap(); // .unwrap()
// .cache_surrounding_pages();
// });
println!("Finished drawing");
document_canvas.cache_surrounding_pages();
}
// let (w_left, h_left) = page_left.size(); fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) {
// let (w_right, h_right) = page_right.size(); if ui.document_canvas.is_none() {
return;
}
let document_canvas = ui.document_canvas.as_ref().unwrap();
// let h_max = f64::max(h_left, h_right); let page_left = document_canvas.left_page.as_ref();
// // Make sure both pages are rendered with the same height let page_right = document_canvas.right_page.as_ref();
// let w_max = match h_left < h_right {
// true => w_left * h_right / h_left + w_right,
// false => w_left + w_right * h_left / h_right,
// };
// let h_scale = area.height() as f64 / h_max; if page_left.is_none() || page_right.is_none() {
// let w_scale = area.width() as f64 / w_max; // TODO: show error message
// let scale = f64::min(h_scale, w_scale); return;
// let h_page = h_max * scale; }
// let scale_left = h_page / h_left; let page_left = page_left.unwrap();
// let scale_right = h_page / h_right; let page_right = page_right.unwrap();
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0); // Add white background
// context.save().unwrap(); // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// context.translate( // context.fill().unwrap();
// area.width() as f64 / 2.0 - w_left * scale_left, // context.paint().unwrap();
// area.height() as f64 / 2.0 - h_page / 2.0,
// );
// // Poppler sometimes crops white border, draw it manually
// context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
// context.fill().unwrap();
// context.scale(scale_left, scale_left);
// page_left.render(context);
// context.restore().unwrap(); let (w_left, h_left) = page_left.size();
// context.translate( let (w_right, h_right) = page_right.size();
// area.width() as f64 / 2.0,
// area.height() as f64 / 2.0 - h_page / 2.0,
// );
// // Poppler sometimes crops white border, draw it manually
// context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
// context.fill().unwrap();
// context.scale(scale_right, scale_right);
// page_right.render(context);
// let r = ui.drawing_context.paint(); let h_max = f64::max(h_left, h_right);
// match r { // Make sure both pages are rendered with the same height
// Err(v) => println!("Error painting PDF: {v:?}"), let w_max = match h_left < h_right {
// Ok(_v) => {} true => w_left * h_right / h_left + w_right,
// } false => w_left + w_right * h_left / h_right,
};
// ui.drawing_context.show_page().unwrap(); let h_scale = area.height() as f64 / h_max;
// } let w_scale = area.width() as f64 / w_max;
// fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) { let scale = f64::min(h_scale, w_scale);
// if ui.document_canvas.is_none() { let h_page = h_max * scale;
// return;
// }
// let document_canvas = ui.document_canvas.as_ref().unwrap();
// if document_canvas.get_left_page().is_none() { let scale_left = h_page / h_left;
// // TODO: show error message let scale_right = h_page / h_right;
// return;
// }
// let page = document_canvas.get_left_page().unwrap(); context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
context.save().unwrap();
context.translate(
area.width() as f64 / 2.0 - w_left * scale_left,
area.height() as f64 / 2.0 - h_page / 2.0,
);
// Poppler sometimes crops white border, draw it manually
context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
context.fill().unwrap();
context.scale(scale_left, scale_left);
page_left.render(context);
// // Draw background context.restore().unwrap();
// // context.set_source_rgba(1.0, 1.0, 1.0, 1.0); context.translate(
// // context.paint().unwrap(); area.width() as f64 / 2.0,
// // context.fill().expect("uh oh"); area.height() as f64 / 2.0 - h_page / 2.0,
// // context.paint().unwrap(); );
// Poppler sometimes crops white border, draw it manually
context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
context.fill().unwrap();
context.scale(scale_right, scale_right);
page_right.render(context);
// let (w, h) = page.size(); let r = ui.drawing_context.paint();
match r {
Err(v) => println!("Error painting PDF: {v:?}"),
Ok(_v) => {}
}
// let width_diff = area.width() as f64 / w; ui.drawing_context.show_page().unwrap();
// let height_diff = area.height() as f64 / h; }
// if width_diff > height_diff { fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) {
// context.translate( if ui.document_canvas.is_none() {
// (area.width() as f64 - w * height_diff) / 2.0, return;
// (area.height() as f64 - h * height_diff) / 2.0, }
// ); let document_canvas = ui.document_canvas.as_ref().unwrap();
// context.scale(height_diff, height_diff);
// } else {
// context.translate(
// (area.width() as f64 - w * width_diff) / 2.0,
// (area.height() as f64 - h * width_diff) / 2.0,
// );
// context.scale(width_diff, width_diff);
// }
// // Poppler sometimes crops white border, draw it manually if document_canvas.left_page.is_none() {
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0); // TODO: show error message
// context.rectangle(0.0, 0.0, w, h); return;
// context.fill().unwrap(); }
// page.render(context); let page = document_canvas.left_page.as_ref().unwrap();
// let page = ImageSurface::create_for_data(page.into(), Format::Rgb24, 0, 0, 0).unwrap();
// let r = ui.drawing_context.paint(); // context.set_source_surface(page, 0, 0);
// match r { // Draw background
// Err(v) => println!("Error painting PDF: {v:?}"), // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// Ok(_v) => {} // context.paint().unwrap();
// } // context.fill().expect("uh oh");
// context.paint().unwrap();
// ui.drawing_context.show_page().unwrap(); let (w, h) = page.size();
// } // let w = page.width() as f64;
// let h = page.height() as f64;
let width_diff = area.width() as f64 / w;
let height_diff = area.height() as f64 / h;
if width_diff > height_diff {
context.translate(
(area.width() as f64 - w * height_diff) / 2.0,
(area.height() as f64 - h * height_diff) / 2.0,
);
context.scale(height_diff, height_diff);
} else {
context.translate(
(area.width() as f64 - w * width_diff) / 2.0,
(area.height() as f64 - h * width_diff) / 2.0,
);
context.scale(width_diff, width_diff);
}
// Poppler sometimes crops white border, draw it manually
context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
context.rectangle(0.0, 0.0, w, h);
context.fill().unwrap();
page.render(context);
let r = ui.drawing_context.paint();
match r {
Err(v) => println!("Error painting PDF: {v:?}"),
Ok(_v) => {}
}
ui.drawing_context.show_page().unwrap();
}
fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) { fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
let filechooser = FileChooserDialog::builder() let filechooser = FileChooserDialog::builder()
@ -402,23 +438,52 @@ pub fn load_document(file: impl AsRef<Path>, ui: Rc<RefCell<Ui>>) {
// TODO: catch errors, maybe show error dialog // TODO: catch errors, maybe show error dialog
// let uri = format!("file://{}", file.as_ref().to_str().unwrap()); // let uri = format!("file://{}", file.as_ref().to_str().unwrap());
let (sender, receiver) = cache::spawn_async_cache(file); let sender = cache::spawn_async_cache(
// gtk::spawn file,
glib::spawn_future_local(clone!(@weak ui => async move { clone!(@weak ui => move |cache_response| match cache_response {
while let Ok(cache_response) = receiver.recv().await { cache::CacheResponse::DocumentLoaded { num_pages } => {
match cache_response{ ui.borrow_mut().document_canvas.as_mut().unwrap().num_pages = Some(num_pages);
cache::CacheResponse::DocumentLoaded { num_pages } => todo!(), //ui.borrow_mut().document_canvas.unwrap().num_pages = Some(num_pages), update_page_status(&ui.borrow())
cache::CacheResponse::SinglePageLoaded { page } => { ui.borrow_mut().picture.set_paintable(Some(page.as_ref()));},
cache::CacheResponse::TwoPagesLoaded { page_left, page_right } => todo!(),
} }
} cache::CacheResponse::SinglePageLoaded { page } => {
})); ui.borrow_mut().document_canvas.as_mut().unwrap().left_page = Some(page);
ui.borrow_mut().document_canvas.as_mut().unwrap().right_page = None;
ui.borrow().drawing_area.queue_draw();
}
cache::CacheResponse::TwoPagesLoaded {
page_left,
page_right,
} => {
ui.borrow_mut().document_canvas.as_mut().unwrap().left_page = Some(page_left);
ui.borrow_mut().document_canvas.as_mut().unwrap().right_page = Some(page_right);
ui.borrow().drawing_area.queue_draw();
}
}),
);
println!("Spawned async cache");
// // gtk::spawn
// glib::spawn_future_local(clone!(@weak ui => async move {
// println!("Waiting for cache response:...");
// while let Ok(cache_response) = receiver.recv().await {
// match cache_response{
// cache::CacheResponse::DocumentLoaded { num_pages } => {ui.borrow_mut().document_canvas.as_mut().unwrap().num_pages = Some(num_pages); update_page_status(&ui.borrow())},
// cache::CacheResponse::SinglePageLoaded { page } => { ui.borrow_mut().document_canvas.as_mut().unwrap().left_page = Some(page);
// ui.borrow_mut().document_canvas.as_mut().unwrap().right_page = None;
// ui.borrow().drawing_area.queue_draw();
// },
// cache::CacheResponse::TwoPagesLoaded { page_left, page_right } => { ui.borrow_mut().document_canvas.as_mut().unwrap().left_page = Some(page_left);
// ui.borrow_mut().document_canvas.as_mut().unwrap().right_page = Some(page_right);
// ui.borrow().drawing_area.queue_draw();
// }
// }
// }
// }));
let document_canvas = DocumentCanvas::new(sender); let document_canvas = DocumentCanvas::new(sender);
document_canvas.cache_surrounding_pages(); document_canvas.cache_initial_pages();
// document_canvas.cache_all_pages();
// update_page_status(&ui.borrow());
document_canvas.request_to_draw_pages();
ui.borrow_mut().document_canvas = Some(document_canvas); ui.borrow_mut().document_canvas = Some(document_canvas);
update_page_status(&ui.borrow());
println!("finished loading document");
} }