375 lines
13 KiB
Rust
375 lines
13 KiB
Rust
use eframe::egui;
|
|
use crate::book::Book;
|
|
use crate::style::{StyleProfile, TextAlignment};
|
|
use crate::theme::{self, Theme};
|
|
|
|
pub fn recalculate_pages(book: &mut Book, font_size: f32, line_height: f32, panel_width: f32, panel_height: f32) {
|
|
let char_width = font_size * 0.6;
|
|
let chars_per_line = if char_width > 0.0 {
|
|
(panel_width / char_width).max(1.0) as usize
|
|
} else {
|
|
1
|
|
};
|
|
let lines_per_page = if line_height > 0.0 {
|
|
(panel_height / line_height).max(1.0) as usize
|
|
} else {
|
|
1
|
|
};
|
|
let chars_per_page = chars_per_line * lines_per_page;
|
|
for section in &mut book.sections {
|
|
section.pages = calculate_pages(§ion.content, chars_per_page);
|
|
}
|
|
}
|
|
|
|
pub struct ReaderAction {
|
|
pub go_back: bool,
|
|
pub toggle_theme: bool,
|
|
pub toggle_bookmark: bool,
|
|
pub toggle_kraft_bg: bool,
|
|
pub switch_to_profile: Option<String>,
|
|
pub page_next: bool,
|
|
pub page_prev: bool,
|
|
}
|
|
|
|
pub fn reading_view(
|
|
ui: &mut egui::Ui,
|
|
book: &mut Book,
|
|
current_section: &mut usize,
|
|
current_page: &mut usize,
|
|
sidebar_open: &mut bool,
|
|
style: &mut StyleProfile,
|
|
theme: &Theme,
|
|
use_kraft_bg: bool,
|
|
_file_path: &str,
|
|
profile_names: &[String],
|
|
) -> ReaderAction {
|
|
let mut action = ReaderAction {
|
|
go_back: false,
|
|
toggle_theme: false,
|
|
toggle_bookmark: false,
|
|
toggle_kraft_bg: false,
|
|
switch_to_profile: None,
|
|
page_next: false,
|
|
page_prev: false,
|
|
};
|
|
|
|
let panel_size = ui.available_size();
|
|
recalculate_pages(book, style.font_size, style.line_height(), panel_size.x, panel_size.y);
|
|
|
|
let colors = theme::reader_colors(theme);
|
|
|
|
// --- Sidebar (TOC) ---
|
|
if *sidebar_open {
|
|
egui::SidePanel::left("toc_sidebar")
|
|
.resizable(true)
|
|
.default_width(200.0)
|
|
.show_inside(ui, |ui| {
|
|
ui.heading("目录");
|
|
ui.separator();
|
|
render_toc(ui, &book.toc, current_section, current_page);
|
|
});
|
|
}
|
|
|
|
// --- Top toolbar ---
|
|
egui::TopBottomPanel::top("reader_toolbar")
|
|
.show_inside(ui, |ui| {
|
|
ui.horizontal(|ui| {
|
|
if ui.button("← 返回").on_hover_text("返回书架").clicked() {
|
|
action.go_back = true;
|
|
}
|
|
ui.separator();
|
|
ui.label(&book.title);
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
|
let (theme_icon, theme_hint) = match theme {
|
|
Theme::Dark => ("🌞", "切换到浅色主题"),
|
|
Theme::Light => ("🌙", "切换到夜间主题"),
|
|
Theme::Sepia => ("📜", "切换到棕褐色主题"),
|
|
};
|
|
if ui.button(theme_icon).on_hover_text(theme_hint).clicked() {
|
|
action.toggle_theme = true;
|
|
}
|
|
if ui.button("🔖").on_hover_text("添加/移除书签").clicked() {
|
|
action.toggle_bookmark = true;
|
|
}
|
|
if ui.button("A⁻").on_hover_text("缩小字体").clicked() {
|
|
style.font_size = (style.font_size - 2.0).max(10.0);
|
|
}
|
|
if ui.button("A⁺").on_hover_text("放大字体").clicked() {
|
|
style.font_size = (style.font_size + 2.0).min(48.0);
|
|
}
|
|
egui::ComboBox::from_id_salt("profile_selector")
|
|
.width(110.0)
|
|
.selected_text(&style.name)
|
|
.show_ui(ui, |ui| {
|
|
for name in profile_names {
|
|
let selected = *name == style.name;
|
|
if ui.selectable_label(selected, name).clicked() {
|
|
action.switch_to_profile = Some(name.clone());
|
|
}
|
|
}
|
|
});
|
|
let kraft_icon = if use_kraft_bg { "📄" } else { "📋" };
|
|
if ui.button(kraft_icon).on_hover_text("牛皮纸背景").clicked() {
|
|
action.toggle_kraft_bg = true;
|
|
}
|
|
if ui.button("☰").on_hover_text("打开/关闭目录").clicked() {
|
|
*sidebar_open = !*sidebar_open;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
// --- Bottom progress bar ---
|
|
let total_pages = if *current_section < book.sections.len() {
|
|
let p = &book.sections[*current_section].pages;
|
|
if p.len() > 1 { p.len() - 1 } else { 0 }
|
|
} else { 0 };
|
|
|
|
egui::TopBottomPanel::bottom("reader_progress")
|
|
.show_inside(ui, |ui| {
|
|
ui.horizontal(|ui| {
|
|
let section_title = book.sections.get(*current_section)
|
|
.map(|s| s.title.as_str())
|
|
.unwrap_or("");
|
|
ui.label(section_title);
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
|
// Page turn buttons (right side of bottom bar)
|
|
let prev_enabled = *current_page > 0 || *current_section > 0;
|
|
let next_enabled = (*current_page + 1 < book.sections[*current_section]
|
|
.pages.len().saturating_sub(1))
|
|
|| (*current_section + 1 < book.sections.len());
|
|
|
|
let next_btn = egui::Button::new(
|
|
egui::RichText::new("下一页 ▶").size(13.0)
|
|
).min_size(egui::vec2(100.0, 28.0));
|
|
|
|
let prev_btn = egui::Button::new(
|
|
egui::RichText::new("◀ 上一页").size(13.0)
|
|
).min_size(egui::vec2(100.0, 28.0));
|
|
|
|
if !next_enabled {
|
|
ui.add_enabled(false, next_btn);
|
|
} else if ui.add(next_btn).on_hover_text("下一页 (→键)").clicked() {
|
|
action.page_next = true;
|
|
}
|
|
|
|
ui.add_space(8.0);
|
|
|
|
if !prev_enabled {
|
|
ui.add_enabled(false, prev_btn);
|
|
} else if ui.add(prev_btn).on_hover_text("上一页 (←键)").clicked() {
|
|
action.page_prev = true;
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
let label = if total_pages > 0 {
|
|
format!("{}/{}", *current_page + 1, total_pages)
|
|
} else {
|
|
"1/1".to_string()
|
|
};
|
|
ui.label(label);
|
|
let mut progress = if total_pages > 0 {
|
|
*current_page as f32 / total_pages as f32
|
|
} else { 0.0 };
|
|
if ui.add(egui::Slider::new(&mut progress, 0.0..=1.0).text("")).changed() && total_pages > 0 {
|
|
*current_page = (progress * total_pages as f32).round() as usize;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
// --- Center text area ---
|
|
egui::CentralPanel::default().show_inside(ui, |ui| {
|
|
let available = ui.available_size();
|
|
let (rect, response) = ui.allocate_at_least(available, egui::Sense::click());
|
|
|
|
// Add reading margins (inset)
|
|
let inset = 24.0;
|
|
let text_rect = egui::Rect::from_min_size(
|
|
egui::pos2(rect.min.x + inset, rect.min.y),
|
|
egui::vec2((rect.width() - inset * 2.0).max(100.0), rect.height()),
|
|
);
|
|
|
|
if let Some(section) = book.sections.get(*current_section) {
|
|
if *current_page < section.pages.len().saturating_sub(1) {
|
|
let start = section.pages[*current_page];
|
|
let end = section.pages[*current_page + 1];
|
|
let raw_text: String = section.content.chars().skip(start).take(end - start).collect();
|
|
let indented = style.apply_to_text(&raw_text);
|
|
|
|
let align = match style.alignment {
|
|
TextAlignment::Left => egui::Align::LEFT,
|
|
TextAlignment::Center => egui::Align::Center,
|
|
TextAlignment::Right => egui::Align::RIGHT,
|
|
};
|
|
ui.allocate_new_ui(egui::UiBuilder::new().max_rect(text_rect), |ui| {
|
|
ui.with_layout(
|
|
egui::Layout::top_down(align).with_main_justify(false),
|
|
|ui| {
|
|
ui.add(
|
|
egui::Label::new(
|
|
egui::RichText::new(&indented)
|
|
.size(style.font_size)
|
|
.color(colors.text)
|
|
).wrap()
|
|
);
|
|
},
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
// Click navigation
|
|
if response.clicked() {
|
|
if let Some(click_pos) = response.interact_pointer_pos() {
|
|
let x_ratio = (click_pos.x - rect.min.x) / rect.width();
|
|
if x_ratio < 0.3 {
|
|
action.page_prev = true;
|
|
} else if x_ratio > 0.7 {
|
|
action.page_next = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Keyboard navigation
|
|
if ui.input(|i| i.key_pressed(egui::Key::ArrowRight)) {
|
|
action.page_next = true;
|
|
}
|
|
if ui.input(|i| i.key_pressed(egui::Key::ArrowLeft)) {
|
|
action.page_prev = true;
|
|
}
|
|
});
|
|
|
|
action
|
|
}
|
|
|
|
fn render_toc(
|
|
ui: &mut egui::Ui,
|
|
entries: &[crate::book::TocEntry],
|
|
current_section: &mut usize,
|
|
current_page: &mut usize,
|
|
) {
|
|
for entry in entries {
|
|
let is_current = entry.section == *current_section;
|
|
let label_text = if is_current {
|
|
egui::RichText::new(&entry.label).color(egui::Color32::YELLOW).strong()
|
|
} else {
|
|
egui::RichText::new(&entry.label)
|
|
};
|
|
let response = ui.add(
|
|
egui::Button::new(label_text)
|
|
.frame(false)
|
|
.wrap()
|
|
);
|
|
if response.clicked() {
|
|
*current_section = entry.section;
|
|
*current_page = 0;
|
|
}
|
|
response.on_hover_text(format!("跳转到: {}", entry.label));
|
|
if !entry.children.is_empty() {
|
|
ui.indent(&entry.label, |ui| {
|
|
render_toc(ui, &entry.children, current_section, current_page);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn calculate_pages(text: &str, chars_per_page: usize) -> Vec<usize> {
|
|
let mut pages = Vec::new();
|
|
pages.push(0);
|
|
|
|
if text.is_empty() || chars_per_page == 0 {
|
|
return pages;
|
|
}
|
|
|
|
let chars: Vec<char> = text.chars().collect();
|
|
let total_chars = chars.len();
|
|
if total_chars <= chars_per_page {
|
|
pages.push(total_chars);
|
|
return pages;
|
|
}
|
|
|
|
let mut pos: usize = 0;
|
|
while pos < total_chars {
|
|
let next = pos + chars_per_page;
|
|
if next >= total_chars {
|
|
pages.push(total_chars);
|
|
break;
|
|
}
|
|
|
|
// Search backward from next for paragraph (\n\n) or line (\n) breaks
|
|
let search_start = pos + chars_per_page / 2;
|
|
let search_end = (next + chars_per_page / 2).min(total_chars);
|
|
let mut split = next;
|
|
|
|
// Prefer double newline (paragraph), then single newline
|
|
let mut found = false;
|
|
for i in (search_start..search_end).rev() {
|
|
if chars[i] == '\n' && i > 0 && chars[i - 1] == '\n' {
|
|
split = i - 1;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if !found {
|
|
for i in (search_start..search_end).rev() {
|
|
if chars[i] == '\n' {
|
|
split = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if split <= pos {
|
|
split = next;
|
|
}
|
|
|
|
pos = split.min(total_chars);
|
|
pages.push(pos);
|
|
}
|
|
|
|
pages
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_pagination_empty() {
|
|
let pages = calculate_pages("", 100);
|
|
assert_eq!(pages, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pagination_shorter_than_page() {
|
|
let pages = calculate_pages("Hello World", 100);
|
|
assert_eq!(pages, vec![0, 11]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pagination_exact_fit() {
|
|
let pages = calculate_pages("ABCD", 4);
|
|
assert_eq!(pages, vec![0, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pagination_multiple_pages() {
|
|
let text = "A".repeat(100);
|
|
let pages = calculate_pages(&text, 30);
|
|
assert_eq!(pages, vec![0, 30, 60, 90, 100]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pagination_single_char() {
|
|
let pages = calculate_pages("A", 1);
|
|
assert_eq!(pages, vec![0, 1]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_pagination_zero_chars_per_page() {
|
|
let pages = calculate_pages("test", 0);
|
|
assert_eq!(pages, vec![0]);
|
|
}
|
|
} |