atmos/kernel/

text_box.rs

// text_box.rs - 共通テキストボックス編集モジュール

use alloc::string::String;

#[derive(Debug, Clone, Default)]
pub struct TextBox {
    pub text: String,
    pub cursor_pos: usize, // 文字ベースのカーソル位置
    pub multiline: bool,   // true の場合のみ Tab を 4 桁タブストップ空白へ展開する
}

/// [`TextBox::handle_key_outcome`] の結果。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyOutcome {
    /// このキーは TextBox では扱わなかった（呼び出し側の既定動作へ委ねてよい）。
    Ignored,
    /// カーソルだけが動いた。テキストは 1 文字も変わっていない。
    CursorMoved,
    /// テキストを書き換えた。
    TextChanged,
}

impl TextBox {
    pub fn new() -> Self {
        Self {
            text: String::new(),
            cursor_pos: 0,
            multiline: false,
        }
    }

    pub fn with_text(text: &str) -> Self {
        let text_str = String::from(text);
        let len = text_str.chars().count();
        Self {
            text: text_str,
            cursor_pos: len,
            multiline: false,
        }
    }

    /// 複数行モードを有効にした TextBox を生成します（note エディタ等）。
    pub fn with_text_multiline(text: &str) -> Self {
        let mut tb = Self::with_text(text);
        tb.multiline = true;
        tb
    }

    pub fn set_text(&mut self, text: &str) {
        self.text = String::from(text);
        self.cursor_pos = self.text.chars().count();
    }

    /// カーソルを挿入した表示用の文字列を作成します
    pub fn get_text_with_cursor(&self, show_cursor: bool) -> String {
        if !show_cursor {
            return self.text.clone();
        }
        let mut s = String::new();
        for (i, c) in self.text.chars().enumerate() {
            if i == self.cursor_pos {
                s.push('|');
            }
            s.push(c);
        }
        if self.cursor_pos >= self.text.chars().count() {
            s.push('|');
        }
        s
    }

    /// キーボード入力を処理します。テキストまたはカーソルが動いた場合は true を返します。
    ///
    /// 「文字が変わったのか、カーソルが動いただけなのか」を区別したい呼び出し側は
    /// [`TextBox::handle_key_outcome`] を使うこと。
    pub fn handle_key(&mut self, keycode: u8, ascii: Option<char>) -> bool {
        self.handle_key_outcome(keycode, ascii) != KeyOutcome::Ignored
    }

    /// [`TextBox::handle_key`] の詳細版。矢印キー等の**カーソル移動**と、
    /// 実際にテキストを書き換えた**編集**を区別して返す。
    ///
    /// 【2026-09-08 バグ修正】この区別が無かったため、Web エンジン側は
    /// 矢印キーでも「値が変わった」とみなして DOM の value を書き換え
    /// `input` イベントを発火していた。DOM が dirty になると
    /// `relayout_if_dom_dirty` → `parse_and_layout` が走り、そこで
    /// `active_text_box` が破棄される。次のキーで `with_text_multiline` により
    /// **カーソル位置が末尾に戻った** TextBox が作り直されるため、
    /// note アプリで「↑を押しても 1 行しか上がらない」症状になっていた。
    pub fn handle_key_outcome(&mut self, keycode: u8, ascii: Option<char>) -> KeyOutcome {
        let chars_count = self.text.chars().count();
        if self.cursor_pos > chars_count {
            self.cursor_pos = chars_count;
        }

        match keycode {
            0x0E => {
                // Backspace
                if self.cursor_pos > 0 && !self.text.is_empty() {
                    let mut new_text = String::new();
                    for (i, c) in self.text.chars().enumerate() {
                        if i != self.cursor_pos - 1 {
                            new_text.push(c);
                        }
                    }
                    self.text = new_text;
                    self.cursor_pos -= 1;
                    return KeyOutcome::TextChanged;
                }
            }
            0x4B => {
                // Left Arrow
                if self.cursor_pos > 0 {
                    self.cursor_pos -= 1;
                    return KeyOutcome::CursorMoved;
                }
            }
            0x4D => {
                // Right Arrow
                if self.cursor_pos < chars_count {
                    self.cursor_pos += 1;
                    return KeyOutcome::CursorMoved;
                }
            }
            0x48 => {
                // Up Arrow
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut line_ranges = alloc::vec::Vec::new();
                let mut start = 0;
                for (idx, &c) in chars.iter().enumerate() {
                    if c == '\n' {
                        line_ranges.push((start, idx));
                        start = idx + 1;
                    }
                }
                line_ranges.push((start, chars.len()));

                let mut current_line_idx = 0;
                for (idx, &(start, end)) in line_ranges.iter().enumerate() {
                    if self.cursor_pos >= start && self.cursor_pos <= end {
                        current_line_idx = idx;
                        break;
                    }
                }

                if current_line_idx > 0 {
                    let current_col = self.cursor_pos - line_ranges[current_line_idx].0;
                    let target_line_idx = current_line_idx - 1;
                    let (t_start, t_end) = line_ranges[target_line_idx];
                    let t_len = t_end - t_start;
                    self.cursor_pos = t_start + current_col.min(t_len);
                    return KeyOutcome::CursorMoved;
                }
            }
            0x50 => {
                // Down Arrow
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut line_ranges = alloc::vec::Vec::new();
                let mut start = 0;
                for (idx, &c) in chars.iter().enumerate() {
                    if c == '\n' {
                        line_ranges.push((start, idx));
                        start = idx + 1;
                    }
                }
                line_ranges.push((start, chars.len()));

                let mut current_line_idx = 0;
                for (idx, &(start, end)) in line_ranges.iter().enumerate() {
                    if self.cursor_pos >= start && self.cursor_pos <= end {
                        current_line_idx = idx;
                        break;
                    }
                }

                if current_line_idx < line_ranges.len() - 1 {
                    let current_col = self.cursor_pos - line_ranges[current_line_idx].0;
                    let target_line_idx = current_line_idx + 1;
                    let (t_start, t_end) = line_ranges[target_line_idx];
                    let t_len = t_end - t_start;
                    self.cursor_pos = t_start + current_col.min(t_len);
                    return KeyOutcome::CursorMoved;
                }
            }
            0x53 => {
                // Delete (Ctrl+D): カーソル位置の文字を前方削除
                if self.cursor_pos < chars_count {
                    let mut new_text = String::new();
                    for (i, c) in self.text.chars().enumerate() {
                        if i != self.cursor_pos {
                            new_text.push(c);
                        }
                    }
                    self.text = new_text;
                    return KeyOutcome::TextChanged;
                }
            }
            0x47 => {
                // Home (Ctrl+A): 現在行の行頭へ
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut start = self.cursor_pos;
                while start > 0 && chars[start - 1] != '\n' {
                    start -= 1;
                }
                if start != self.cursor_pos {
                    self.cursor_pos = start;
                    return KeyOutcome::CursorMoved;
                }
            }
            0x4F => {
                // End (Ctrl+E): 現在行の行末へ
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut end = self.cursor_pos;
                while end < chars.len() && chars[end] != '\n' {
                    end += 1;
                }
                if end != self.cursor_pos {
                    self.cursor_pos = end;
                    return KeyOutcome::CursorMoved;
                }
            }
            0x49 => {
                // Page Up: 文書の先頭へ移動
                if self.cursor_pos != 0 {
                    self.cursor_pos = 0;
                    return KeyOutcome::CursorMoved;
                }
            }
            0x51 => {
                // Page Down: 文書の末尾へ移動
                if self.cursor_pos != chars_count {
                    self.cursor_pos = chars_count;
                    return KeyOutcome::CursorMoved;
                }
            }
            crate::kernel::keyboard::KC_KILL_LINE => {
                // Ctrl+K: カーソル位置から行末まで削除
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut end = self.cursor_pos;
                while end < chars.len() && chars[end] != '\n' {
                    end += 1;
                }
                if end > self.cursor_pos {
                    let mut new_text = String::new();
                    for (i, c) in chars.iter().enumerate() {
                        if i < self.cursor_pos || i >= end {
                            new_text.push(*c);
                        }
                    }
                    self.text = new_text;
                    return KeyOutcome::TextChanged;
                }
            }
            0x0F if self.multiline => {
                // Tab: 4桁タブストップに合わせた半角空白へ展開する（複数行エディタのみ）。
                // 現在行頭からのカラム位置を求め、次の 4 の倍数までを空白で埋める。
                let chars: alloc::vec::Vec<char> = self.text.chars().collect();
                let mut col = 0usize;
                let mut i = self.cursor_pos;
                while i > 0 && chars[i - 1] != '\n' {
                    i -= 1;
                    col += 1;
                }
                let spaces = 4 - (col % 4);
                let mut new_text = String::new();
                for (idx, ch) in chars.iter().enumerate() {
                    if idx == self.cursor_pos {
                        for _ in 0..spaces {
                            new_text.push(' ');
                        }
                    }
                    new_text.push(*ch);
                }
                if self.cursor_pos >= chars.len() {
                    for _ in 0..spaces {
                        new_text.push(' ');
                    }
                }
                self.text = new_text;
                self.cursor_pos += spaces;
                return KeyOutcome::TextChanged;
            }
            _ => {
                if let Some(c) = ascii {
                    if c == '\r' || c == '\n' {
                        let mut new_text = String::new();
                        let mut inserted = false;
                        for (i, ch) in self.text.chars().enumerate() {
                            if i == self.cursor_pos {
                                new_text.push('\n');
                                inserted = true;
                            }
                            new_text.push(ch);
                        }
                        if !inserted {
                            new_text.push('\n');
                        }
                        self.text = new_text;
                        self.cursor_pos += 1;
                        return KeyOutcome::TextChanged;
                    } else {
                        let mut new_text = String::new();
                        let mut inserted = false;
                        for (i, ch) in self.text.chars().enumerate() {
                            if i == self.cursor_pos {
                                new_text.push(c);
                                inserted = true;
                            }
                            new_text.push(ch);
                        }
                        if !inserted {
                            new_text.push(c);
                        }
                        self.text = new_text;
                        self.cursor_pos += 1;
                        return KeyOutcome::TextChanged;
                    }
                }
            }
        }
        KeyOutcome::Ignored
    }
}