Shift+Tab 向前跳轉一個段落

Author: lotem

src/action.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 pub trait 動作: Fn() + Copy + 'static {}
 impl<T> 動作 for T where T: Fn() + Copy + 'static {}
 

src/engine.rs

@@ -5,10 +5,10 @@ use leptos::prelude::*;
 use crate::action::動作;
 use crate::definition::觸鍵方式;
 use crate::gear::{
-    assignment::{作業, 作業推進參數, 作業機關, 作業機關輸出信號},
+    assignment::{作業, 作業機關, 作業機關輸出信號, 步進法},
     caption::{字幕機關, 字幕機關輸出信號, 字幕段落},
     chord::{並擊機關, 並擊機關輸出信號},
-    input::{焦點事件處理機關, 輸入事件處理機關},
+    input::{焦點事件處理機關, 觸鍵消息, 輸入事件處理機關},
     key_press::{連擊機關, 連擊機關輸出信號},
     mode::{工作模式, 工作模式機關, 工作模式機關輸出信號},
     theory::{輸入方案機關, 輸入方案機關輸出信號},
@@ -46,8 +46,10 @@ pub fn 微觀引擎() -> 微觀引擎輸出信號 {
         ..
     } = 作業;
     let 字幕機關輸出信號 {
-        分段字幕, 當前段落,
-    ..
+        分段字幕,
+        當前段落,
+        前序段落,
+        ..
     } = 字幕;
     let 連擊機關輸出信號 {
         連擊狀態變更,
@@ -90,7 +92,7 @@ pub fn 微觀引擎() -> 微觀引擎輸出信號 {
 
     焦點事件處理機關(重置並擊狀態);
 
-    let 處理功能鍵 = move |鍵碼: KeyCode| match 鍵碼 {
+    let 處理功能鍵 = move |觸鍵消息 { 鍵碼, 檔位 }| match 鍵碼 {
         KeyCode::Escape => {
             match 現行工作模式() {
                 工作模式::錄入 => {
@@ -107,12 +109,20 @@ pub fn 微觀引擎() -> 微觀引擎輸出信號 {
         }
         KeyCode::Tab => {
             if 現行工作模式() == 工作模式::錄入 {
-                if 作業推進(作業推進參數 {
-                    段落: 當前段落().map(|字幕段落(起, 止, _)| (起, 止)),
-                    迴轉: true,
-                })
-                .is_ok()
-                {
+                let 跳轉結果 = if 檔位.shift {
+                    let 目標 = 前序段落()
+                        .or_else(|| 分段字幕.with(|衆段落| 衆段落.last().cloned()))
+                        .map(|字幕段落(起, _, _)| 起);
+                    作業回退(步進法 {
+                        目標, 迴轉: true
+                    })
+                } else {
+                    let 目標 = 當前段落().map(|字幕段落(_, 止, _)| 止);
+                    作業推進(步進法 {
+                        目標, 迴轉: true
+                    })
+                };
+                if 跳轉結果.is_ok() {
                     重置輸入狀態();
                 }
             } else {
@@ -125,12 +135,12 @@ pub fn 微觀引擎() -> 微觀引擎輸出信號 {
                 match 指法() {
                     觸鍵方式::連擊 => {
                         if 有無作業() {
-                            let _不看結果 = 作業回退();
+                            let _不看結果 = 作業回退(步進法::default());
                         }
                         回退連擊輸入碼();
                     }
                     觸鍵方式::並擊 => {
-                        if 並擊完成() || 作業回退().is_ok() {
+                        if 並擊完成() || 作業回退(步進法::default()).is_ok() {
                             重置並擊狀態();
                         }
                     }
@@ -163,8 +173,11 @@ pub fn 微觀引擎() -> 微觀引擎輸出信號 {
     };
     let 批閱作業 = move || {
         // 擊中目標輸入碼後反查下一個輸入碼
-        let 分段落則迴轉 = 分段字幕.read().len() > 1;
-        擊中目標() && 作業推進(作業推進參數::步進(分段落則迴轉)).is_ok()
+        let 分段落則迴轉 = 步進法 {
+            目標: None,
+            迴轉: 分段字幕.read().len() > 1,
+        };
+        擊中目標() && 作業推進(分段落則迴轉).is_ok()
     };
     let 另起一段 = move || {
         當前段落

src/gear/assignment.rs

@@ -1,4 +1,5 @@
 use lazy_regex::regex;
+use leptos::logging::log;
 use leptos::prelude::*;
 use std::cmp::min;
 
@@ -78,21 +79,7 @@ impl 作業 {
     }
 }
 
-#[derive(Clone, Copy)]
-pub struct 作業推進參數 {
-    pub 段落: Option<(usize, usize)>,
-    pub 迴轉: bool,
-}
-
-impl 作業推進參數 {
-    pub fn 步進(迴轉: bool) -> Self {
-        Self {
-            段落: None, 迴轉
-        }
-    }
-}
-
-#[derive(Clone, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct 對照輸入碼 {
     pub 字根碼原文: Option<String>,
     pub 轉寫碼原文: Option<String>,
@@ -114,9 +101,15 @@ impl 對照輸入碼 {
     }
 }
 
+#[derive(Clone, Copy, Default)]
+pub struct 步進法 {
+    pub 目標: Option<usize>,
+    pub 迴轉: bool,
+}
+
 pub type 重置作業進度動作 = impl 動作;
-pub type 作業推進動作 = impl 動作給一參數得一結果<作業推進參數>;
-pub type 作業回退動作 = impl 動作得一結果;
+pub type 作業推進動作 = impl 動作給一參數得一結果<步進法>;
+pub type 作業回退動作 = impl 動作給一參數得一結果<步進法>;
 
 #[derive(Clone)]
 pub struct 作業機關輸出信號 {
@@ -162,7 +155,8 @@ pub fn 作業機關(方案: &輸入方案機關輸出信號) -> 作業機關輸
 
     let _ = Effect::watch(
         目標輸入碼序列,
-        move |_, _, _| {
+        move |目標輸入碼序列, _, _| {
+            log!("更新了目標輸入碼: {}", 目標輸入碼序列.len());
             重置作業進度();
         },
         false,
@@ -178,38 +172,40 @@ pub fn 作業機關(方案: &輸入方案機關輸出信號) -> 作業機關輸
         })
     });
 
-    let 作業推進 = move |參數: 作業推進參數| {
-        let 全文結束 = 目標輸入碼序列.read().len();
-        let 推進目標位置 = match 參數.段落 {
-            Some((起, 止)) => {
-                if 作業進度() < 起 {
-                    起
-                } else {
-                    止
-                }
-            }
-            None => 作業進度() + 1,
-        };
-        if 參數.迴轉 && 推進目標位置 >= 全文結束 {
+    let 作業推進 = move |步進: 步進法| {
+        let 當前進度 = 作業進度();
+        let 全文長度 = 目標輸入碼序列.read().len();
+        let 目標進度 = 步進.目標.unwrap_or(當前進度 + 1);
+        if 步進.迴轉 && 目標進度 >= 全文長度 {
             重置作業進度();
             Ok(())
         }
         // 非迴轉態可推進至全文結束位置
-        else if 推進目標位置 <= 全文結束 {
-            更新作業進度(推進目標位置);
+        else if 目標進度 <= 全文長度 {
+            更新作業進度(目標進度);
             Ok(())
         } else {
             Err(未有())
         }
     };
 
-    let 作業回退 = move || {
-        let 進度 = 作業進度();
-        if 進度 > 0 {
-            更新作業進度(進度 - 1);
-            Ok(())
-        } else {
-            Err(未有())
+    let 作業回退 = move |步進: 步進法| {
+        let 當前進度 = 作業進度();
+        let 全文長度 = 目標輸入碼序列.read().len();
+        match 步進.目標 {
+            Some(目標進度) if 步進.迴轉 || 當前進度 > 目標進度 => {
+                更新作業進度(目標進度);
+                Ok(())
+            }
+            None if 步進.迴轉 && 當前進度 == 0 && 全文長度 > 0 => {
+                更新作業進度(全文長度 - 1);
+                Ok(())
+            }
+            None if 當前進度 > 0 => {
+                更新作業進度(當前進度 - 1);
+                Ok(())
+            }
+            _ => Err(未有()),
         }
     };
 

src/gear/caption.rs

@@ -81,6 +81,10 @@ fn 標註字序<'a>(衆段落: impl Iterator<Item = Cow<'a, str>>) -> Box<[字
         .into_boxed_slice()
 }
 
+fn 所屬段落序號(衆段落: &[字幕段落], 進度: usize) -> usize {
+    衆段落.partition_point(|字幕段落(_, 段落結束, _)| *段落結束 <= 進度)
+}
+
 #[derive(Clone)]
 pub struct 字幕表示 {
     pub 已完成: String,
@@ -92,6 +96,7 @@ pub struct 字幕表示 {
 pub struct 字幕機關輸出信號 {
     pub 分段字幕: Memo<Box<[字幕段落<'static>]>>,
     pub 當前段落: Memo<Option<字幕段落<'static>>>,
+    pub 前序段落: Signal<Option<字幕段落<'static>>>,
     pub 段落表示: Signal<Option<字幕表示>>,
 }
 
@@ -135,8 +140,7 @@ pub fn 字幕機關(
     let 當前段落 = Memo::new(move |_| {
         分段字幕.with(|衆段落| {
             let 全文進度 = 作業進度();
-            let 當前段落號 =
-                衆段落.partition_point(|字幕段落(_, 段落結束, _)| *段落結束 <= 全文進度);
+            let 當前段落號 = 所屬段落序號(衆段落, 全文進度);
             衆段落
                 .get(當前段落號)
                 .or_else(|| {
@@ -148,6 +152,18 @@ pub fn 字幕機關(
         })
     });
 
+    let 前序段落 = Signal::derive(move || {
+        分段字幕.with(|衆段落| {
+            let 全文進度 = 作業進度();
+            let 當前段落號 = 所屬段落序號(衆段落, 全文進度);
+            if 當前段落號 == 0 {
+                None
+            } else {
+                衆段落.get(當前段落號 - 1).cloned()
+            }
+        })
+    });
+
     let 段落表示 = Signal::derive(move || {
         當前段落().map(|字幕段落(段落起始, _, 段落文字)| {
             let 全文進度 = 作業進度();
@@ -173,6 +189,7 @@ pub fn 字幕機關(
     字幕機關輸出信號 {
         分段字幕,
         當前段落,
+        前序段落,
         段落表示,
     }
 }

src/gear/input.rs

@@ -14,15 +14,34 @@ pub fn 焦點事件處理機關(重置並擊狀態: impl 動作) {
     });
 }
 
+#[allow(dead_code)]
+pub struct 檔位 {
+    pub shift: bool,
+    pub ctrl: bool,
+    pub alt: bool,
+    pub meta: bool,
+}
+
+pub struct 觸鍵消息 {
+    pub 鍵碼: KeyCode,
+    pub 檔位: 檔位,
+}
+
 pub fn 輸入事件處理機關(
-    處理功能鍵: impl 動作給一參數得一結果<KeyCode, bool>,
+    處理功能鍵: impl 動作給一參數得一結果<觸鍵消息, bool>,
     既然落鍵: impl 動作給一參數<KeyCode>,
     既然抬鍵: impl 動作給一參數<KeyCode>,
 ) {
     let keydown_handle = window_event_listener(ev::keydown, move |ev| {
         log!("落鍵 key = {}, code = {}", &ev.key(), ev.code());
         let 鍵碼 = 網頁鍵值轉換(&ev.code());
-        if 處理功能鍵(鍵碼) {
+        let 檔位 = 檔位 {
+            shift: ev.shift_key(),
+            ctrl: ev.ctrl_key(),
+            alt: ev.alt_key(),
+            meta: ev.meta_key(),
+        };
+        if 處理功能鍵(觸鍵消息 { 鍵碼, 檔位 }) {
             ev.prevent_default();
         }
         既然落鍵(鍵碼);