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

Fix clippy warnings

Browse Source
This commit is contained in:
Julian Mutter 2023-11-21 18:22:38 +01:00
parent 874120108b
commit 2ff15bbce0
2 changed files with 28 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/cache.rs
View File

@ -2,7 +2,7 @@ use poppler::{Document, Page};
use std::{ use std::{
collections::BTreeMap, collections::BTreeMap,
path::{Path, PathBuf}, path::{Path, PathBuf},
sync::Arc, rc::Rc,
}; };
use async_channel::Sender; use async_channel::Sender;
@ -13,7 +13,7 @@ pub type MyPageType = Page;
pub struct PageCache { pub struct PageCache {
document: Document, document: Document,
max_num_stored_pages: usize, max_num_stored_pages: usize,
pages: BTreeMap<usize, Arc<MyPageType>>, pages: BTreeMap<usize, Rc<MyPageType>>,
} }
impl PageCache { impl PageCache {
@ -25,8 +25,8 @@ impl PageCache {
} }
} }
pub fn get_page(&self, page_number: usize) -> Option<Arc<MyPageType>> { pub fn get_page(&self, page_number: usize) -> Option<Rc<MyPageType>> {
self.pages.get(&page_number).map(Arc::clone) self.pages.get(&page_number).map(Rc::clone)
} }
pub fn cache_pages(&mut self, page_numbers: Vec<usize>) { pub fn cache_pages(&mut self, page_numbers: Vec<usize>) {
@ -37,7 +37,7 @@ impl PageCache {
} }
if let Some(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)); self.pages.insert(page_number, Rc::new(page));
if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 { if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 {
let _result = self.remove_most_distant_page(page_number); let _result = self.remove_most_distant_page(page_number);
@ -72,12 +72,12 @@ impl PageCache {
CacheCommand::GetCurrentTwoPages { page_left_number } => { CacheCommand::GetCurrentTwoPages { page_left_number } => {
if let Some(page_left) = self.get_page(page_left_number) { if let Some(page_left) = self.get_page(page_left_number) {
if let Some(page_right) = self.get_page(page_left_number + 1) { if let Some(page_right) = self.get_page(page_left_number + 1) {
Some(CacheResponse::TwoPagesLoaded { Some(CacheResponse::TwoPagesRetrieved {
page_left, page_left,
page_right, page_right,
}) })
} else { } else {
Some(CacheResponse::SinglePageLoaded { page: page_left }) Some(CacheResponse::SinglePageRetrieved { page: page_left })
} }
} else { } else {
// TODO: if page left was not empty, this could be because page turning was too quick. // TODO: if page left was not empty, this could be because page turning was too quick.
@ -99,12 +99,12 @@ pub enum CacheResponse {
DocumentLoaded { DocumentLoaded {
num_pages: usize, num_pages: usize,
}, },
SinglePageLoaded { SinglePageRetrieved {
page: Arc<MyPageType>, page: Rc<MyPageType>,
}, },
TwoPagesLoaded { TwoPagesRetrieved {
page_left: Arc<MyPageType>, page_left: Rc<MyPageType>,
page_right: Arc<MyPageType>, page_right: Rc<MyPageType>,
}, },
} }
@ -126,20 +126,15 @@ where
let mut cache = PageCache::new(document, 10); let mut cache = PageCache::new(document, 10);
loop { while let Ok(command) = command_receiver.recv().await {
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).await {
if let Some(response) = cache.process_command(command).await { // response_sender.send_blocking(response).unwrap();
// response_sender.send_blocking(response).unwrap(); println!("Command processed, activating receiver....");
println!("Command processed, activating receiver...."); receiver(response);
receiver(response);
}
} else {
// Sender was closed, cache not needed anymore
break;
} }
} }
}); });

18
src/ui.rs
View File

@ -1,4 +1,4 @@
use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc}; use std::{cell::RefCell, path::Path, rc::Rc};
use async_channel::Sender; use async_channel::Sender;
use cairo::{Context, Format, ImageSurface}; use cairo::{Context, Format, ImageSurface};
@ -28,8 +28,8 @@ pub struct DocumentCanvas {
current_page_number: usize, current_page_number: usize,
pub num_pages: Option<usize>, pub num_pages: Option<usize>,
page_cache_sender: Sender<CacheCommand>, page_cache_sender: Sender<CacheCommand>,
pub left_page: Option<Arc<MyPageType>>, pub left_page: Option<Rc<MyPageType>>,
pub right_page: Option<Arc<MyPageType>>, pub right_page: Option<Rc<MyPageType>>,
} }
impl DocumentCanvas { impl DocumentCanvas {
@ -44,7 +44,7 @@ impl DocumentCanvas {
} }
pub fn increase_page_number(&mut self) { pub fn increase_page_number(&mut self) {
if self.current_page_number >= self.num_pages.unwrap_or(0) - 2 { if self.current_page_number >= self.num_pages.unwrap_or(0).saturating_sub(2) {
return; return;
} }
@ -52,11 +52,7 @@ impl DocumentCanvas {
} }
pub fn decrease_page_number(&mut self) { pub fn decrease_page_number(&mut self) {
if self.current_page_number <= 0 { self.current_page_number = self.current_page_number.saturating_sub(1);
return;
}
self.current_page_number -= 1;
} }
pub fn cache_initial_pages(&self) { pub fn cache_initial_pages(&self) {
@ -271,12 +267,12 @@ pub fn load_document(file: impl AsRef<Path>, ui: Rc<RefCell<Ui>>) {
ui.borrow_mut().document_canvas.as_mut().unwrap().num_pages = Some(num_pages); ui.borrow_mut().document_canvas.as_mut().unwrap().num_pages = Some(num_pages);
update_page_status(&ui.borrow()) update_page_status(&ui.borrow())
} }
cache::CacheResponse::SinglePageLoaded { page } => { cache::CacheResponse::SinglePageRetrieved { page } => {
ui.borrow_mut().document_canvas.as_mut().unwrap().left_page = Some(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_mut().document_canvas.as_mut().unwrap().right_page = None;
ui.borrow().drawing_area.queue_draw(); ui.borrow().drawing_area.queue_draw();
} }
cache::CacheResponse::TwoPagesLoaded { cache::CacheResponse::TwoPagesRetrieved {
page_left, page_left,
page_right, page_right,
} => { } => {