Add bit operations, shift/rotate controls, undo/redo, and improve UI feedback

- Add bit_ops core module with hex/bit-string/decimal conversions, toggle, invert, shift (zero-fill & rotate)
- Add undo/redo support for bit viewer operations
- Add bit-string and decimal input fields to bit viewer page
- Improve calc_engine Python/sympy detection with detailed diagnostics and remediation hints
- Extract shared UI feedback components (group_panel, show_error, show_empty_state, show_instructions, etc.)
- Refactor number_conversion and text_conversion pages to use shared components
- Update README with new feature descriptions

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: AnlangA

README.md

@@ -1,6 +1,6 @@
 # 编码转换工具
 
-一个用 Rust 和 egui 构建的跨平台编码转换工具，支持多种进制转换、文本编码转换和位操作查看。
+一个用 Rust 和 egui 构建的跨平台编码转换工具，支持多种进制转换、文本编码转换、位查看与位操作，以及多进制表达式计算。
 
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
 ![Rust](https://img.shields.io/badge/rust-1.70+-orange.svg)
@@ -9,8 +9,9 @@
 
 - **进制转换**：二进制 ↔ 十进制 ↔ 十六进制，实时转换
 - **文本编码**：ASCII ↔ 十六进制，支持不可打印字符显示
-- **位查看器**：可视化位操作，支持点击切换
-- **浮点数转换**：IEEE 754 标准，支持 f32 浮点数转换
+- **位查看器**：支持十六进制 / 位串 / 十进制联动查看，支持点击切换、按位取反、逻辑移位、循环移位、撤销与重做
+- **浮点数转换**：IEEE 754 标准，支持 f32 浮点数转换与分析
+- **表达式计算器**：支持二进制、八进制、十进制、十六进制表达式计算，并自动转换显示结果
 
 ## 快速开始
 
@@ -33,10 +34,11 @@ cargo run --release
 
 ```
 src/
-├── app/           # 应用程序层
-├── core/          # 核心业务逻辑
-├── ui/            # 用户界面层
-└── utils/         # 工具函数
+├── app/           # 应用程序入口、配置与启动逻辑
+├── backend/       # 异步计算与前后端消息通信
+├── core/          # 核心业务逻辑（位操作、计算引擎等）
+├── frontend/      # 页面状态管理与本地交互逻辑
+└── ui/            # 用户界面层与可复用组件
 ```
 
 ## 开发
@@ -46,6 +48,8 @@ src/
 cargo test
 ```
 
+如果你要使用表达式计算器，请确保当前 Python 环境可用；项目会优先查找本地虚拟环境中的 Python，并依赖 `scripts/calc_engine.py` 所需的 `sympy` 包。
+
 ## 许可证
 
 MIT 许可证 - 查看 [LICENSE](LICENSE) 文件了解详情。

src/backend/messages.rs

@@ -162,6 +162,10 @@ pub enum BitViewerOperation {
     ToggleBit(usize),
     /// Invert all bits
     InvertAll,
+    /// Shift all bits to the left by the given count
+    ShiftLeft(usize),
+    /// Shift all bits to the right by the given count
+    ShiftRight(usize),
 }
 
 /// Bit viewer request.
@@ -173,7 +177,7 @@ pub struct BitViewerRequest {
     pub operation: BitViewerOperation,
     /// Hex input (for ParseHex)
     pub hex_input: Option<String>,
-    /// Current binary bits (for ToggleBit/InvertAll)
+    /// Current binary bits (for bit operations)
     pub current_bits: Option<Vec<bool>>,
 }
 

src/backend/worker.rs

@@ -4,7 +4,7 @@ use std::sync::mpsc::{Receiver, Sender, TryRecvError};
 use std::thread::{self, JoinHandle};
 
 use super::messages::*;
-use crate::core::calc_engine;
+use crate::core::{bit_ops, calc_engine};
 
 /// Backend processor that handles all computation requests.
 pub struct BackendWorker;
@@ -229,105 +229,80 @@ impl BackendWorker {
         match req.operation {
             BitViewerOperation::ParseHex => {
                 let hex_input = req.hex_input.unwrap_or_default();
-                let clean_hex: String = hex_input
-                    .chars()
-                    .filter(|c| c.is_ascii_hexdigit())
-                    .collect::<String>()
-                    .to_uppercase();
-
-                if clean_hex.is_empty() {
-                    return BitViewerResponse {
+                match bit_ops::parse_hex_input(&hex_input) {
+                    Ok(parsed) => BitViewerResponse {
                         id: req.id,
-                        hex_input: String::new(),
-                        binary_bits: Vec::new(),
-                        error: Some("输入为空".to_string()),
-                    };
-                }
-
-                // Validate hex characters
-                if !clean_hex.chars().all(|c| c.is_ascii_hexdigit()) {
-                    return BitViewerResponse {
+                        hex_input: parsed.normalized_hex,
+                        binary_bits: bit_ops::bit_string_to_bits(&parsed.bit_string)
+                            .unwrap_or_default(),
+                        error: None,
+                    },
+                    Err(error) => BitViewerResponse {
                         id: req.id,
                         hex_input,
                         binary_bits: Vec::new(),
-                        error: Some("无效的十六进制字符".to_string()),
-                    };
-                }
-
-                let mut binary_bits = Vec::new();
-                for hex_char in clean_hex.chars() {
-                    if let Some(digit) = hex_char.to_digit(16) {
-                        let digit = digit as u8;
-                        for i in (0..4).rev() {
-                            binary_bits.push((digit & (1 << i)) != 0);
-                        }
-                    }
+                        error: Some(error),
+                    },
                 }
+            }
+            BitViewerOperation::ToggleBit(index) => {
+                let current_bits = req.current_bits.unwrap_or_default();
+                let bit_string = bit_ops::bits_to_bit_string(&current_bits);
+                let updated_bit_string =
+                    bit_ops::toggle_bit(&bit_string, index).unwrap_or(bit_string);
 
                 BitViewerResponse {
                     id: req.id,
-                    hex_input: clean_hex,
-                    binary_bits,
+                    hex_input: bit_ops::bit_string_to_hex(&updated_bit_string).unwrap_or_default(),
+                    binary_bits: bit_ops::bit_string_to_bits(&updated_bit_string)
+                        .unwrap_or_default(),
                     error: None,
                 }
             }
-            BitViewerOperation::ToggleBit(index) => {
-                let mut bits = req.current_bits.unwrap_or_default();
-                if index < bits.len() {
-                    bits[index] = !bits[index];
-                }
-                let hex_input = Self::bits_to_hex(&bits);
+            BitViewerOperation::InvertAll => {
+                let current_bits = req.current_bits.unwrap_or_default();
+                let bit_string = bit_ops::bits_to_bit_string(&current_bits);
+                let updated_bit_string = bit_ops::invert_all(&bit_string).unwrap_or(bit_string);
 
                 BitViewerResponse {
                     id: req.id,
-                    hex_input,
-                    binary_bits: bits,
+                    hex_input: bit_ops::bit_string_to_hex(&updated_bit_string).unwrap_or_default(),
+                    binary_bits: bit_ops::bit_string_to_bits(&updated_bit_string)
+                        .unwrap_or_default(),
                     error: None,
                 }
             }
-            BitViewerOperation::InvertAll => {
-                let mut bits = req.current_bits.unwrap_or_default();
-                for bit in &mut bits {
-                    *bit = !*bit;
-                }
-                let hex_input = Self::bits_to_hex(&bits);
+            BitViewerOperation::ShiftLeft(count) => {
+                let current_bits = req.current_bits.unwrap_or_default();
+                let bit_string = bit_ops::bits_to_bit_string(&current_bits);
+                let updated_bit_string =
+                    bit_ops::shift_left(&bit_string, count, bit_ops::ShiftMode::ZeroFill)
+                        .unwrap_or(bit_string);
 
                 BitViewerResponse {
                     id: req.id,
-                    hex_input,
-                    binary_bits: bits,
+                    hex_input: bit_ops::bit_string_to_hex(&updated_bit_string).unwrap_or_default(),
+                    binary_bits: bit_ops::bit_string_to_bits(&updated_bit_string)
+                        .unwrap_or_default(),
                     error: None,
                 }
             }
-        }
-    }
-
-    fn bits_to_hex(bits: &[bool]) -> String {
-        if bits.is_empty() {
-            return String::new();
-        }
-
-        let mut hex_string = String::new();
-        let mut current_nibble = 0u8;
+            BitViewerOperation::ShiftRight(count) => {
+                let current_bits = req.current_bits.unwrap_or_default();
+                let bit_string = bit_ops::bits_to_bit_string(&current_bits);
+                let updated_bit_string =
+                    bit_ops::shift_right(&bit_string, count, bit_ops::ShiftMode::ZeroFill)
+                        .unwrap_or(bit_string);
 
-        for (i, &bit) in bits.iter().enumerate() {
-            let bit_pos = 3 - (i % 4);
-            if bit {
-                current_nibble |= 1 << bit_pos;
-            }
-
-            if (i + 1) % 4 == 0 {
-                hex_string.push_str(&format!("{:X}", current_nibble));
-                current_nibble = 0;
+                BitViewerResponse {
+                    id: req.id,
+                    hex_input: bit_ops::bit_string_to_hex(&updated_bit_string).unwrap_or_default(),
+                    binary_bits: bit_ops::bit_string_to_bits(&updated_bit_string)
+                        .unwrap_or_default(),
+                    error: None,
+                }
             }
         }
-
-        // Handle incomplete last nibble
-        if !bits.len().is_multiple_of(4) {
-            hex_string.push_str(&format!("{:X}", current_nibble));
-        }
-
-        hex_string
     }
 
     fn handle_calculator(req: CalculatorRequest) -> CalculatorResponse {