316 lines
10 KiB
Rust
316 lines
10 KiB
Rust
use std::{
|
|
cell::RefCell,
|
|
path::{Path, PathBuf},
|
|
rc::Rc,
|
|
};
|
|
|
|
use gtk::{
|
|
glib, Application, ApplicationWindow, Box, Button, FileChooserAction, FileChooserDialog,
|
|
HeaderBar, Label, Orientation, Picture, ResponseType,
|
|
};
|
|
use log::debug;
|
|
|
|
use crate::cache::{self, SyncCacheCommandSender};
|
|
use glib::clone;
|
|
use gtk::prelude::*;
|
|
|
|
pub struct Ui {
|
|
window: ApplicationWindow,
|
|
bottom_bar: gtk::Box,
|
|
header_bar: gtk::HeaderBar,
|
|
page_indicator: gtk::Label,
|
|
pub app_wrapper: Box,
|
|
pub image_container: Box,
|
|
pub image_left: Picture,
|
|
pub image_right: Picture,
|
|
pub document_canvas: Option<DocumentCanvas>,
|
|
}
|
|
|
|
pub struct DocumentCanvas {
|
|
current_page_number: usize,
|
|
pub num_pages: Option<usize>,
|
|
page_cache_sender: SyncCacheCommandSender,
|
|
}
|
|
|
|
impl DocumentCanvas {
|
|
pub fn new(page_cache_sender: SyncCacheCommandSender) -> Self {
|
|
DocumentCanvas {
|
|
current_page_number: 0,
|
|
num_pages: None,
|
|
page_cache_sender,
|
|
}
|
|
}
|
|
|
|
pub fn increase_page_number(&mut self) {
|
|
if self.current_page_number >= self.num_pages.unwrap_or(0).saturating_sub(2) {
|
|
return;
|
|
}
|
|
|
|
self.current_page_number += 1;
|
|
}
|
|
|
|
pub fn decrease_page_number(&mut self) {
|
|
self.current_page_number = self.current_page_number.saturating_sub(1);
|
|
}
|
|
|
|
pub fn cache_initial_pages(&self, area_height: i32) {
|
|
self.page_cache_sender.send_cache_commands(
|
|
&vec![self.current_page_number, self.current_page_number + 1],
|
|
area_height,
|
|
);
|
|
}
|
|
|
|
pub fn cache_surrounding_pages(&self, area_height: i32) {
|
|
self.page_cache_sender.send_cache_commands(
|
|
&vec![
|
|
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,
|
|
],
|
|
area_height,
|
|
);
|
|
}
|
|
|
|
pub fn request_to_draw_pages(&self) {
|
|
if self.num_pages == Some(1) {
|
|
self.page_cache_sender.send_retrieve_command(
|
|
cache::RetrievePagesCommand::GetCurrentPage {
|
|
page_number: self.current_page_number,
|
|
},
|
|
)
|
|
} else {
|
|
self.page_cache_sender.send_retrieve_command(
|
|
cache::RetrievePagesCommand::GetCurrentTwoPages {
|
|
page_left_number: self.current_page_number,
|
|
},
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn toggle_fullscreen(ui: &Ui) {
|
|
match !ui.window.is_fullscreen() {
|
|
true => {
|
|
ui.header_bar.hide();
|
|
ui.bottom_bar.hide();
|
|
ui.window.fullscreen();
|
|
}
|
|
false => {
|
|
ui.header_bar.show();
|
|
ui.bottom_bar.show();
|
|
ui.window.unfullscreen();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_page_status(ui: &Ui) {
|
|
let page_status = match &ui.document_canvas {
|
|
Some(doc) => {
|
|
doc.request_to_draw_pages();
|
|
|
|
if doc.num_pages.unwrap_or(0) == 1 {
|
|
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.unwrap_or(0)
|
|
)
|
|
}
|
|
}
|
|
None => "No document loaded!".to_string(),
|
|
};
|
|
ui.page_indicator.set_label(page_status.as_str());
|
|
}
|
|
|
|
fn process_right_click(ui: &mut Ui, _x: f64, _y: f64) {
|
|
if ui.document_canvas.is_none() {
|
|
return;
|
|
}
|
|
|
|
ui.document_canvas.as_mut().unwrap().decrease_page_number();
|
|
update_page_status(ui);
|
|
}
|
|
|
|
fn process_left_click(ui: &mut Ui, x: f64, y: f64) {
|
|
if ui.document_canvas.is_none() {
|
|
return;
|
|
}
|
|
|
|
let center = ui.app_wrapper.width() / 2;
|
|
if y < (ui.app_wrapper.height() / 5) as f64 {
|
|
toggle_fullscreen(ui);
|
|
} else if x > center as f64 {
|
|
if x < ui.app_wrapper.width() as f64 * 0.75 {
|
|
ui.document_canvas.as_mut().unwrap().increase_page_number();
|
|
} else {
|
|
ui.document_canvas.as_mut().unwrap().increase_page_number();
|
|
ui.document_canvas.as_mut().unwrap().increase_page_number();
|
|
}
|
|
} else if x < center as f64 {
|
|
if x > ui.app_wrapper.width() as f64 * 0.25 {
|
|
ui.document_canvas.as_mut().unwrap().decrease_page_number();
|
|
} else {
|
|
ui.document_canvas.as_mut().unwrap().decrease_page_number();
|
|
ui.document_canvas.as_mut().unwrap().decrease_page_number();
|
|
}
|
|
}
|
|
update_page_status(ui);
|
|
}
|
|
|
|
impl Ui {
|
|
pub fn build(app: &Application) -> Rc<RefCell<Ui>> {
|
|
debug!("building ui");
|
|
let open_file_button = Button::from_icon_name("document-open");
|
|
|
|
let app_wrapper = Box::builder().orientation(Orientation::Vertical).build();
|
|
let window = ApplicationWindow::builder()
|
|
.application(app)
|
|
.title("Music Reader")
|
|
.child(&app_wrapper)
|
|
.maximized(true)
|
|
.width_request(600)
|
|
.height_request(400)
|
|
.build();
|
|
|
|
let image_container = Box::builder()
|
|
.spacing(0)
|
|
// .width_request(600)
|
|
// .height_request(300)
|
|
.vexpand(true)
|
|
.hexpand(true)
|
|
.halign(gtk::Align::Center)
|
|
.build();
|
|
let image_left = Picture::builder()
|
|
// .width_request(300)
|
|
// .height_request(300)
|
|
.vexpand(true)
|
|
// .hexpand(true)
|
|
.build();
|
|
let image_right = Picture::builder()
|
|
// .width_request(300)
|
|
// .height_request(300)
|
|
.vexpand(true)
|
|
// .hexpand(true)
|
|
.build();
|
|
image_container.append(&image_left);
|
|
image_container.append(&image_right);
|
|
|
|
let ui = Ui {
|
|
window,
|
|
app_wrapper,
|
|
bottom_bar: Box::builder().hexpand_set(true).build(),
|
|
header_bar: HeaderBar::builder().build(),
|
|
page_indicator: Label::builder().build(),
|
|
image_container,
|
|
image_left,
|
|
image_right,
|
|
document_canvas: None,
|
|
};
|
|
let ui = Rc::new(RefCell::new(ui));
|
|
|
|
ui.borrow().header_bar.pack_start(&open_file_button);
|
|
ui.borrow()
|
|
.app_wrapper
|
|
.prepend(&ui.borrow().image_container);
|
|
ui.borrow().app_wrapper.append(&ui.borrow().bottom_bar);
|
|
ui.borrow().bottom_bar.append(&ui.borrow().page_indicator);
|
|
|
|
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 = 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().app_wrapper.add_controller(click_left);
|
|
ui.borrow().app_wrapper.add_controller(click_right);
|
|
|
|
ui.borrow()
|
|
.window
|
|
.set_titlebar(Some(&ui.borrow().header_bar));
|
|
|
|
open_file_button.connect_clicked(
|
|
glib::clone!(@strong ui => @default-panic, move |_button| {
|
|
choose_file(Rc::clone(&ui), &ui.borrow().window);
|
|
}),
|
|
);
|
|
|
|
ui.borrow().window.present();
|
|
ui
|
|
}
|
|
}
|
|
|
|
fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
|
|
let filechooser = FileChooserDialog::builder()
|
|
.title("Choose a PDF...")
|
|
.action(FileChooserAction::Open)
|
|
.modal(true)
|
|
.build();
|
|
filechooser.add_button("_Cancel", ResponseType::Cancel);
|
|
filechooser.add_button("_Open", ResponseType::Accept);
|
|
filechooser.set_transient_for(Some(window));
|
|
filechooser.connect_response(move |d, response| {
|
|
if response == ResponseType::Accept {
|
|
let path = d.file().unwrap().path().unwrap();
|
|
load_document(path, Rc::clone(&ui));
|
|
}
|
|
d.destroy();
|
|
});
|
|
filechooser.show()
|
|
}
|
|
|
|
pub fn load_document(file: impl AsRef<Path>, ui: Rc<RefCell<Ui>>) {
|
|
debug!("Loading file...");
|
|
// TODO: catch errors, maybe show error dialog
|
|
let path: PathBuf = file.as_ref().to_path_buf();
|
|
let uri = format!("file://{}", path.to_str().unwrap());
|
|
let document = poppler::Document::from_file(&uri, None).unwrap();
|
|
let num_pages = document.n_pages() as usize;
|
|
|
|
let sender = cache::spawn_sync_cache(
|
|
document,
|
|
clone!(@weak ui => move |cache_response| match cache_response {
|
|
cache::CacheResponse::SinglePageRetrieved { page } => {
|
|
ui.borrow_mut().image_left.set_paintable(Some(page.as_ref()));
|
|
ui.borrow_mut().image_right.set_visible(false);
|
|
let area_height = ui.borrow().image_left.height();
|
|
ui.borrow().document_canvas.as_ref().unwrap().cache_surrounding_pages(area_height);
|
|
}
|
|
cache::CacheResponse::TwoPagesRetrieved {
|
|
page_left,
|
|
page_right,
|
|
} => {
|
|
ui.borrow_mut().image_left.set_paintable(Some(page_left.as_ref()));
|
|
ui.borrow_mut().image_right.set_paintable(Some(page_right.as_ref()));
|
|
ui.borrow_mut().image_right.set_visible(true);
|
|
let area_height = ui.borrow().image_left.height();
|
|
ui.borrow().document_canvas.as_ref().unwrap().cache_surrounding_pages(area_height);
|
|
debug!("Image size: {}, {}", ui.borrow().image_left.width(), ui.borrow().image_left.height());
|
|
}
|
|
}),
|
|
);
|
|
|
|
let mut document_canvas = DocumentCanvas::new(sender);
|
|
document_canvas.num_pages = Some(num_pages);
|
|
document_canvas.cache_initial_pages(ui.borrow().image_left.height());
|
|
|
|
ui.borrow_mut().document_canvas = Some(document_canvas);
|
|
|
|
update_page_status(&ui.borrow());
|
|
debug!("finished loading document");
|
|
}
|