Tried implementing real async loading, using libpdfium instead of libpoppler

pdfium does not find library yet.
Major clean up needed

Cargo.toml

@@ -5,9 +5,11 @@ edition = "2021"
 
 [dependencies]
 poppler-rs = "0.22"
-cairo-rs = "0.18.2"
+cairo-rs = "0.18.3"
-glib-macros = "0.18.2"
+glib-macros = "0.18.3"
-gio = "0.18.2"
+gio = "0.18.3"
-glib = "0.18.2"
+glib = "0.18.3"
-gtk4 = "0.7.3"
 clap = { version = "4.4.6", features = ["derive"] }
+gtk = { version = "0.7.3", package = "gtk4", features = ["v4_8"] }
+async-channel = "2.1.0"
+pdfium-render = "0.8.15"

flake.nix

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

src/cache.rs

@@ -0,0 +1,159 @@
+use glib::Bytes;
+use gtk::gdk::Texture;
+use pdfium_render::{pdfium, prelude::*};
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex},
+};
+
+use async_channel::{Receiver, Sender};
+
+type PageNumber = usize;
+
+pub struct PageCache<'a> {
+    document: PdfDocument<'a>,
+    render_config: PdfRenderConfig,
+    max_num_stored_pages: usize,
+    pages: BTreeMap<usize, Arc<Texture>>,
+}
+
+impl<'a> PageCache<'a> {
+    pub fn new(
+        document: PdfDocument<'a>,
+        render_config: PdfRenderConfig,
+        max_num_stored_pages: usize,
+    ) -> Self {
+        PageCache {
+            document,
+            render_config,
+            max_num_stored_pages,
+            pages: BTreeMap::new(),
+        }
+    }
+
+    pub fn get_page(&self, page_number: usize) -> Option<Arc<Texture>> {
+        self.pages.get(&page_number).map(Arc::clone)
+    }
+
+    pub fn cache_pages(&mut self, page_numbers: Vec<usize>) {
+        for page_number in page_numbers {
+            if self.pages.contains_key(&page_number) {
+                continue;
+            }
+
+            let page = self.document.pages().get(page_number as u16).unwrap();
+            let image = page.render_with_config(&self.render_config).unwrap();
+
+            // TODO: does this clone?
+            let bytes = Bytes::from(image.as_bytes());
+            let page = Texture::from_bytes(&bytes).unwrap();
+            // let page = self.document.page(page_number as i32);
+            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);
+            }
+        }
+    }
+
+    fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> {
+        let (min_cached_page_number, min_cached_page) = self.pages.pop_first().ok_or(())?;
+        let (max_cached_page_number, max_cached_page) = self.pages.pop_last().ok_or(())?;
+
+        if current_page_number.abs_diff(min_cached_page_number)
+            > current_page_number.abs_diff(max_cached_page_number)
+        {
+            self.pages.insert(max_cached_page_number, max_cached_page);
+        } else {
+            self.pages.insert(min_cached_page_number, min_cached_page);
+        }
+
+        Ok(())
+    }
+
+    fn process_command(&mut self, command: CacheCommand) -> Option<CacheResponse> {
+        match command {
+            CacheCommand::CachePages { pages } => {
+                self.cache_pages(pages);
+                None
+            }
+            CacheCommand::GetCurrentTwoPages { page_left_number } => {
+                let page_left = self
+                    .get_page(page_left_number)
+                    .expect("Requested page was not cached!!!");
+
+                if let Some(page_right) = self.get_page(page_left_number + 1) {
+                    Some(CacheResponse::TwoPagesLoaded {
+                        page_left,
+                        page_right,
+                    })
+                } else {
+                    Some(CacheResponse::SinglePageLoaded { page: page_left })
+                }
+            }
+        }
+    }
+}
+
+pub enum CacheCommand {
+    CachePages { pages: Vec<PageNumber> },
+    GetCurrentTwoPages { page_left_number: PageNumber },
+}
+
+pub enum CacheResponse {
+    DocumentLoaded {
+        num_pages: usize,
+    },
+    SinglePageLoaded {
+        page: Arc<Texture>,
+    },
+    TwoPagesLoaded {
+        page_left: Arc<Texture>,
+        page_right: Arc<Texture>,
+    },
+}
+
+pub fn spawn_async_cache(
+    file: impl AsRef<Path>,
+) -> (Sender<CacheCommand>, Receiver<CacheResponse>) {
+    let (command_sender, command_receiver) = async_channel::unbounded();
+    let (response_sender, response_receiver) = async_channel::unbounded();
+
+    let path: PathBuf = file.as_ref().to_path_buf();
+
+    std::thread::spawn(move || {
+        // Load pdf document here since Document is not thread safe and cannot be passed from main thread
+        let pdfium = Pdfium::default();
+
+        let document = pdfium.load_pdf_from_file(&path, None).unwrap();
+        let render_config = PdfRenderConfig::new()
+            .set_target_width(2000)
+            .set_maximum_height(2000)
+            .rotate_if_landscape(PdfPageRenderRotation::Degrees90, true);
+        let num_pages = document.pages().iter().count();
+
+        // let document = poppler::Document::from_file(&uri, None).unwrap();
+        // let num_pages = document.n_pages() as usize;
+        response_sender.send(CacheResponse::DocumentLoaded { num_pages });
+
+        let mut cache = PageCache::new(document, render_config, 10);
+
+        loop {
+            if let Ok(command) = command_receiver.recv_blocking() {
+                // if !command_receiver.is_empty() {
+                //     // ignore command if more up to date ones are available
+                //     continue;
+                // }
+                if let Some(response) = cache.process_command(command) {
+                    response_sender.send_blocking(response);
+                }
+            } else {
+                // Sender was closed, cache not needed anymore
+                break;
+            }
+        }
+    });
+
+    (command_sender, response_receiver)
+}

src/main.rs

@@ -1,8 +1,9 @@
+mod cache;
 mod ui;
 
 use clap::Parser;
-use gtk4::prelude::*;
+use gtk::prelude::*;
-use gtk4::Application;
+use gtk::Application;
 use std::cell::RefCell;
 use std::path::PathBuf;
 use std::rc::Rc;

src/ui.rs

@@ -1,108 +1,46 @@
 use std::{cell::RefCell, collections::BTreeMap, path::Path, rc::Rc, thread, time::Duration};
 
+use async_channel::Sender;
 use cairo::{Context, Format, ImageSurface};
-use gtk4::{
+use gtk::{
-    prelude::*, Application, ApplicationWindow, Box, Button, DrawingArea, FileChooserAction,
+    gdk::Paintable, gio, glib, prelude::*, Application, ApplicationWindow, Box, Button,
-    FileChooserDialog, HeaderBar, Label, Orientation, ResponseType,
+    DrawingArea, FileChooserAction, FileChooserDialog, HeaderBar, Label, Orientation, Picture,
+    ResponseType,
 };
 use poppler::{Document, Page};
 
+use crate::cache::{self, CacheCommand, PageCache};
+use glib::clone;
+use gtk::prelude::*;
+
 pub struct Ui {
     window: ApplicationWindow,
-    bottom_bar: gtk4::Box,
+    bottom_bar: gtk::Box,
-    header_bar: gtk4::HeaderBar,
+    header_bar: gtk::HeaderBar,
-    page_indicator: gtk4::Label,
+    page_indicator: gtk::Label,
-    drawing_area: gtk4::DrawingArea,
+    drawing_area: gtk::DrawingArea,
+    picture: Picture,
     drawing_context: cairo::Context,
     document_canvas: Option<DocumentCanvas>,
 }
 
-pub struct PageCache {
-    max_num_pages: usize,
-    first_page_number: usize,
-    pages: BTreeMap<usize, Rc<Page>>,
-}
-
-impl PageCache {
-    pub fn new(max_num_pages: usize) -> Self {
-        PageCache {
-            max_num_pages,
-            first_page_number: 0,
-            pages: BTreeMap::new(),
-        }
-    }
-
-    pub fn get_page(&self, page_number: usize) -> Option<Rc<Page>> {
-        let index = page_number - self.first_page_number;
-        self.pages.get(&index).map(Rc::clone)
-    }
-
-    pub fn cache_pages(
-        &mut self,
-        current_page_number: usize,
-        page_numbers: Vec<usize>,
-        document: &Document,
-    ) {
-        for page_number in page_numbers {
-            if self.pages.contains_key(&page_number) {
-                continue;
-            }
-
-            let page = document.page(page_number as i32);
-            if let Some(page) = page {
-                self.pages.insert(page_number, Rc::new(page));
-
-                if self.pages.len() > self.max_num_pages && self.pages.len() > 2 {
-                    let _result = self.remove_most_distant_page(current_page_number);
-                }
-            }
-        }
-    }
-
-    fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> {
-        let (min_cached_page_number, min_cached_page) = self.pages.pop_first().ok_or(())?;
-        let (max_cached_page_number, max_cached_page) = self.pages.pop_last().ok_or(())?;
-
-        if current_page_number.abs_diff(min_cached_page_number)
-            > current_page_number.abs_diff(max_cached_page_number)
-        {
-            self.pages.insert(max_cached_page_number, max_cached_page);
-        } else {
-            self.pages.insert(min_cached_page_number, min_cached_page);
-        }
-
-        Ok(())
-    }
-}
-
 pub struct DocumentCanvas {
-    document: Document,
     current_page_number: usize,
-    num_pages: usize,
+    num_pages: Option<usize>,
-    page_cache: PageCache,
+    page_cache_sender: Sender<CacheCommand>,
 }
 
 impl DocumentCanvas {
-    pub fn new(document: poppler::Document, max_num_cached_pages: usize) -> Self {
+    pub fn new(page_cache_sender: Sender<CacheCommand>) -> Self {
-        let num_pages = document.n_pages() as usize;
         DocumentCanvas {
-            document,
-            num_pages,
             current_page_number: 0,
-            page_cache: PageCache::new(max_num_cached_pages),
+            num_pages: None,
+            page_cache_sender,
         }
     }
 
-    pub fn get_left_page(&self) -> Option<Rc<Page>> {
-        self.page_cache.get_page(self.current_page_number)
-    }
-
-    pub fn get_right_page(&self) -> Option<Rc<Page>> {
-        self.page_cache.get_page(self.current_page_number + 1)
-    }
-
     pub fn increase_page_number(&mut self) {
-        if self.current_page_number >= self.num_pages - 2 {
+        if self.current_page_number >= self.num_pages.unwrap_or(0) - 2 {
             return;
         }
 
@@ -117,33 +55,25 @@ impl DocumentCanvas {
         self.current_page_number -= 1;
     }
 
-    pub fn cache_current_two_pages(&mut self) {
+    pub fn cache_surrounding_pages(&self) {
-        self.page_cache.cache_pages(
+        self.page_cache_sender
-            self.current_page_number,
+            .send_blocking(CacheCommand::CachePages {
-            vec![self.current_page_number, self.current_page_number + 1],
+                pages: vec![
-            &self.document,
+                    self.current_page_number.saturating_sub(2),
-        );
+                    self.current_page_number.saturating_sub(1),
+                    self.current_page_number,
+                    self.current_page_number + 1,
+                    self.current_page_number + 2,
+                    self.current_page_number + 3,
+                ],
+            });
     }
 
-    pub fn cache_surrounding_pages(&mut self) {
+    pub fn request_to_draw_pages(&self) {
-        self.page_cache.cache_pages(
+        self.page_cache_sender
-            self.current_page_number,
+            .send_blocking(CacheCommand::GetCurrentTwoPages {
-            vec![
+                page_left_number: self.current_page_number,
-                self.current_page_number.saturating_sub(2),
+            });
-                self.current_page_number.saturating_sub(1),
-                self.current_page_number + 2,
-                self.current_page_number + 3,
-            ],
-            &self.document,
-        );
-    }
-
-    pub fn cache_all_pages(&mut self) {
-        self.page_cache.cache_pages(
-            self.current_page_number,
-            (0..self.document.n_pages() as usize).collect(),
-            &self.document,
-        );
     }
 }
 
@@ -165,14 +95,18 @@ pub fn toggle_fullscreen(ui: &Ui) {
 fn update_page_status(ui: &Ui) {
     let page_status = match &ui.document_canvas {
         Some(doc) => {
-            if doc.num_pages == 1 {
+            if doc.num_pages.unwrap_or(0) == 1 {
-                format!("{} / {}", doc.current_page_number, doc.num_pages)
+                format!(
+                    "{} / {}",
+                    doc.current_page_number,
+                    doc.num_pages.unwrap_or(0)
+                )
             } else {
                 format!(
                     "{}-{} / {}",
                     doc.current_page_number + 1,
                     doc.current_page_number + 2,
-                    doc.num_pages
+                    doc.num_pages.unwrap_or(0)
                 )
             }
         }
@@ -246,34 +180,43 @@ impl Ui {
                 .hexpand(true)
                 .vexpand(true)
                 .build(),
+            picture: Picture::builder()
+                .width_request(400)
+                .height_request(300)
+                .hexpand(true)
+                .vexpand(true)
+                .build(),
             drawing_context: create_drawing_context(),
             document_canvas: None,
         };
         let ui = Rc::new(RefCell::new(ui));
 
         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.append(&ui.borrow().bottom_bar);
         ui.borrow().bottom_bar.append(&ui.borrow().page_indicator);
 
-        let click_left = gtk4::GestureClick::new();
+        let click_left = gtk::GestureClick::new();
         click_left.set_button(1);
         click_left.connect_pressed(glib::clone!(@weak ui => @default-panic, move |_, _, x, y| {
         process_left_click(&mut ui.borrow_mut(), x, y);
              }));
 
-        let click_right = gtk4::GestureClick::new();
+        let click_right = gtk::GestureClick::new();
         click_right.set_button(3);
         click_right.connect_pressed(glib::clone!(@weak ui => @default-panic, move |_, _, 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_right);
 
         ui.borrow().drawing_area.set_draw_func(
             glib::clone!(@weak ui => move |area, context, _, _| {
-                draw(&mut ui.borrow_mut(), area, context);
+                // draw(&mut ui.borrow_mut(), area, context, sender.clone());
             }),
         );
 
@@ -292,147 +235,148 @@ impl Ui {
     }
 }
 
-fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context) {
+// fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context, sender: Sender<String>) {
-    if ui.document_canvas.is_none() {
+//     if ui.document_canvas.is_none() {
-        return;
+//         return;
-    }
+//     }
-    let document_canvas = ui.document_canvas.as_ref().unwrap();
+//     let document_canvas = ui.document_canvas.as_ref().unwrap();
-    if document_canvas.num_pages > 1 {
+//     if document_canvas.num_pages.unwrap_or(0) > 1 {
-        draw_two_pages(ui, area, context);
+//         draw_two_pages(ui, area, context);
-    } else {
+//     } else {
-        draw_single_page(ui, area, context);
+//         draw_single_page(ui, area, context);
-    }
+//     }
 
-    // TODO: this makes the draw wait
+//     // gio::spawn_blocking(move || {
-    // ui.document_canvas
+//     //     ui.document_canvas
-    //     .as_mut()
+//     //         .as_mut()
-    //     .unwrap()
+//     //         .unwrap()
-    //     .cache_surrounding_pages();
+//     //         .cache_surrounding_pages();
-}
+//     // });
+// }
 
-fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) {
+// fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) {
-    if ui.document_canvas.is_none() {
+//     if ui.document_canvas.is_none() {
-        return;
+//         return;
-    }
+//     }
-    let document_canvas = ui.document_canvas.as_ref().unwrap();
+//     let document_canvas = ui.document_canvas.as_ref().unwrap();
 
-    let page_left = document_canvas.get_left_page();
+//     let page_left = document_canvas.get_left_page();
-    let page_right = document_canvas.get_right_page();
+//     let page_right = document_canvas.get_right_page();
 
-    if page_left.is_none() || page_right.is_none() {
+//     if page_left.is_none() || page_right.is_none() {
-        // TODO: show error message
+//         // TODO: show error message
-        return;
+//         return;
-    }
+//     }
 
-    let page_left = page_left.unwrap();
+//     let page_left = page_left.unwrap();
-    let page_right = page_right.unwrap();
+//     let page_right = page_right.unwrap();
 
-    // Add white background
+//     // Add white background
-    // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
+//     // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
-    // context.fill().unwrap();
+//     // context.fill().unwrap();
-    // context.paint().unwrap();
+//     // context.paint().unwrap();
 
-    let (w_left, h_left) = page_left.size();
+//     let (w_left, h_left) = page_left.size();
-    let (w_right, h_right) = page_right.size();
+//     let (w_right, h_right) = page_right.size();
 
-    let h_max = f64::max(h_left, h_right);
+//     let h_max = f64::max(h_left, h_right);
-    // Make sure both pages are rendered with the same height
+//     // Make sure both pages are rendered with the same height
-    let w_max = match h_left < h_right {
+//     let w_max = match h_left < h_right {
-        true => w_left * h_right / h_left + w_right,
+//         true => w_left * h_right / h_left + w_right,
-        false => w_left + w_right * h_left / h_right,
+//         false => w_left + w_right * h_left / h_right,
-    };
+//     };
 
-    let h_scale = area.height() as f64 / h_max;
+//     let h_scale = area.height() as f64 / h_max;
-    let w_scale = area.width() as f64 / w_max;
+//     let w_scale = area.width() as f64 / w_max;
-    let scale = f64::min(h_scale, w_scale);
+//     let scale = f64::min(h_scale, w_scale);
-    let h_page = h_max * scale;
+//     let h_page = h_max * scale;
 
-    let scale_left = h_page / h_left;
+//     let scale_left = h_page / h_left;
-    let scale_right = h_page / h_right;
+//     let scale_right = h_page / h_right;
 
-    context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
+//     context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
-    context.save().unwrap();
+//     context.save().unwrap();
-    context.translate(
+//     context.translate(
-        area.width() as f64 / 2.0 - w_left * scale_left,
+//         area.width() as f64 / 2.0 - w_left * scale_left,
-        area.height() as f64 / 2.0 - h_page / 2.0,
+//         area.height() as f64 / 2.0 - h_page / 2.0,
-    );
+//     );
-    // Poppler sometimes crops white border, draw it manually
+//     // Poppler sometimes crops white border, draw it manually
-    context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
+//     context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
-    context.fill().unwrap();
+//     context.fill().unwrap();
-    context.scale(scale_left, scale_left);
+//     context.scale(scale_left, scale_left);
-    page_left.render(context);
+//     page_left.render(context);
 
-    context.restore().unwrap();
+//     context.restore().unwrap();
-    context.translate(
+//     context.translate(
-        area.width() as f64 / 2.0,
+//         area.width() as f64 / 2.0,
-        area.height() as f64 / 2.0 - h_page / 2.0,
+//         area.height() as f64 / 2.0 - h_page / 2.0,
-    );
+//     );
-    // Poppler sometimes crops white border, draw it manually
+//     // Poppler sometimes crops white border, draw it manually
-    context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
+//     context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
-    context.fill().unwrap();
+//     context.fill().unwrap();
-    context.scale(scale_right, scale_right);
+//     context.scale(scale_right, scale_right);
-    page_right.render(context);
+//     page_right.render(context);
 
-    let r = ui.drawing_context.paint();
+//     let r = ui.drawing_context.paint();
-    match r {
+//     match r {
-        Err(v) => println!("Error painting PDF: {v:?}"),
+//         Err(v) => println!("Error painting PDF: {v:?}"),
-        Ok(_v) => {}
+//         Ok(_v) => {}
-    }
+//     }
 
-    ui.drawing_context.show_page().unwrap();
+//     ui.drawing_context.show_page().unwrap();
-}
+// }
-fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) {
+// fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) {
-    if ui.document_canvas.is_none() {
+//     if ui.document_canvas.is_none() {
-        return;
+//         return;
-    }
+//     }
-    let document_canvas = ui.document_canvas.as_ref().unwrap();
+//     let document_canvas = ui.document_canvas.as_ref().unwrap();
 
-    if document_canvas.get_left_page().is_none() {
+//     if document_canvas.get_left_page().is_none() {
-        // TODO: show error message
+//         // TODO: show error message
-        return;
+//         return;
-    }
+//     }
 
-    let page = document_canvas.get_left_page().unwrap();
+//     let page = document_canvas.get_left_page().unwrap();
 
-    // Draw background
+//     // Draw background
-    // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
+//     // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
-    // context.paint().unwrap();
+//     // context.paint().unwrap();
-    // context.fill().expect("uh oh");
+//     // context.fill().expect("uh oh");
-    // context.paint().unwrap();
+//     // context.paint().unwrap();
 
-    let (w, h) = page.size();
+//     let (w, h) = page.size();
 
-    let width_diff = area.width() as f64 / w;
+//     let width_diff = area.width() as f64 / w;
-    let height_diff = area.height() as f64 / h;
+//     let height_diff = area.height() as f64 / h;
-    if width_diff > height_diff {
+//     if width_diff > height_diff {
-        context.translate(
+//         context.translate(
-            (area.width() as f64 - w * height_diff) / 2.0,
+//             (area.width() as f64 - w * height_diff) / 2.0,
-            (area.height() as f64 - h * height_diff) / 2.0,
+//             (area.height() as f64 - h * height_diff) / 2.0,
-        );
+//         );
-        context.scale(height_diff, height_diff);
+//         context.scale(height_diff, height_diff);
-    } else {
+//     } else {
-        context.translate(
+//         context.translate(
-            (area.width() as f64 - w * width_diff) / 2.0,
+//             (area.width() as f64 - w * width_diff) / 2.0,
-            (area.height() as f64 - h * width_diff) / 2.0,
+//             (area.height() as f64 - h * width_diff) / 2.0,
-        );
+//         );
-        context.scale(width_diff, width_diff);
+//         context.scale(width_diff, width_diff);
-    }
+//     }
 
-    // Poppler sometimes crops white border, draw it manually
+//     // Poppler sometimes crops white border, draw it manually
-    context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
+//     context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
-    context.rectangle(0.0, 0.0, w, h);
+//     context.rectangle(0.0, 0.0, w, h);
-    context.fill().unwrap();
+//     context.fill().unwrap();
 
-    page.render(context);
+//     page.render(context);
 
-    let r = ui.drawing_context.paint();
+//     let r = ui.drawing_context.paint();
-    match r {
+//     match r {
-        Err(v) => println!("Error painting PDF: {v:?}"),
+//         Err(v) => println!("Error painting PDF: {v:?}"),
-        Ok(_v) => {}
+//         Ok(_v) => {}
-    }
+//     }
 
-    ui.drawing_context.show_page().unwrap();
+//     ui.drawing_context.show_page().unwrap();
-}
+// }
 
 fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
     let filechooser = FileChooserDialog::builder()
@@ -456,13 +400,25 @@ fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
 pub fn load_document(file: impl AsRef<Path>, ui: Rc<RefCell<Ui>>) {
     println!("Loading file...");
     // 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 mut document_canvas =
-        DocumentCanvas::new(poppler::Document::from_file(&uri, None).unwrap(), 1000);
-    // document_canvas.cache_current_two_pages();
-    document_canvas.cache_all_pages();
 
+    let (sender, receiver) = cache::spawn_async_cache(file);
+    // gtk::spawn
+    glib::spawn_future_local(clone!(@weak ui => async move {
+        while let Ok(cache_response) = receiver.recv().await {
+            match cache_response{
+    cache::CacheResponse::DocumentLoaded { num_pages } => todo!(), //ui.borrow_mut().document_canvas.unwrap().num_pages = Some(num_pages),
+                cache::CacheResponse::SinglePageLoaded { page } => { ui.borrow_mut().picture.set_paintable(Some(page.as_ref()));},
+    cache::CacheResponse::TwoPagesLoaded { page_left, page_right } => todo!(),
+            }
+        }
+    }));
+
+    let document_canvas = DocumentCanvas::new(sender);
+    document_canvas.cache_surrounding_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);
-
-    update_page_status(&ui.borrow());
 }