xiaji/epub-read
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
17fbe7efbbe83d273738e47fa95a01597c88a5bf
epub-read/docs/superpowers/plans/2026-05-13-epub-reader.md

1526 lines
43 KiB
Markdown
Raw Normal View History

feat: add create_style function with light/dark theme support
2026-05-13 23:43:02 +08:00
# ePub Reader Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Build a standalone Windows ePub reader with egui, Kindle-like UI, Chinese font support.
**Architecture:** Single-exe Rust application using `eframe` (egui) for UI, `epub` crate for ePub parsing, bundled Noto Sans SC font. App dispatches between Welcome screen and Reading view based on whether a book is open. The `App` struct holds all state; the book is parsed into a plain-text model with pre-computed page offsets.
**Tech Stack:** Rust 1.94+ (x86_64-pc-windows-gnu), eframe 0.31, epub 1.2, rfd 0.15, serde/serde_json, Noto Sans SC font
**Build Env:** MSYS2 MINGW64 terminal (`C:\msys64\mingw64.exe`) — all `cargo` commands must run there.
---
### Task 1: Create project scaffold
**Files:**
- Create: `Cargo.toml`
- Create: `.cargo/config.toml`
- Create: `src/main.rs`
- [ ] **Step 1: Create directory structure**
```bash
mkdir -p epub-read/src epub-read/.cargo
cd epub-read
```
- [ ] **Step 2: Write Cargo.toml**
```toml
[package]
name = "epub-read"
version = "0.1.0"
edition = "2021"
description = "ePub reader with egui"
[[bin]]
name = "epub-read"
path = "src/main.rs"
[dependencies]
eframe = "0.31"
epub = "1.2"
rfd = "0.15"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
strip = "symbols"
```
- [ ] **Step 3: Write .cargo/config.toml for static MinGW linking**
```toml
[target.x86_64-pc-windows-gnu]
rustflags = ["-C", "target-feature=+crt-static"]
```
- [ ] **Step 4: Write src/main.rs**
```rust
#![windows_subsystem = "windows"]
mod app;
mod book;
mod font;
mod persistence;
mod reader;
mod theme;
fn main() -> eframe::Result {
let native_options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_inner_size([900.0, 700.0])
.with_min_inner_size([600.0, 400.0]),
..Default::default()
};
eframe::run_native(
"ePub Reader",
native_options,
Box::new(|cc| {
font::setup_fonts(&cc.egui_ctx);
Ok(Box::new(app::App::new(cc)))
}),
)
}
```
- [ ] **Step 5: Write placeholder module files**
```bash
echo "" > src/app.rs
echo "" > src/book.rs
echo "" > src/font.rs
echo "" > src/persistence.rs
echo "" > src/reader.rs
echo "" > src/theme.rs
```
- [ ] **Step 6: Verify cargo compiles**
Run in MINGW64:
```bash
cd /path/to/epub-read
cargo check
```
Expected: Compilation succeeds (warnings about unused code OK).
---
### Task 2: Define data models
**Files:**
- Create: `src/book.rs` (Book, Section, TocEntry, strip_html + tests)
- Create: `src/theme.rs` (Theme, Settings + tests)
- [ ] **Step 1: Write tests for strip_html**
Append to `src/book.rs`:
```rust
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_strip_html_plain_text() {
assert_eq!(strip_html("Hello World"), "Hello World");
}
#[test]
fn test_strip_html_simple_tags() {
assert_eq!(strip_html("<p>Hello</p>"), "Hello");
}
#[test]
fn test_strip_html_nested_tags() {
assert_eq!(
strip_html("<div><p>Hello <b>World</b></p></div>"),
"Hello World"
);
}
#[test]
fn test_strip_html_html_entities() {
assert_eq!(strip_html("Hello &amp; World"), "Hello & World");
assert_eq!(strip_html("Hello&nbsp;World"), "Hello World");
}
#[test]
fn test_strip_html_empty() {
assert_eq!(strip_html(""), "");
}
}
```
- [ ] **Step 2: Run tests to verify they fail**
```bash
cd /path/to/epub-read
cargo test --lib 2>&1 | head -20
```
Expected: Compile error — `strip_html` not defined.
- [ ] **Step 3: Write strip_html + data models into book.rs**
```rust
pub fn strip_html(input: &str) -> String {
let mut result = String::with_capacity(input.len());
let mut in_tag = false;
let mut in_entity = false;
let mut entity = String::new();
for c in input.chars() {
match c {
'<' => in_tag = true,
'>' if in_tag => in_tag = false,
'&' if !in_tag => {
in_entity = true;
entity.clear();
}
';' if in_entity => {
in_entity = false;
let decoded = match entity.as_str() {
"amp" => "&",
"lt" => "<",
"gt" => ">",
"quot" => "\"",
"nbsp" => " ",
_ => "",
};
result.push_str(decoded);
}
c if !in_tag && !in_entity => result.push(c),
c if in_entity => entity.push(c),
_ => {}
}
}
result
}
#[derive(Debug, Clone)]
pub struct TocEntry {
pub label: String,
pub section: usize,
pub children: Vec<TocEntry>,
}
#[derive(Debug, Clone)]
pub struct Section {
pub title: String,
pub content: String,
pub pages: Vec<usize>,
}
#[derive(Debug, Clone)]
pub struct Book {
pub title: String,
pub author: String,
pub cover: Option<Vec<u8>>,
pub sections: Vec<Section>,
pub toc: Vec<TocEntry>,
}
```
- [ ] **Step 4: Write Theme + Settings into theme.rs**
```rust
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum Theme {
Light,
Dark,
}
impl Default for Theme {
fn default() -> Self {
Theme::Light
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Settings {
pub font_size: f32,
pub theme: Theme,
pub recent_files: Vec<String>,
pub reading_positions: std::collections::HashMap<String, ReadingPosition>,
pub bookmarks: std::collections::HashMap<String, Vec<Bookmark>>,
pub window_size: Option<(f32, f32)>,
}
impl Default for Settings {
fn default() -> Self {
Self {
font_size: 20.0,
theme: Theme::Light,
recent_files: Vec::new(),
reading_positions: std::collections::HashMap::new(),
bookmarks: std::collections::HashMap::new(),
window_size: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReadingPosition {
pub section: usize,
pub page: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Bookmark {
pub section: usize,
pub page: usize,
pub label: String,
pub timestamp: i64,
}
```
Write tests for Settings round-trip into theme.rs:
```rust
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_settings_default() {
let s = Settings::default();
assert_eq!(s.font_size, 20.0);
assert_eq!(s.theme, Theme::Light);
}
#[test]
fn test_settings_round_trip() {
let s = Settings::default();
let json = serde_json::to_string(&s).unwrap();
let restored: Settings = serde_json::from_str(&json).unwrap();
assert_eq!(restored.font_size, s.font_size);
assert_eq!(restored.theme, s.theme);
}
#[test]
fn test_theme_serialize() {
let json = serde_json::to_string(&Theme::Dark).unwrap();
assert_eq!(json, "\"Dark\"");
let restored: Theme = serde_json::from_str(&json).unwrap();
assert_eq!(restored, Theme::Dark);
}
}
```
- [ ] **Step 5: Run tests to verify they pass**
```bash
cargo test
```
Expected: All strip_html tests pass, all Settings/Theme round-trip tests pass.
---
### Task 3: Implement EpubLoader
**Files:**
- Modify: `src/book.rs`
- [ ] **Step 1: Write test for EpubLoader (skips if no sample epub)**
Append to `src/book.rs` tests:
```rust
#[test]
fn test_epub_loader_nonexistent_file() {
let result = load_epub("nonexistent.epub");
assert!(result.is_err());
}
```
- [ ] **Step 2: Run the test to verify it fails**
```bash
cargo test --lib test_epub_loader -- --nocapture
```
Expected: Compile error — `load_epub` not defined.
- [ ] **Step 3: Implement EpubLoader in book.rs**
Add the loader and a public `load_epub` function:
```rust
use std::path::Path;
use std::time::{SystemTime, UNIX_EPOCH};
pub fn load_epub(path: impl AsRef<Path>) -> Result<Book, String> {
let path = path.as_ref();
let mut doc = epub::doc::EpubDoc::new(path)
.map_err(|e| format!("无法打开文件: {}", e))?;
let title = doc.mdata("title").unwrap_or_else(|| "未知标题".to_string());
let author = doc.mdata("creator").unwrap_or_else(|| "未知作者".to_string());
let cover = doc.get_cover().ok();
let spine = doc.spine.clone();
let raw_toc = doc.toc.clone();
let mut sections = Vec::new();
for (i, href) in spine.iter().enumerate() {
let (_, raw_html) = doc.get_resource_str(href)
.map_err(|e| format!("读取章节失败: {}", e))?;
let text = strip_html(&raw_html);
let title = extract_title(&raw_html)
.unwrap_or_else(|| format!("第{}章", i + 1));
sections.push(Section {
title,
content: text,
pages: Vec::new(),
});
}
let toc = build_toc(&raw_toc, &spine);
Ok(Book { title, author, cover, sections, toc })
}
fn extract_title(html: &str) -> Option<String> {
if let Some(start) = html.find("<title>") {
let rest = &html[start + 7..];
if let Some(end) = rest.find("</title>") {
return Some(strip_html(&rest[..end]).trim().to_string());
}
}
if let Some(start) = html.find("<h1") {
let rest = &html[start..];
if let Some(content_start) = rest.find('>') {
let inner = &rest[content_start + 1..];
if let Some(end) = inner.find("</h1>") {
return Some(strip_html(&inner[..end]).trim().to_string());
}
}
}
None
}
fn build_toc(
entries: &[epub::doc::TocEntry],
spine: &[String],
) -> Vec<TocEntry> {
entries
.iter()
.map(|e| {
let section = spine
.iter()
.position(|s| e.content.contains(s.trim_end_matches('/')))
.unwrap_or(0);
TocEntry {
label: e.label.clone(),
section,
children: build_toc(&e.children, spine),
}
})
.collect()
}
```
- [ ] **Step 4: Run tests to verify they pass**
```bash
cargo test
```
Expected: All existing tests pass (new test covers error case only).
---
### Task 4: Implement pagination algorithm
**Files:**
- Modify: `src/reader.rs`
- [ ] **Step 1: Write pagination tests**
```rust
#[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]);
}
}
```
- [ ] **Step 2: Run to verify failure**
```bash
cargo test --lib tests::test_pagination_empty -- --nocapture
```
Expected: Compile error — `calculate_pages` not defined.
- [ ] **Step 3: Implement calculate_pages in reader.rs**
```rust
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 total_chars = text.chars().count();
if total_chars <= chars_per_page {
pages.push(total_chars);
return pages;
}
let mut pos = 0;
while pos < total_chars {
pos = (pos + chars_per_page).min(total_chars);
pages.push(pos);
}
pages
}
```
- [ ] **Step 4: Run tests to verify they pass**
```bash
cargo test
```
Expected: All pagination tests pass.
---
### Task 5: Implement font loading
**Files:**
- Modify: `src/font.rs`
- [ ] **Step 1: Download Noto Sans SC font**
```bash
# Download Noto Sans SC Regular from GitHub
mkdir -p fonts
curl -L -o fonts/NotoSansSC-Regular.ttf \
"https://github.com/googlefonts/noto-cjk/releases/download/Sans2.004/03_NotoSansCJKsc.zip"
```
Note: If the above URL fails, download manually from https://fonts.google.com/download?family=Noto+Sans+SC and place `NotoSansSC-Regular.ttf` in `fonts/`.
- [ ] **Step 2: Implement font.rs**
```rust
use eframe::egui;
pub fn setup_fonts(ctx: &egui::Context) {
let mut fonts = egui::FontDefinitions::default();
// Try to load bundled Chinese font
let font_data = include_bytes!("../fonts/NotoSansSC-Regular.ttf");
fonts.font_data.insert(
"NotoSansSC".to_string(),
egui::FontData::from_static(font_data),
);
// Priority: NotoSansSC for CJK, then default proportional/ monospace
if let Some(proportional) = fonts.families.get_mut(&egui::FontFamily::Proportional) {
proportional.insert(0, "NotoSansSC".to_string());
}
if let Some(monospace) = fonts.families.get_mut(&egui::FontFamily::Monospace) {
monospace.insert(0, "NotoSansSC".to_string());
}
ctx.set_fonts(fonts);
}
```
---
### Task 6: Implement settings persistence
**Files:**
- Create: `src/persistence.rs`
- [ ] **Step 1: Write round-trip tests**
```rust
#[cfg(test)]
mod tests {
use super::*;
use crate::theme::{Settings, Theme};
#[test]
fn test_save_and_load_settings() {
let dir = std::env::temp_dir().join("epub-read-test");
let _ = std::fs::create_dir_all(&dir);
let mut s = Settings::default();
s.font_size = 24.0;
s.theme = Theme::Dark;
save_settings(&dir, &s).unwrap();
let loaded = load_settings(&dir).unwrap();
assert_eq!(loaded.font_size, 24.0);
assert_eq!(loaded.theme, Theme::Dark);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_load_settings_nonexistent() {
let dir = std::env::temp_dir().join("epub-read-test-nonexistent");
let _ = std::fs::remove_dir_all(&dir);
let result = load_settings(&dir);
assert!(result.is_err());
}
}
```
- [ ] **Step 2: Run to verify failure**
```bash
cargo test --lib persistence::tests -- --nocapture
```
Expected: Compile error — functions not defined.
- [ ] **Step 3: Implement persistence.rs**
```rust
use crate::theme::Settings;
use std::path::Path;
const SETTINGS_FILE: &str = "settings.json";
pub fn settings_dir() -> std::path::PathBuf {
// Use exe directory for portable settings
if let Ok(exe) = std::env::current_exe() {
if let Some(dir) = exe.parent() {
return dir.to_path_buf();
}
}
std::path::PathBuf::from(".")
}
pub fn save_settings(dir: &Path, settings: &Settings) -> Result<(), String> {
let path = dir.join(SETTINGS_FILE);
let json = serde_json::to_string_pretty(settings)
.map_err(|e| format!("序列化设置失败: {}", e))?;
std::fs::write(&path, json)
.map_err(|e| format!("保存设置失败: {}", e))?;
Ok(())
}
pub fn load_settings(dir: &Path) -> Result<Settings, String> {
let path = dir.join(SETTINGS_FILE);
let json = std::fs::read_to_string(&path)
.map_err(|e| format!("读取设置失败: {}", e))?;
serde_json::from_str(&json)
.map_err(|e| format!("解析设置失败: {}", e))
}
```
- [ ] **Step 4: Run tests to verify they pass**
```bash
cargo test
```
Expected: All persistence tests pass.
---
### Task 7: Implement theme visuals
**Files:**
- Modify: `src/theme.rs`
- [ ] **Step 1: Write test for theme creation**
```rust
#[test]
fn test_create_style_light() {
let style = create_style(&Theme::Light);
assert_eq!(style.visuals.window_fill, egui::Color32::from_rgb(255, 255, 255));
}
```
- [ ] **Step 2: Run to verify failure**
```bash
cargo test --lib theme::tests::test_create_style_light -- --nocapture
```
Expected: Compile error — `create_style` not defined.
- [ ] **Step 3: Implement create_style**
Add imports at top of theme.rs:
```rust
use eframe::egui;
use eframe::egui::{Color32, Style, Visuals};
```
Add function:
```rust
pub fn create_style(theme: &Theme) -> Style {
match theme {
Theme::Light => Style {
visuals: Visuals::light(),
..Default::default()
},
Theme::Dark => Style {
visuals: Visuals::dark(),
..Default::default()
},
}
}
```
- [ ] **Step 4: Run tests to verify they pass**
```bash
cargo test
```
Expected: All tests pass.
---
### Task 8: Implement Welcome screen
**Files:**
- Create: `src/app.rs`
- [ ] **Step 1: Write welcome_view skeleton**
app.rs:
```rust
use crate::book::Book;
use crate::persistence;
use crate::reader;
use crate::theme::{self, Settings, Theme};
use eframe::egui;
use std::collections::HashMap;
use std::path::PathBuf;
pub struct App {
pub state: AppState,
settings: Settings,
settings_dir: std::path::PathBuf,
}
pub struct AppState {
pub book: Option<Book>,
pub current_section: usize,
pub current_page: usize,
pub sidebar_open: bool,
pub file_path: Option<PathBuf>,
pub error_message: Option<String>,
}
impl App {
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
let settings_dir = persistence::settings_dir();
let settings = persistence::load_settings(&settings_dir).unwrap_or_default();
cc.egui_ctx.set_style(theme::create_style(&settings.theme));
Self {
state: AppState {
book: None,
current_section: 0,
current_page: 0,
sidebar_open: false,
file_path: None,
error_message: None,
},
settings,
settings_dir,
}
}
}
```
- [ ] **Step 2: Implement open_file method**
```rust
impl App {
pub fn open_file(&mut self, path: PathBuf) {
match crate::book::load_epub(&path) {
Ok(book) => {
let path_str = path.to_string_lossy().to_string();
// Restore reading position
let pos = self.settings.reading_positions.get(&path_str).copied();
// Update recent files
let mut recent = Vec::new();
recent.push(path_str.clone());
for f in &self.settings.recent_files {
if *f != path_str {
recent.push(f.clone());
if recent.len() >= 10 {
break;
}
}
}
self.settings.recent_files = recent;
self.state.book = Some(book);
self.state.current_section = pos.map(|p| p.section).unwrap_or(0);
self.state.current_page = pos.map(|p| p.page).unwrap_or(0);
self.state.sidebar_open = false;
self.state.file_path = Some(path);
self.state.error_message = None;
self.save_settings();
}
Err(e) => {
self.state.error_message = Some(e);
}
}
}
fn save_settings(&self) {
let _ = persistence::save_settings(&self.settings_dir, &self.settings);
}
fn save_reading_position(&mut self) {
if let Some(ref path) = self.state.file_path {
let path_str = path.to_string_lossy().to_string();
self.settings.reading_positions.insert(
path_str,
theme::ReadingPosition {
section: self.state.current_section,
page: self.state.current_page,
},
);
}
}
}
```
- [ ] **Step 3: Implement welcome_view + main update**
Append to app.rs:
```rust
impl App {
fn welcome_view(&mut self, ctx: &egui::Context) {
egui::CentralPanel::default().show(ctx, |ui| {
ui.vertical_centered(|ui| {
ui.add_space(150.0);
ui.heading("ePub Reader");
ui.add_space(20.0);
if ui.button("📂 打开 ePub 文件")
.min_size(egui::vec2(200.0, 40.0))
.clicked()
{
if let Some(path) = rfd::FileDialog::new()
.add_filter("ePub", &["epub"])
.pick_file()
{
self.open_file(path);
}
}
ui.add_space(30.0);
// Recent files
if !self.settings.recent_files.is_empty() {
ui.label("最近阅读:");
ui.separator();
let mut to_remove: Option<usize> = None;
for (i, path) in self.settings.recent_files.iter().enumerate() {
let name = std::path::Path::new(path)
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| path.clone());
if ui.button(&name).clicked() {
let p = std::path::PathBuf::from(path);
if p.exists() {
self.open_file(p);
} else {
to_remove = Some(i);
}
}
}
if let Some(i) = to_remove {
self.settings.recent_files.remove(i);
self.save_settings();
}
}
// Error dialog
if let Some(ref msg) = self.state.error_message {
ui.add_space(20.0);
ui.colored_label(
egui::Color32::RED,
msg,
);
}
});
});
}
}
```
---
### Task 9: Implement Reading view
**Files:**
- Modify: `src/reader.rs`
- [ ] **Step 1: Write the full reading view**
```rust
use crate::book::Book;
use crate::theme::{self, Theme};
use eframe::egui;
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 total_chars = text.chars().count();
if total_chars <= chars_per_page {
pages.push(total_chars);
return pages;
}
let mut pos = 0;
while pos < total_chars {
pos = (pos + chars_per_page).min(total_chars);
pages.push(pos);
}
pages
}
pub fn recalculate_pages(book: &mut Book, font_size: f32, panel_width: f32, panel_height: f32) {
let char_width = font_size * 0.6;
let line_height = font_size * 1.5;
let chars_per_line = if char_width > 0.0 {
(panel_width / char_width).max(1) as usize
} else {
1
};
let lines_per_page = if line_height > 0.0 {
(panel_height / line_height).max(1) as usize
} else {
1
};
let chars_per_page = chars_per_line * lines_per_page;
for section in &mut book.sections {
section.pages = calculate_pages(&section.content, chars_per_page);
}
}
pub fn reading_view(
ui: &mut egui::Ui,
book: &mut Book,
current_section: &mut usize,
current_page: &mut usize,
sidebar_open: &mut bool,
font_size: &mut f32,
theme: &Theme,
file_path: &str,
) {
let panel_size = ui.available_size();
recalculate_pages(book, *font_size, panel_size.x, panel_size.y);
// --- 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, &book.sections, current_section);
});
}
// --- Top toolbar ---
egui::TopBottomPanel::top("reader_toolbar")
.show_inside(ui, |ui| {
ui.horizontal(|ui| {
if ui.button("← 返回").clicked() {
// Return to welcome screen is handled by caller
}
ui.separator();
ui.label(&book.title);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button(if *theme == Theme::Dark { "☀️" } else { "🌙" }).clicked() {
// Theme toggle handled by caller
}
if ui.button("🔖").clicked() {
// Bookmark toggle handled by caller
}
if ui.button("A⁻").clicked() {
*font_size = (*font_size - 2.0).max(10.0);
}
if ui.button("A⁺").clicked() {
*font_size = (*font_size + 2.0).min(48.0);
}
if ui.button("☰").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| {
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
};
ui.add(egui::Slider::new(&mut progress, 0.0..=1.0).text(""));
if total_pages > 0 {
*current_page = (progress * total_pages as f32) as usize;
}
});
});
});
// --- Center text area ---
egui::CentralPanel::default().show_inside(ui, |ui| {
let (rect, response) = ui.allocate_space(ui.available_size(), egui::Sense::click());
// Render text
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 text: String = section.content.chars().skip(start).take(end - start).collect();
ui.put(rect, |ui: &mut egui::Ui| {
ui.add(
egui::Label::new(
egui::RichText::new(&text)
.size(*font_size)
.color(if *theme == Theme::Dark { egui::Color32::WHITE } else { egui::Color32::BLACK })
)
.wrap(true)
);
});
}
}
// Handle 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 {
// Previous page
if *current_page > 0 {
*current_page -= 1;
} else if *current_section > 0 {
*current_section -= 1;
*current_page = book.sections[*current_section]
.pages
.len()
.saturating_sub(2);
}
} else if x_ratio > 0.7 {
// Next page
if *current_page + 1 < book.sections[*current_section]
.pages
.len()
.saturating_sub(1)
{
*current_page += 1;
} else if *current_section + 1 < book.sections.len() {
*current_section += 1;
*current_page = 0;
}
}
}
}
// Keyboard navigation
if ui.input(|i| i.key_pressed(egui::Key::ArrowRight)) {
if *current_page + 1 < book.sections[*current_section]
.pages
.len()
.saturating_sub(1)
{
*current_page += 1;
} else if *current_section + 1 < book.sections.len() {
*current_section += 1;
*current_page = 0;
}
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowLeft)) {
if *current_page > 0 {
*current_page -= 1;
} else if *current_section > 0 {
*current_section -= 1;
*current_page = book.sections[*current_section]
.pages
.len()
.saturating_sub(2);
}
}
});
}
fn render_toc(
ui: &mut egui::Ui,
entries: &[crate::book::TocEntry],
sections: &[crate::book::Section],
current_section: &mut usize,
) {
for entry in entries {
let label = &entry.label;
let is_current = entry.section == *current_section;
let response = if is_current {
ui.colored_label(egui::Color32::YELLOW, label)
} else {
ui.label(label)
};
if response.clicked() {
*current_section = entry.section;
}
if !entry.children.is_empty() {
ui.indent(label, |ui| {
render_toc(ui, &entry.children, sections, current_section);
});
}
}
}
```
---
### Task 10: Wire App and verify build
**Files:**
- Modify: `src/app.rs` (full App with eframe::App impl)
- [ ] **Step 1: Implement eframe::App for App**
Add to `src/app.rs`:
```rust
impl eframe::App for App {
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
if self.state.book.is_none() {
self.welcome_view(ctx);
} else {
let mut go_back = false;
let mut toggle_theme = false;
let mut toggle_bookmark = false;
// Extract book reference
let book = self.state.book.as_mut().unwrap();
let file_path = self.state.file_path.as_ref()
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_default();
egui::CentralPanel::default().show(ctx, |ui| {
crate::reader::reading_view(
ui,
book,
&mut self.state.current_section,
&mut self.state.current_page,
&mut self.state.sidebar_open,
&mut self.settings.font_size,
&self.settings.theme,
&file_path,
);
});
// Handle navigation from toolbar (simulated via state flags)
// For now, toolbar buttons in reading_view return through the book reference
// Theme toggle is handled here
if toggle_theme {
self.settings.theme = match self.settings.theme {
theme::Theme::Light => theme::Theme::Dark,
theme::Theme::Dark => theme::Theme::Light,
};
ctx.set_style(theme::create_style(&self.settings.theme));
self.save_settings();
}
// Auto-save reading position on each frame (throttled)
self.save_reading_position();
self.save_settings();
}
}
}
```
Wait, the toolbar buttons (theme toggle, back) are inside `reading_view` and can't directly set App's state. I need to redesign this. Let me use return values from `reading_view`.
- [ ] **Step 2: Refactor reading_view to use return values**
Change `reading_view` signature in `src/reader.rs`:
```rust
pub struct ReaderAction {
pub go_back: bool,
pub toggle_theme: bool,
pub toggle_bookmark: bool,
}
pub fn reading_view(
ui: &mut egui::Ui,
book: &mut Book,
current_section: &mut usize,
current_page: &mut usize,
sidebar_open: &mut bool,
font_size: &mut f32,
theme: &Theme,
file_path: &str,
) -> ReaderAction {
let mut action = ReaderAction {
go_back: false,
toggle_theme: false,
toggle_bookmark: false,
};
// --- 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, &book.sections, current_section);
});
}
// --- Top toolbar ---
egui::TopBottomPanel::top("reader_toolbar")
.show_inside(ui, |ui| {
ui.horizontal(|ui| {
if ui.button("← 返回").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 = match theme {
Theme::Dark => "☀️",
Theme::Light => "🌙",
};
if ui.button(theme_icon).clicked() {
action.toggle_theme = true;
}
if ui.button("🔖").clicked() {
action.toggle_bookmark = true;
}
if ui.button("A⁻").clicked() {
*font_size = (*font_size - 2.0).max(10.0);
}
if ui.button("A⁺").clicked() {
*font_size = (*font_size + 2.0).min(48.0);
}
if ui.button("☰").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| {
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
};
let slider = egui::Slider::new(&mut progress, 0.0..=1.0).text("");
if ui.add(slider).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 (rect, response) = ui.allocate_space(ui.available_size(), egui::Sense::click());
// Render text
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 text: String = section.content.chars().skip(start).take(end - start).collect();
ui.put(rect, |ui: &mut egui::Ui| {
let color = match theme {
Theme::Dark => egui::Color32::WHITE,
Theme::Light => egui::Color32::BLACK,
};
ui.add(
egui::Label::new(
egui::RichText::new(&text).size(*font_size).color(color)
)
.wrap(true)
);
});
}
}
// Handle 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 {
if *current_page > 0 {
*current_page -= 1;
} else if *current_section > 0 {
*current_section -= 1;
*current_page = book.sections[*current_section]
.pages
.len()
.saturating_sub(2);
}
} else if x_ratio > 0.7 {
if *current_page + 1 < book.sections[*current_section]
.pages
.len()
.saturating_sub(1)
{
*current_page += 1;
} else if *current_section + 1 < book.sections.len() {
*current_section += 1;
*current_page = 0;
}
}
}
}
// Keyboard navigation
if ui.input(|i| i.key_pressed(egui::Key::ArrowRight)) {
if *current_page + 1 < book.sections[*current_section]
.pages
.len()
.saturating_sub(1)
{
*current_page += 1;
} else if *current_section + 1 < book.sections.len() {
*current_section += 1;
*current_page = 0;
}
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowLeft)) {
if *current_page > 0 {
*current_page -= 1;
} else if *current_section > 0 {
*current_section -= 1;
*current_page = book.sections[*current_section]
.pages
.len()
.saturating_sub(2);
}
}
});
action
}
```
- [ ] **Step 3: Update App::update to use ReaderAction**
```rust
impl eframe::App for App {
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
if self.state.book.is_none() {
self.welcome_view(ctx);
return;
}
let file_path = self.state.file_path
.as_ref()
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_default();
egui::CentralPanel::default().show(ctx, |ui| {
let book = self.state.book.as_mut().unwrap();
let action = crate::reader::reading_view(
ui,
book,
&mut self.state.current_section,
&mut self.state.current_page,
&mut self.state.sidebar_open,
&mut self.settings.font_size,
&self.settings.theme,
&file_path,
);
if action.go_back {
self.save_reading_position();
self.state.book = None;
self.state.current_section = 0;
self.state.current_page = 0;
}
if action.toggle_theme {
self.settings.theme = match self.settings.theme {
theme::Theme::Light => theme::Theme::Dark,
theme::Theme::Dark => theme::Theme::Light,
};
ctx.set_style(theme::create_style(&self.settings.theme));
}
});
// Save position and settings
self.save_reading_position();
self.save_settings();
}
}
```
- [ ] **Step 4: Build and fix compilation errors**
```bash
cargo check 2>&1
```
Fix any compilation errors iteratively:
```bash
cargo check 2>&1 | head -50
```
Common issues to fix:
- Missing imports in various modules
- API mismatches between `epub` crate version and usage
- Method name differences in `egui`
- [ ] **Step 5: Final successful build**
```bash
cargo check
```
Expected: Compilation succeeds with 0 errors (warnings OK).
---
### Task 11: Build release binary
**Files:**
- Modify: `.cargo/config.toml` (verify static linking config)
- [ ] **Step 1: Verify static linking config**
`.cargo/config.toml`:
```toml
[target.x86_64-pc-windows-gnu]
rustflags = ["-C", "target-feature=+crt-static"]
```
- [ ] **Step 2: Build release**
```bash
cargo build --release
```
Expected: `target/release/epub-read.exe` produced.
- [ ] **Step 3: Verify no DLL dependencies**
```bash
# Check that the exe has no mingw DLL dependencies
objdump -p target/release/epub-read.exe | grep "DLL Name"
```
Expected: No `libgcc_s_seh-1.dll`, `libwinpthread-1.dll`, or `libstdc++-6.dll` listed. Only Windows system DLLs.
- [ ] **Step 4: Verify console is hidden**
```bash
# Run the exe — should show no console window
./target/release/epub-read.exe &
```
Expected: GUI window appears, no console/terminal window visible.
- [ ] **Step 5: Verify with a real ePub file**
Place a `.epub` file accessible, launch the app, click "打开 ePub 文件", select the file, verify:
- Chinese text renders correctly
- Pages advance with click/keyboard
- TOC sidebar works
- Font size adjustment works
- Theme toggle works
- Progress bar updates
- Re-opening the same file restores position
---
## Self-Review Checklist
1. **Spec coverage:** All 12 features from spec are covered: open file ✓, parse epub ✓, pagination ✓, navigation ✓, TOC ✓, reading position ✓, font size ✓, theme ✓, Chinese font ✓, bookmarks (UI stubs in toolbar, data model complete), settings persistence ✓, recent files ✓.
2. **Placeholder scan:** No TBD/TODO. All code is complete, no vague descriptions.
3. **Type consistency:** `Book`, `Section`, `TocEntry`, `Settings`, `Theme`, `Bookmark`, `ReadingPosition` — consistent across all tasks. `ReaderAction` return type connects Task 9 to Task 10.
4. **Ambiguity check:** Bookmark functionality has data model but UI toggles are noted as stubs (🔖 button exists, action reported back to App). This is minimal viable scope — bookmark saving/listing can be added as follow-up.
Reference in New Issue Copy Permalink