Encoder.pyw

import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
import base64
import time
import re

# ================= DPI 适配模块 =================
def enable_dpi_awareness():
    try:
        from ctypes import windll
        windll.shcore.SetProcessDpiAwareness(2)
    except:
        try:
            windll.user32.SetProcessDPIAware()
        except:
            pass

enable_dpi_awareness()


class RobustEncoderApp:
    def __init__(self, root):
        self.root = root
        self.root.title("encoder")
        # 设置窗口大小和最小尺寸
        self.root.geometry("800x700")
        self.root.minsize(600, 500)

        # 字体配置
        self.font_text = ("Consolas", 10)
        self.font_ui = ("Microsoft YaHei UI", 9)

        # --- 主容器 ---
        main_frame = ttk.Frame(root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)

        # --- 顶部：输入区域 ---
        input_label = ttk.Label(main_frame, text="input:", font=self.font_ui)
        input_label.pack(anchor=tk.W)

        self.input_text = scrolledtext.ScrolledText(
            main_frame, height=10, font=self.font_text, wrap=tk.WORD
        )
        self.input_text.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
        self._bind_context_menu(self.input_text)

        # --- 中部：控制区域 ---
        control_frame = ttk.LabelFrame(main_frame, text="settings", padding="10")
        control_frame.pack(fill=tk.X, pady=(0, 10))

        # 第一行：模式与格式
        row1 = ttk.Frame(control_frame)
        row1.pack(fill=tk.X, pady=5)

        ttk.Label(row1, text="work pattern:", font=self.font_ui).pack(side=tk.LEFT)

        # 【修改点】：下拉菜单选项改为中文 "编码" 和 "解码"
        self.mode_var = tk.StringVar(value="encoding")
        self.mode_combo = ttk.Combobox(
            row1, textvariable=self.mode_var, values=["encoding", "decoding"], width=10, state="readonly"
        )
        self.mode_combo.pack(side=tk.LEFT, padx=5)

        ttk.Label(row1, text="encode form:", font=self.font_ui).pack(side=tk.LEFT, padx=(20, 0))
        self.format_var = tk.StringVar(value="Hex")
        formats = ["Hex", "ASCII", "UTF-8", "GBK", "UTF-16", "UTF-32"]
        self.format_combo = ttk.Combobox(
            row1, textvariable=self.format_var, values=formats, width=10, state="readonly"
        )
        self.format_combo.pack(side=tk.LEFT, padx=5)

        # 第二行：选项与按钮
        row2 = ttk.Frame(control_frame)
        row2.pack(fill=tk.X, pady=5)

        self.separator_var = tk.BooleanVar(value=False)
        ttk.Checkbutton(
            row2, text="use, (only ASCII)", variable=self.separator_var
        ).pack(side=tk.LEFT)

        # 右侧按钮组
        btn_frame = ttk.Frame(row2)
        btn_frame.pack(side=tk.RIGHT)

        ttk.Button(btn_frame, text="clean all ", command=self.clear_all).pack(side=tk.RIGHT, padx=5)
        ttk.Button(btn_frame, text="begin", command=self.process_data, style="Accent.TButton").pack(
            side=tk.RIGHT
        )

        # --- 底部：输出与日志区域 ---
        output_label = ttk.Label(main_frame, text="result:", font=self.font_ui)
        output_label.pack(anchor=tk.W)

        self.output_text = scrolledtext.ScrolledText(
            main_frame, height=8, font=self.font_text, wrap=tk.WORD, state=tk.DISABLED
        )
        self.output_text.pack(fill=tk.BOTH, expand=True, pady=(0, 5))
        self._bind_context_menu(self.output_text)

        # 复制按钮
        copy_btn = ttk.Button(main_frame, text="copy", command=self.copy_result)
        copy_btn.pack(anchor=tk.E, pady=(0, 5))

        # 日志区域
        log_label = ttk.Label(main_frame, text="data:", font=self.font_ui)
        log_label.pack(anchor=tk.W)

        self.log_text = scrolledtext.ScrolledText(
            main_frame, height=4, font=("Consolas", 8), state=tk.DISABLED, bg="#f0f0f0"
        )
        self.log_text.pack(fill=tk.X, side=tk.BOTTOM)

        # 初始化日志
        self.log("Begin completely.include ASCII, Hex, GBK, UTF-16/32 .")

    # ================= 右键菜单（复制/粘贴/剪切/全选） =================

    def _bind_context_menu(self, widget):
        """为文本框绑定右键菜单，并附加 Ctrl+C/V/X/A 快捷键。"""
        menu = tk.Menu(widget, tearoff=0)
        menu.add_command(label="Cut", accelerator="Ctrl+X",
                         command=lambda: self._cut_text(widget))
        menu.add_command(label="Copy", accelerator="Ctrl+C",
                         command=lambda: self._copy_text(widget))
        menu.add_command(label="Paste", accelerator="Ctrl+V",
                         command=lambda: self._paste_text(widget))
        menu.add_separator()
        menu.add_command(label="Select All", accelerator="Ctrl+A",
                         command=lambda: self._select_all(widget))
        menu.add_command(label="Clear",
                         command=lambda: self._clear_text(widget))

        def show_menu(event):
            try:
                menu.tk_popup(event.x_root, event.y_root)
            finally:
                menu.grab_release()

        widget.bind("<Button-3>", show_menu)
        # 键盘快捷键：返回 "break" 以覆盖默认行为（对禁用状态的结果框尤其重要）
        widget.bind("<Control-c>", lambda e: self._copy_text(widget) or "break")
        widget.bind("<Control-C>", lambda e: self._copy_text(widget) or "break")
        widget.bind("<Control-v>", lambda e: self._paste_text(widget) or "break")
        widget.bind("<Control-V>", lambda e: self._paste_text(widget) or "break")
        widget.bind("<Control-x>", lambda e: self._cut_text(widget) or "break")
        widget.bind("<Control-X>", lambda e: self._cut_text(widget) or "break")
        widget.bind("<Control-a>", lambda e: self._select_all(widget) or "break")
        widget.bind("<Control-A>", lambda e: self._select_all(widget) or "break")

    def _is_disabled(self, widget):
        return str(widget.cget("state")) == "disabled"

    def _copy_text(self, widget):
        try:
            text = widget.get(tk.SEL_FIRST, tk.SEL_LAST)
        except tk.TclError:
            return
        self.root.clipboard_clear()
        self.root.clipboard_append(text)

    def _cut_text(self, widget):
        try:
            text = widget.get(tk.SEL_FIRST, tk.SEL_LAST)
        except tk.TclError:
            return
        self.root.clipboard_clear()
        self.root.clipboard_append(text)
        was_disabled = self._is_disabled(widget)
        if was_disabled:
            widget.config(state=tk.NORMAL)
        try:
            widget.delete(tk.SEL_FIRST, tk.SEL_LAST)
        except tk.TclError:
            pass
        finally:
            if was_disabled:
                widget.config(state=tk.DISABLED)

    def _paste_text(self, widget):
        try:
            text = widget.selection_get(selection="CLIPBOARD")
        except tk.TclError:
            return
        was_disabled = self._is_disabled(widget)
        if was_disabled:
            widget.config(state=tk.NORMAL)
        try:
            try:
                widget.delete(tk.SEL_FIRST, tk.SEL_LAST)
            except tk.TclError:
                pass
            widget.insert(tk.INSERT, text)
            widget.see(tk.INSERT)
        finally:
            if was_disabled:
                widget.config(state=tk.DISABLED)

    def _select_all(self, widget):
        widget.tag_remove(tk.SEL, "1.0", tk.END)
        widget.tag_add(tk.SEL, "1.0", "end-1c")
        widget.focus_set()

    def _clear_text(self, widget):
        was_disabled = self._is_disabled(widget)
        if was_disabled:
            widget.config(state=tk.NORMAL)
        try:
            widget.delete("1.0", tk.END)
        finally:
            if was_disabled:
                widget.config(state=tk.DISABLED)

    def log(self, message):
        """add data"""
        timestamp = time.strftime("[%H:%M:%S]")
        self.log_text.config(state=tk.NORMAL)
        self.log_text.insert(tk.END, f"{timestamp} {message}\n")
        self.log_text.see(tk.END)
        self.log_text.config(state=tk.DISABLED)

    def clear_all(self):
        self.input_text.delete(1.0, tk.END)
        self.output_text.config(state=tk.NORMAL)
        self.output_text.delete(1.0, tk.END)
        self.output_text.config(state=tk.DISABLED)
        self.log("clean completely")

    def copy_result(self):
        content = self.output_text.get(1.0, tk.END).strip()
        if content:
            self.root.clipboard_clear()
            self.root.clipboard_append(content)
            self.log("copy completely")
        else:
            messagebox.showwarning("tips", "nothing to copy")

    def process_data(self):
        raw_input = self.input_text.get(1.0, tk.END).strip()
        mode_cn = self.mode_var.get()
        fmt = self.format_var.get()
        use_sep = self.separator_var.get()

        if not raw_input:
            messagebox.showwarning("tips", "Please enter！")
            return

        result = ""
        try:
            # 【修改点】：将中文模式映射回英文逻辑变量，以便后续函数调用
            mode = "Encode" if mode_cn == "encoding" else "Decoding"

            if mode == "Encode":
                result = self.encode_data(raw_input, fmt, use_sep)
            else:
                result = self.decode_data(raw_input, fmt)

            self.output_text.config(state=tk.NORMAL)
            self.output_text.delete(1.0, tk.END)
            self.output_text.insert(tk.END, result)
            self.output_text.config(state=tk.DISABLED)
            self.log(f"compiete | pattern: {mode_cn} | form: {fmt}")

        except Exception as e:
            self.log(f"faise: {str(e)}")
            messagebox.showerror("fail", str(e))

    # ================= 核心逻辑 =================

    def encode_data(self, text, fmt, use_sep):
        data = text.encode(fmt)

        if fmt == "Hex":
            return data.hex().upper()

        elif fmt == "ASCII":
            nums = [str(b) for b in data]
            if use_sep:
                return ",".join(nums)
            else:
                return "".join(nums)

        else:
            return data.hex().upper()

    def decode_data(self, text, fmt):
        clean_text = text.replace(" ", "").replace("\n", "").replace("\r", "")

        if fmt == "Hex":
            if len(clean_text) % 2 != 0:
                raise ValueError("Hex please check your enter")
            byte_data = bytes.fromhex(clean_text)
            try:
                return byte_data.decode("utf-8")
            except UnicodeDecodeError:
                return f"[can not show]\nHex: {clean_text}"

        elif fmt == "ASCII":
            if "," in text:
                nums = text.split(",")
            else:
                nums = self.greedy_split_ascii(clean_text)

            byte_list = []
            for n in nums:
                val = int(n)
                if 0 <= val <= 255:
                    byte_list.append(val)
                else:
                    raise ValueError(f"Invalid ASCII : {val}")

            return bytes(byte_list).decode("ascii", errors="replace")

        else:
            if len(clean_text) % 2 != 0:
                raise ValueError(f"{fmt} data length anomaly: should be even.")
            byte_data = bytes.fromhex(clean_text)
            return byte_data.decode(fmt, errors="replace")

    def greedy_split_ascii(self, s):
        parts = []
        i = 0
        while i < len(s):
            if i + 3 <= len(s):
                chunk3 = s[i : i + 3]
                if 100 <= int(chunk3) <= 255:
                    parts.append(chunk3)
                    i += 3
                    continue

            if i + 2 <= len(s):
                chunk2 = s[i : i + 2]
                if 10 <= int(chunk2) <= 99:
                    parts.append(chunk2)
                    i += 2
                    continue

            chunk1 = s[i]
            parts.append(chunk1)
            i += 1

        return parts


if __name__ == "__main__":
    root = tk.Tk()
    app = RobustEncoderApp(root)
    root.mainloop()