SunsetMD---MarkDownEditor/markdown-editor-pro.py

import oss2
import configparser
import os
import sys
import markdown
import markdown.extensions
import json
import time
import hashlib
import uuid
from datetime import datetime
from PyQt5.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, 
                             QTextEdit, QSplitter, QAction, QFileDialog, QMessageBox,
                             QToolBar, QStatusBar, QWidget, QTreeView, QFileSystemModel,
                             QDockWidget, QComboBox, QFontComboBox, QLabel, QDialog,
                             QPushButton, QDialogButtonBox, QFormLayout, QSpinBox,
                             QCheckBox, QTabWidget, QListWidget, QListWidgetItem,
                             QProgressBar, QSystemTrayIcon, QMenu, QInputDialog,
                             QLineEdit, QGroupBox, QScrollArea, QShortcut, QTextBrowser)
from PyQt5.QtCore import Qt, QSettings, QDir, QTimer, QThread, pyqtSignal
from PyQt5.QtGui import (QFont, QKeySequence, QTextCursor, QColor, QSyntaxHighlighter, 
                         QTextCharFormat, QPalette, QIcon, QPixmap, QTextDocument,
                         QTextBlockFormat, QTextListFormat)
from PyQt5.QtWebEngineWidgets import QWebEngineView
from PyQt5.QtPrintSupport import QPrintDialog, QPrinter

class TextProcessor:
    """本地文本处理器 - 替代AI功能"""
    
    @staticmethod
    def improve_writing(text):
        """改进写作 - 本地规则处理"""
        improvements = []
        lines = text.split('\n')
        
        for i, line in enumerate(lines):
            if len(line.strip()) > 0:
                # 自动在句号后加空格（如果忘记）
                line = line.replace('。', '。 ')
                line = line.replace('！', '！ ')
                line = line.replace('？', '？ ')
                
                # 移除多余的空格
                line = ' '.join(line.split())
                
                lines[i] = line
        
        improved_text = '\n'.join(lines)
        return f"改进建议：\n\n{improved_text}\n\n* 已优化标点符号和空格 *"
    
    @staticmethod
    def summarize_text(text):
        """文本摘要 - 本地处理"""
        words = text.split()
        if len(words) <= 50:
            return f"文本较短，无需摘要：\n\n{text}"
        
        # 简单的摘要算法 - 取首句和关键词
        sentences = text.split('。')
        if len(sentences) > 1:
            summary = sentences[0] + '。'
            if len(sentences) > 2:
                summary += sentences[1] + '。'
        else:
            summary = text[:100] + '...'
        
        word_count = len(words)
        char_count = len(text)
        
        return f"摘要：\n\n{summary}\n\n原文统计：{word_count} 词，{char_count} 字符"
    
    @staticmethod
    def check_grammar(text):
        """语法检查 - 本地规则"""
        issues = []
        
        # 检查常见中文标点错误
        if ' ,' in text or ' .' in text:
            issues.append("中英文标点混用")
        
        # 检查连续空格
        if '  ' in text:
            issues.append("存在连续空格")
        
        # 检查段落开头空格
        lines = text.split('\n')
        for i, line in enumerate(lines[:10]):  # 只检查前10行
            if line.strip() and not line.startswith('#') and not line.startswith('>'):
                if not line.startswith('    ') and len(line) > 0:
                    if line[0] not in ['-', '*', '+', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']:
                        # 检查是否应该缩进
                        pass
        
        if not issues:
            return "语法检查完成。未发现明显问题。"
        else:
            return f"语法检查完成。发现以下建议：\n\n" + "\n".join(f"- {issue}" for issue in issues)

class LocalAIAssistant(QThread):
    """本地AI助手线程"""
    response_received = pyqtSignal(str)
    error_occurred = pyqtSignal(str)
    
    def __init__(self, action_type, text):
        super().__init__()
        self.action_type = action_type
        self.text = text
        self.processor = TextProcessor()
        
    def run(self):
        try:
            time.sleep(1)  # 模拟处理时间
            
            if self.action_type == "improve_writing":
                response = self.processor.improve_writing(self.text)
            elif self.action_type == "summarize":
                response = self.processor.summarize_text(self.text)
            elif self.action_type == "check_grammar":
                response = self.processor.check_grammar(self.text)
            else:
                response = "本地AI处理完成"
            
            self.response_received.emit(response)
            
        except Exception as e:
            self.error_occurred.emit(str(e))

class AdvancedMarkdownHighlighter(QSyntaxHighlighter):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.highlighting_rules = []
        self.setup_rules()
        
    def setup_rules(self):
        # 标题格式
        header_format = QTextCharFormat()
        header_format.setForeground(QColor("#e74c3c"))
        header_format.setFontWeight(QFont.Bold)
        self.highlighting_rules.append((r'^#{1,6}\s.*', header_format))
        
        # 粗体格式
        bold_format = QTextCharFormat()
        bold_format.setFontWeight(QFont.Bold)
        bold_format.setForeground(QColor("#2980b9"))
        self.highlighting_rules.append((r'\*\*.*?\*\*', bold_format))
        self.highlighting_rules.append((r'__.*?__', bold_format))
        
        # 斜体格式
        italic_format = QTextCharFormat()
        italic_format.setFontItalic(True)
        italic_format.setForeground(QColor("#8e44ad"))
        self.highlighting_rules.append((r'\*.*?\*', italic_format))
        self.highlighting_rules.append((r'_.*?_', italic_format))
        
        # 删除线格式
        strike_format = QTextCharFormat()
        strike_format.setForeground(QColor("#95a5a6"))
        strike_format.setFontStrikeOut(True)
        self.highlighting_rules.append((r'~~.*?~~', strike_format))
        
        # 代码格式
        code_format = QTextCharFormat()
        code_format.setForeground(QColor("#c7254e"))
        code_format.setBackground(QColor("#f9f2f4"))
        code_format.setFontFamily("Consolas")
        self.highlighting_rules.append((r'`[^`]*`', code_format))
        
        # 代码块格式
        code_block_format = QTextCharFormat()
        code_block_format.setForeground(QColor("#333"))
        code_block_format.setBackground(QColor("#f8f8f8"))
        code_block_format.setFontFamily("Consolas")
        self.highlighting_rules.append((r'```.*?```', code_block_format))
        
        # 链接格式
        link_format = QTextCharFormat()
        link_format.setForeground(QColor("#3498db"))
        link_format.setUnderlineStyle(QTextCharFormat.SingleUnderline)
        self.highlighting_rules.append((r'\[.*?\]\(.*?\)', link_format))
        
        # 图片格式
        image_format = QTextCharFormat()
        image_format.setForeground(QColor("#9b59b6"))
        image_format.setFontItalic(True)
        self.highlighting_rules.append((r'!\[.*?\]\(.*?\)', image_format))
        
        # 列表格式
        list_format = QTextCharFormat()
        list_format.setForeground(QColor("#27ae60"))
        self.highlighting_rules.append((r'^[\*\-\+]\s.*', list_format))
        self.highlighting_rules.append((r'^\d+\.\s.*', list_format))
        
        # 引用格式
        quote_format = QTextCharFormat()
        quote_format.setForeground(QColor("#7f8c8d"))
        quote_format.setFontItalic(True)
        self.highlighting_rules.append((r'^>.*', quote_format))
        
        # 表格格式
        table_format = QTextCharFormat()
        table_format.setForeground(QColor("#d35400"))
        self.highlighting_rules.append((r'^\|.*\|.*', table_format))

    def highlightBlock(self, text):
        for pattern, format in self.highlighting_rules:
            import re
            for match in re.finditer(pattern, text, re.MULTILINE | re.DOTALL):
                start, end = match.span()
                self.setFormat(start, end - start, format)

class FileExplorer(QDockWidget):
    def __init__(self, parent=None):
        super().__init__("文件浏览器", parent)
        self.parent = parent
        self.initUI()
        
    def initUI(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # 路径导航和操作按钮
        path_layout = QHBoxLayout()
        
        self.path_edit = QLineEdit()
        self.path_edit.setPlaceholderText("输入路径或点击浏览...")
        self.path_edit.returnPressed.connect(self.navigate_to_path)
        path_layout.addWidget(self.path_edit)
        
        self.browse_btn = QPushButton("浏览")
        self.browse_btn.clicked.connect(self.browse_directory)
        path_layout.addWidget(self.browse_btn)
        
        layout.addLayout(path_layout)
        
        # 搜索框
        search_layout = QHBoxLayout()
        self.search_box = QLineEdit()
        self.search_box.setPlaceholderText("搜索文件...")
        self.search_box.textChanged.connect(self.filter_files)
        search_layout.addWidget(QLabel("搜索:"))
        search_layout.addWidget(self.search_box)
        
        layout.addLayout(search_layout)
        
        # 文件类型过滤
        filter_layout = QHBoxLayout()
        self.filter_combo = QComboBox()
        self.filter_combo.addItems([
            "所有文件 (*)",
            "文档文件 (*.md *.txt *.markdown *.doc *.docx *.pdf)",
            "图片文件 (*.png *.jpg *.jpeg *.gif *.bmp *.svg)",
            "代码文件 (*.py *.java *.cpp *.c *.html *.css *.js *.json *.xml)",
            "媒体文件 (*.mp3 *.mp4 *.avi *.mov *.wav)"
        ])
        self.filter_combo.currentTextChanged.connect(self.apply_filter)
        filter_layout.addWidget(QLabel("过滤:"))
        filter_layout.addWidget(self.filter_combo)
        
        layout.addLayout(filter_layout)
        
        # 文件树视图
        self.model = QFileSystemModel()
        self.model.setRootPath(QDir.homePath())
        
        # 设置列宽
        self.model.setHeaderData(0, Qt.Horizontal, "名称")
        self.model.setHeaderData(1, Qt.Horizontal, "大小")
        self.model.setHeaderData(2, Qt.Horizontal, "类型")
        self.model.setHeaderData(3, Qt.Horizontal, "修改时间")
        
        self.tree = QTreeView()
        self.tree.setModel(self.model)
        self.tree.setRootIndex(self.model.index(QDir.homePath()))
        self.tree.doubleClicked.connect(self.on_file_double_click)
        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
        self.tree.customContextMenuRequested.connect(self.show_context_menu)
        
        # 设置列宽
        self.tree.setColumnWidth(0, 250)  # 名称列宽一些
        self.tree.setColumnWidth(1, 80)   # 大小
        self.tree.setColumnWidth(2, 100)  # 类型
        self.tree.setColumnWidth(3, 120)  # 修改时间
        
        # 隐藏不需要的列（如有）
        # self.tree.hideColumn(1)  # 可以根据需要隐藏某些列
        
        layout.addWidget(self.tree)
        
        # 状态栏
        status_layout = QHBoxLayout()
        self.status_label = QLabel("就绪")
        status_layout.addWidget(self.status_label)
        status_layout.addStretch()
        
        self.refresh_btn = QPushButton("刷新")
        self.refresh_btn.clicked.connect(self.refresh_view)
        status_layout.addWidget(self.refresh_btn)
        
        layout.addLayout(status_layout)
        self.setWidget(widget)
        
        # 更新路径显示
        self.update_path_display(QDir.homePath())
        
    def update_path_display(self, path):
        """更新路径显示"""
        self.path_edit.setText(path)
        self.status_label.setText(f"浏览: {path}")
        
    def navigate_to_path(self):
        """导航到输入的路径"""
        path = self.path_edit.text()
        if os.path.exists(path):
            if os.path.isdir(path):
                self.tree.setRootIndex(self.model.index(path))
                self.update_path_display(path)
            else:
                QMessageBox.information(self, "提示", "请输入有效的文件夹路径")
        else:
            QMessageBox.warning(self, "错误", "路径不存在")
            
    def browse_directory(self):
        """浏览选择目录"""
        directory = QFileDialog.getExistingDirectory(
            self, "选择目录", 
            self.path_edit.text() or QDir.homePath()
        )
        if directory:
            self.tree.setRootIndex(self.model.index(directory))
            self.update_path_display(directory)
        
    def filter_files(self, text):
        """过滤文件"""
        if text:
            # 使用代理模型进行过滤
            from PyQt5.QtCore import QSortFilterProxyModel
            
            proxy_model = QSortFilterProxyModel()
            proxy_model.setSourceModel(self.model)
            proxy_model.setFilterRegExp(text)
            proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
            self.tree.setModel(proxy_model)
        else:
            # 恢复原始模型
            self.tree.setModel(self.model)
            self.tree.setRootIndex(self.model.index(self.path_edit.text() or QDir.homePath()))
        
    def apply_filter(self, filter_text):
        """应用文件类型过滤"""
        if filter_text == "所有文件 (*)":
            self.model.setNameFilters([])
        elif filter_text == "文档文件 (*.md *.txt *.markdown *.doc *.docx *.pdf)":
            self.model.setNameFilters(["*.md", "*.txt", "*.markdown", "*.doc", "*.docx", "*.pdf"])
        elif filter_text == "图片文件 (*.png *.jpg *.jpeg *.gif *.bmp *.svg)":
            self.model.setNameFilters(["*.png", "*.jpg", "*.jpeg", "*.gif", "*.bmp", "*.svg"])
        elif filter_text == "代码文件 (*.py *.java *.cpp *.c *.html *.css *.js *.json *.xml)":
            self.model.setNameFilters(["*.py", "*.java", "*.cpp", "*.c", "*.html", "*.css", "*.js", "*.json", "*.xml"])
        elif filter_text == "媒体文件 (*.mp3 *.mp4 *.avi *.mov *.wav)":
            self.model.setNameFilters(["*.mp3", "*.mp4", "*.avi", "*.mov", "*.wav"])
        
        self.model.setNameFilterDisables(False)
        self.refresh_view()
            
    def on_file_double_click(self, index):
        path = self.model.filePath(index)
        if os.path.isfile(path):
            # 根据文件类型处理
            if path.endswith(('.md', '.txt', '.markdown')):
                self.parent.open_file(path)
            else:
                # 尝试用系统默认程序打开其他文件
                try:
                    import subprocess
                    if os.name == 'nt':  # Windows
                        os.startfile(path)
                    elif os.name == 'posix':  # Linux, macOS
                        subprocess.call(('open' if sys.platform == 'darwin' else 'xdg-open', path))
                except Exception as e:
                    QMessageBox.information(self, "打开文件", f"无法打开文件: {str(e)}")
        else:
            # 如果是文件夹，导航到该文件夹
            self.tree.setRootIndex(self.model.index(path))
            self.update_path_display(path)
            
    def show_context_menu(self, position):
        """显示右键菜单"""
        index = self.tree.indexAt(position)
        if not index.isValid():
            return
            
        path = self.model.filePath(index)
        menu = QMenu()
        
        if os.path.isfile(path):
            open_action = menu.addAction("打开")
            open_with_action = menu.addAction("用系统程序打开")
            menu.addSeparator()
            
            if path.endswith(('.md', '.txt', '.markdown')):
                open_action.triggered.connect(lambda: self.parent.open_file(path))
            else:
                open_action.triggered.connect(lambda: self.open_with_system(path))
                
            open_with_action.triggered.connect(lambda: self.open_with_system(path))
            
        else:
            open_folder_action = menu.addAction("打开文件夹")
            open_folder_action.triggered.connect(lambda: self.tree.setRootIndex(index))
            
        menu.addSeparator()
        
        rename_action = menu.addAction("重命名")
        delete_action = menu.addAction("删除")
        menu.addSeparator()
        
        properties_action = menu.addAction("属性")
        
        # 连接信号
        rename_action.triggered.connect(lambda: self.rename_item(index))
        delete_action.triggered.connect(lambda: self.delete_item(index))
        properties_action.triggered.connect(lambda: self.show_properties(index))
        
        menu.exec_(self.tree.mapToGlobal(position))
        
    def open_with_system(self, path):
        """用系统默认程序打开文件"""
        try:
            import subprocess
            if os.name == 'nt':  # Windows
                os.startfile(path)
            elif os.name == 'posix':  # Linux, macOS
                subprocess.call(('open' if sys.platform == 'darwin' else 'xdg-open', path))
        except Exception as e:
            QMessageBox.critical(self, "错误", f"无法打开文件: {str(e)}")
            
    def rename_item(self, index):
        """重命名文件或文件夹"""
        old_path = self.model.filePath(index)
        old_name = os.path.basename(old_path)
        
        new_name, ok = QInputDialog.getText(
            self, "重命名", "输入新名称:", text=old_name
        )
        
        if ok and new_name and new_name != old_name:
            try:
                new_path = os.path.join(os.path.dirname(old_path), new_name)
                os.rename(old_path, new_path)
                self.refresh_view()
            except Exception as e:
                QMessageBox.critical(self, "错误", f"重命名失败: {str(e)}")
                
    def delete_item(self, index):
        """删除文件或文件夹"""
        path = self.model.filePath(index)
        name = os.path.basename(path)
        
        reply = QMessageBox.question(
            self, "确认删除", 
            f"确定要删除 '{name}' 吗？此操作不可撤销！",
            QMessageBox.Yes | QMessageBox.No,
            QMessageBox.No
        )
        
        if reply == QMessageBox.Yes:
            try:
                if os.path.isfile(path):
                    os.remove(path)
                else:
                    import shutil
                    shutil.rmtree(path)
                self.refresh_view()
            except Exception as e:
                QMessageBox.critical(self, "错误", f"删除失败: {str(e)}")
                
    def show_properties(self, index):
        """显示文件属性"""
        path = self.model.filePath(index)
        name = os.path.basename(path)
        
        try:
            stat = os.stat(path)
            size = stat.st_size
            modified = datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S")
            created = datetime.fromtimestamp(stat.st_ctime).strftime("%Y-%m-%d %H:%M:%S")
            
            if os.path.isfile(path):
                file_type = "文件"
                import mimetypes
                mime_type, _ = mimetypes.guess_type(path)
                file_type += f" ({mime_type or '未知类型'})"
            else:
                file_type = "文件夹"
                # 计算文件夹中的文件数量
                file_count = sum(len(files) for _, _, files in os.walk(path))
                file_type += f" ({file_count} 个项目)"
            
            message = f"""
名称: {name}
路径: {path}
类型: {file_type}
大小: {self.format_file_size(size)}
创建时间: {created}
修改时间: {modified}
            """.strip()
            
            QMessageBox.information(self, "属性", message)
            
        except Exception as e:
            QMessageBox.critical(self, "错误", f"无法获取属性: {str(e)}")
            
    def format_file_size(self, size):
        """格式化文件大小"""
        for unit in ['B', 'KB', 'MB', 'GB']:
            if size < 1024.0:
                return f"{size:.1f} {unit}"
            size /= 1024.0
        return f"{size:.1f} TB"
        
    def refresh_view(self):
        """刷新视图"""
        current_path = self.path_edit.text() or QDir.homePath()
        self.tree.setRootIndex(self.model.index(current_path))

class SettingsDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.parent = parent
        self.initUI()
        
    def initUI(self):
        self.setWindowTitle("设置")
        self.setModal(True)
        self.resize(500, 400)
        
        layout = QVBoxLayout(self)
        
        # 创建标签页
        tab_widget = QTabWidget()
        
        # 编辑器设置
        editor_tab = QWidget()
        editor_layout = QFormLayout(editor_tab)
        
        self.font_combo = QFontComboBox()
        self.font_combo.setCurrentFont(QFont(self.parent.editor_font))
        editor_layout.addRow("编辑器字体:", self.font_combo)
        
        self.font_size = QSpinBox()
        self.font_size.setRange(8, 72)
        self.font_size.setValue(self.parent.editor_font_size)
        editor_layout.addRow("字体大小:", self.font_size)
        
        self.theme_combo = QComboBox()
        self.theme_combo.addItems(["默认", "暗色", "护眼绿", "深蓝"])
        self.theme_combo.setCurrentText(self.parent.current_theme)
        editor_layout.addRow("主题:", self.theme_combo)
        
        tab_widget.addTab(editor_tab, "编辑器")
        
        # 自动保存设置
        save_tab = QWidget()
        save_layout = QFormLayout(save_tab)
        
        self.auto_save = QCheckBox("启用自动保存")
        self.auto_save.setChecked(self.parent.auto_save_enabled)
        save_layout.addRow(self.auto_save)
        
        self.auto_save_interval = QSpinBox()
        self.auto_save_interval.setRange(1, 60)
        self.auto_save_interval.setValue(self.parent.auto_save_interval)
        self.auto_save_interval.setSuffix(" 分钟")
        save_layout.addRow("自动保存间隔:", self.auto_save_interval)
        
        self.backup_enabled = QCheckBox("启用自动备份")
        self.backup_enabled.setChecked(self.parent.backup_enabled)
        save_layout.addRow(self.backup_enabled)
        
        tab_widget.addTab(save_tab, "自动保存")
        
        # AI助手设置
        ai_tab = QWidget()
        ai_layout = QFormLayout(ai_tab)
        
        self.ai_enabled = QCheckBox("启用AI助手功能")
        self.ai_enabled.setChecked(self.parent.ai_assistant_enabled)
        ai_layout.addRow(self.ai_enabled)
        
        ai_info = QLabel("AI助手使用本地文本处理技术，无需网络连接")
        ai_info.setWordWrap(True)
        ai_layout.addRow(ai_info)
        
        tab_widget.addTab(ai_tab, "AI助手")
        
        # 云同步设置
        cloud_tab = QWidget()
        cloud_layout = QFormLayout(cloud_tab)
        
        self.cloud_enabled = QCheckBox("启用云同步")
        self.cloud_enabled.setChecked(self.parent.cloud_sync_enabled)
        cloud_layout.addRow(self.cloud_enabled)
        
        cloud_info = QLabel("云同步功能将文件备份到阿里云OSS")
        cloud_info.setWordWrap(True)
        cloud_layout.addRow(cloud_info)
        
        tab_widget.addTab(cloud_tab, "云同步")
        
        layout.addWidget(tab_widget)
        
        # 按钮
        buttons = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
            Qt.Horizontal, self
        )
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)
        
    def accept(self):
        self.parent.editor_font = self.font_combo.currentFont().family()
        self.parent.editor_font_size = self.font_size.value()
        self.parent.current_theme = self.theme_combo.currentText()
        self.parent.auto_save_enabled = self.auto_save.isChecked()
        self.parent.auto_save_interval = self.auto_save_interval.value()
        self.parent.backup_enabled = self.backup_enabled.isChecked()
        self.parent.ai_assistant_enabled = self.ai_enabled.isChecked()
        self.parent.cloud_sync_enabled = self.cloud_enabled.isChecked()
        
        self.parent.apply_settings()
        super().accept()

class ProfessionalMarkdownEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.current_file = None
        self.recent_files = []
        self.settings = QSettings("SunsetMD", "SunsetMD Pro")
        self.auto_save_timer = QTimer()
        self.auto_save_timer.timeout.connect(self.auto_save)
        self.backup_timer = QTimer()
        self.backup_timer.timeout.connect(self.create_backup)
        
        # 默认设置
        self.editor_font = "Consolas"
        self.editor_font_size = 12
        self.current_theme = "默认"
        self.auto_save_enabled = False
        self.auto_save_interval = 5
        self.backup_enabled = True
        self.ai_assistant_enabled = True
        self.cloud_sync_enabled = True
        
        self.initUI()
        self.load_settings()
        
    def initUI(self):
        self.setWindowTitle("SunsetMD Pro - 专业Markdown编辑器")
        self.setGeometry(100, 100, 1600, 1000)
        
        # 设置应用图标
        self.set_application_icon()
        
        # 创建中央部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QHBoxLayout(central_widget)
        
        # 创建标签页
        self.tab_widget = QTabWidget()
        self.tab_widget.setTabsClosable(True)
        self.tab_widget.tabCloseRequested.connect(self.close_tab)
        layout.addWidget(self.tab_widget)
        
        # 创建新标签页
        self.create_new_tab()
        
        # 创建文件浏览器
        self.file_explorer = FileExplorer(self)
        self.addDockWidget(Qt.LeftDockWidgetArea, self.file_explorer)
        
        # 创建大纲视图
        self.outline_dock = QDockWidget("文档大纲", self)
        self.outline_widget = QListWidget()
        self.outline_dock.setWidget(self.outline_widget)
        self.addDockWidget(Qt.RightDockWidgetArea, self.outline_dock)
        
        # 创建菜单
        self.create_menus()
        
        # 创建工具栏
        self.create_toolbar()
        
        # 状态栏
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        
        # 进度条
        self.progress_bar = QProgressBar()
        self.progress_bar.setVisible(False)
        self.status_bar.addPermanentWidget(self.progress_bar)
        
        # 更新状态
        self.update_status()
        
        # 创建系统托盘
        self.create_system_tray()
        
        # 设置任务栏图标
        self.set_taskbar_icon()
        
    def set_application_icon(self):
        """设置应用图标"""
        try:
            # 尝试从icons目录加载图标
            icon_path = "./icons/ssmd.png"
            if os.path.exists(icon_path):
                app_icon = QIcon(icon_path)
                self.setWindowIcon(app_icon)
                QApplication.setWindowIcon(app_icon)
            else:
                # 如果图标文件不存在，创建一个简单的默认图标
                self.create_default_icon()
        except Exception as e:
            print(f"加载图标失败: {e}")
            self.create_default_icon()
            
    def create_default_icon(self):
        """创建默认图标"""
        try:
            # 创建一个简单的默认图标
            pixmap = QPixmap(64, 64)
            pixmap.fill(QColor("#3498db"))  # 蓝色背景
            
            # 在图标上绘制"M"字母
            from PyQt5.QtGui import QPainter, QPen
            painter = QPainter(pixmap)
            painter.setPen(QPen(QColor("white")))
            painter.setFont(QFont("Arial", 32, QFont.Bold))
            painter.drawText(pixmap.rect(), Qt.AlignCenter, "M")
            painter.end()
            
            app_icon = QIcon(pixmap)
            self.setWindowIcon(app_icon)
            QApplication.setWindowIcon(app_icon)
        except Exception as e:
            print(f"创建默认图标失败: {e}")
            
    def set_taskbar_icon(self):
        """设置任务栏图标"""
        try:
            # 在Windows上设置任务栏图标
            if sys.platform == "win32":
                import ctypes
                myappid = 'sunsetmd.pro.editor.2.0'
                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
        except Exception as e:
            print(f"设置任务栏图标失败: {e}")
        
    def create_system_tray(self):
        if not QSystemTrayIcon.isSystemTrayAvailable():
            return
            
        self.tray_icon = QSystemTrayIcon(self)
        
        # 设置托盘图标
        try:
            icon_path = "./icons/ssmd.png"
            if os.path.exists(icon_path):
                self.tray_icon.setIcon(QIcon(icon_path))
            else:
                # 使用窗口图标作为托盘图标
                self.tray_icon.setIcon(self.windowIcon())
        except:
            pass
            
        self.tray_icon.setToolTip("SunsetMD Pro")
        
        tray_menu = QMenu(self)
        show_action = tray_menu.addAction("显示")
        show_action.triggered.connect(self.show_normal)
        tray_menu.addSeparator()
        quit_action = tray_menu.addAction("退出")
        quit_action.triggered.connect(self.quit_application)
        
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.activated.connect(self.tray_icon_activated)
        self.tray_icon.show()
        
        # 托盘图标消息
        self.tray_icon.showMessage(
            "SunsetMD Pro", 
            "应用程序已启动并运行在系统托盘中",
            QSystemTrayIcon.Information, 
            2000
        )
        
    def show_normal(self):
        """显示窗口并置顶"""
        self.show()
        self.setWindowState(self.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
        self.activateWindow()
        self.raise_()
        
    def tray_icon_activated(self, reason):
        if reason == QSystemTrayIcon.DoubleClick:
            self.show_normal()
        elif reason == QSystemTrayIcon.Trigger:
            if self.isVisible():
                self.hide()
            else:
                self.show_normal()
                
    def quit_application(self):
        self.save_settings()
        QApplication.quit()

    def create_new_tab(self, file_path=None):
        # 创建分割器
        splitter = QSplitter(Qt.Horizontal)
        
        # 左侧编辑器
        editor = QTextEdit()
        editor.setFont(QFont(self.editor_font, self.editor_font_size))
        
        # 应用语法高亮
        highlighter = AdvancedMarkdownHighlighter(editor.document())
        
        # 右侧预览
        preview = QWebEngineView()
        preview.setHtml(self.get_preview_html(""))
        
        splitter.addWidget(editor)
        splitter.addWidget(preview)
        splitter.setSizes([600, 600])
        
        # 连接信号
        editor.textChanged.connect(lambda: self.update_preview(editor, preview))
        editor.textChanged.connect(self.update_outline)
        editor.textChanged.connect(self.update_status)
        
        # 添加标签页
        if file_path:
            tab_name = os.path.basename(file_path)
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    editor.setPlainText(f.read())
            except Exception as e:
                QMessageBox.critical(self, "错误", f"打开文件失败: {str(e)}")
                return
        else:
            tab_name = "新文档"
            
        index = self.tab_widget.addTab(splitter, tab_name)
        self.tab_widget.setCurrentIndex(index)
        
        # 设置标签页图标
        self.set_tab_icon(index, file_path)
        
        # 设置当前文件
        if file_path:
            self.current_file = file_path
            self.add_to_recent_files(file_path)
            
        return editor, preview

    def set_tab_icon(self, index, file_path=None):
        """设置标签页图标"""
        try:
            if file_path and file_path.endswith('.md'):
                # Markdown文件图标
                icon_path = "./icons/markdown_icon.png"
                if os.path.exists(icon_path):
                    self.tab_widget.setTabIcon(index, QIcon(icon_path))
            else:
                # 新文件图标
                icon_path = "./icons/new_file_icon.png"
                if os.path.exists(icon_path):
                    self.tab_widget.setTabIcon(index, QIcon(icon_path))
        except:
            pass  # 如果图标加载失败，忽略错误

    def create_menus(self):
        menubar = self.menuBar()
        
        # 文件菜单
        file_menu = menubar.addMenu("文件")
        
        new_action = QAction("新建", self)
        new_action.setShortcut(QKeySequence.New)
        new_action.triggered.connect(self.new_file)
        file_menu.addAction(new_action)
        
        new_tab_action = QAction("新建标签页", self)
        new_tab_action.setShortcut("Ctrl+T")
        new_tab_action.triggered.connect(lambda: self.create_new_tab())
        file_menu.addAction(new_tab_action)
        
        open_action = QAction("打开", self)
        open_action.setShortcut(QKeySequence.Open)
        open_action.triggered.connect(self.open_file)
        file_menu.addAction(open_action)
        
        # 最近文件子菜单
        self.recent_menu = file_menu.addMenu("最近文件")
        self.update_recent_menu()
        
        file_menu.addSeparator()
        
        save_action = QAction("保存", self)
        save_action.setShortcut(QKeySequence.Save)
        save_action.triggered.connect(self.save_file)
        file_menu.addAction(save_action)
        
        save_as_action = QAction("另存为", self)
        save_as_action.setShortcut(QKeySequence.SaveAs)
        save_as_action.triggered.connect(self.save_as_file)
        file_menu.addAction(save_as_action)
        
        save_all_action = QAction("全部保存", self)
        save_all_action.setShortcut("Ctrl+Shift+S")
        save_all_action.triggered.connect(self.save_all_files)
        file_menu.addAction(save_all_action)
        
        file_menu.addSeparator()
        
        # 导入导出子菜单
        import_export_menu = file_menu.addMenu("导入导出")
        
        export_html_action = QAction("导出HTML", self)
        export_html_action.triggered.connect(self.export_html)
        import_export_menu.addAction(export_html_action)
        
        export_pdf_action = QAction("导出PDF", self)
        export_pdf_action.triggered.connect(self.export_pdf)
        import_export_menu.addAction(export_pdf_action)
        
        file_menu.addSeparator()
        
        print_action = QAction("打印", self)
        print_action.setShortcut(QKeySequence.Print)
        print_action.triggered.connect(self.print_document)
        file_menu.addAction(print_action)
        
        file_menu.addSeparator()
        
        exit_action = QAction("退出", self)
        exit_action.setShortcut(QKeySequence.Quit)
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # 编辑菜单
        edit_menu = menubar.addMenu("编辑")
        
        undo_action = QAction("撤销", self)
        undo_action.setShortcut(QKeySequence.Undo)
        undo_action.triggered.connect(self.undo)
        edit_menu.addAction(undo_action)
        
        redo_action = QAction("重做", self)
        redo_action.setShortcut(QKeySequence.Redo)
        redo_action.triggered.connect(self.redo)
        edit_menu.addAction(redo_action)
        
        edit_menu.addSeparator()
        
        cut_action = QAction("剪切", self)
        cut_action.setShortcut(QKeySequence.Cut)
        cut_action.triggered.connect(self.cut)
        edit_menu.addAction(cut_action)
        
        copy_action = QAction("复制", self)
        copy_action.setShortcut(QKeySequence.Copy)
        copy_action.triggered.connect(self.copy)
        edit_menu.addAction(copy_action)
        
        paste_action = QAction("粘贴", self)
        paste_action.setShortcut(QKeySequence.Paste)
        paste_action.triggered.connect(self.paste)
        edit_menu.addAction(paste_action)
        
        # AI助手菜单
        ai_menu = menubar.addMenu("AI助手")
        
        improve_writing_action = QAction("改进写作", self)
        improve_writing_action.triggered.connect(lambda: self.ai_assistant("improve_writing"))
        ai_menu.addAction(improve_writing_action)
        
        summarize_action = QAction("文本摘要", self)
        summarize_action.triggered.connect(lambda: self.ai_assistant("summarize"))
        ai_menu.addAction(summarize_action)
        
        check_grammar_action = QAction("语法检查", self)
        check_grammar_action.triggered.connect(lambda: self.ai_assistant("check_grammar"))
        ai_menu.addAction(check_grammar_action)
        
        # 视图菜单
        view_menu = menubar.addMenu("视图")
        
        toggle_explorer_action = QAction("切换文件浏览器", self)
        toggle_explorer_action.setShortcut("F2")
        toggle_explorer_action.triggered.connect(self.toggle_file_explorer)
        view_menu.addAction(toggle_explorer_action)
        
        toggle_preview_action = QAction("切换预览", self)
        toggle_preview_action.setShortcut("F9")
        toggle_preview_action.triggered.connect(self.toggle_preview)
        view_menu.addAction(toggle_preview_action)
        
        toggle_outline_action = QAction("切换大纲", self)
        toggle_outline_action.setShortcut("F10")
        toggle_outline_action.triggered.connect(self.toggle_outline)
        view_menu.addAction(toggle_outline_action)
        
        # 格式菜单
        format_menu = menubar.addMenu("格式")
        
        bold_action = QAction("粗体", self)
        bold_action.setShortcut("Ctrl+B")
        bold_action.triggered.connect(self.insert_bold)
        format_menu.addAction(bold_action)
        
        italic_action = QAction("斜体", self)
        italic_action.setShortcut("Ctrl+I")
        italic_action.triggered.connect(self.insert_italic)
        format_menu.addAction(italic_action)
        
        format_menu.addSeparator()
        
        for i in range(1, 7):
            heading_action = QAction(f"标题 {i}", self)
            heading_action.setShortcut(f"Ctrl+{i}")
            heading_action.triggered.connect(lambda checked, level=i: self.insert_heading(level))
            format_menu.addAction(heading_action)
            
        # 表格菜单
        table_menu = format_menu.addMenu("表格")
        insert_table_action = QAction("插入表格", self)
        insert_table_action.triggered.connect(self.insert_table)
        table_menu.addAction(insert_table_action)
        
        # 工具菜单
        tools_menu = menubar.addMenu("工具")
        
        settings_action = QAction("设置", self)
        settings_action.triggered.connect(self.show_settings)
        tools_menu.addAction(settings_action)
        
        word_count_action = QAction("字数统计", self)
        word_count_action.triggered.connect(self.show_word_count)
        tools_menu.addAction(word_count_action)
        
        tools_menu.addSeparator()
        
        backup_action = QAction("创建备份", self)
        backup_action.triggered.connect(self.create_backup)
        tools_menu.addAction(backup_action)
        
        restore_action = QAction("恢复备份", self)
        restore_action.triggered.connect(self.restore_backup)
        tools_menu.addAction(restore_action)
        
    def create_toolbar(self):
        # 主工具栏
        main_toolbar = QToolBar("主工具栏")
        self.addToolBar(main_toolbar)
        
        # 设置工具栏图标
        try:
            icon_path = "./icons/new_icon.png"
            if os.path.exists(icon_path):
                new_btn = QAction(QIcon(icon_path), "新建", self)
            else:
                new_btn = QAction("新建", self)
        except:
            new_btn = QAction("新建", self)
            
        new_btn.triggered.connect(self.new_file)
        main_toolbar.addAction(new_btn)
        
        try:
            icon_path = "./icons/open_icon.png"
            if os.path.exists(icon_path):
                open_btn = QAction(QIcon(icon_path), "打开", self)
            else:
                open_btn = QAction("打开", self)
        except:
            open_btn = QAction("打开", self)
            
        open_btn.triggered.connect(self.open_file)
        main_toolbar.addAction(open_btn)
        
        try:
            icon_path = "./icons/save_icon.png"
            if os.path.exists(icon_path):
                save_btn = QAction(QIcon(icon_path), "保存", self)
            else:
                save_btn = QAction("保存", self)
        except:
            save_btn = QAction("保存", self)
            
        save_btn.triggered.connect(self.save_file)
        main_toolbar.addAction(save_btn)
        
        main_toolbar.addSeparator()
        
        bold_btn = QAction("粗体", self)
        bold_btn.triggered.connect(self.insert_bold)
        main_toolbar.addAction(bold_btn)
        
        italic_btn = QAction("斜体", self)
        italic_btn.triggered.connect(self.insert_italic)
        main_toolbar.addAction(italic_btn)
        
        main_toolbar.addSeparator()
        
        # 字体选择
        main_toolbar.addWidget(QLabel("字体:"))
        self.font_combo = QFontComboBox()
        self.font_combo.setCurrentFont(QFont(self.editor_font))
        self.font_combo.currentFontChanged.connect(self.change_font)
        main_toolbar.addWidget(self.font_combo)
        
        # 字号选择
        main_toolbar.addWidget(QLabel("字号:"))
        self.font_size = QComboBox()
        self.font_size.addItems(["8", "9", "10", "11", "12", "14", "16", "18", "20", "22", "24"])
        self.font_size.setCurrentText(str(self.editor_font_size))
        self.font_size.currentTextChanged.connect(self.change_font_size)
        main_toolbar.addWidget(self.font_size)
        
        # AI工具栏
        ai_toolbar = QToolBar("AI助手")
        self.addToolBar(ai_toolbar)
        
        ai_improve_btn = QAction("改进写作", self)
        ai_improve_btn.triggered.connect(lambda: self.ai_assistant("improve_writing"))
        ai_toolbar.addAction(ai_improve_btn)
        
        ai_summarize_btn = QAction("文本摘要", self)
        ai_summarize_btn.triggered.connect(lambda: self.ai_assistant("summarize"))
        ai_toolbar.addAction(ai_summarize_btn)

    # 编辑器操作
    def undo(self):
        editor = self.get_current_editor()
        if editor:
            editor.undo()
            
    def redo(self):
        editor = self.get_current_editor()
        if editor:
            editor.redo()
            
    def cut(self):
        editor = self.get_current_editor()
        if editor:
            editor.cut()
            
    def copy(self):
        editor = self.get_current_editor()
        if editor:
            editor.copy()
            
    def paste(self):
        editor = self.get_current_editor()
        if editor:
            editor.paste()

    def new_file(self):
        self.create_new_tab()
        
    def open_file(self, file_path=None):
        if not file_path:
            file_path, _ = QFileDialog.getOpenFileName(
                self, "打开文件", "", "Markdown文件 (*.md *.markdown);;文本文件 (*.txt);;所有文件 (*)"
            )
        
        if file_path:
            self.create_new_tab(file_path)
            
    def save_file(self):
        editor = self.get_current_editor()
        if not editor:
            return False
            
        if self.current_file:
            try:
                with open(self.current_file, 'w', encoding='utf-8') as f:
                    f.write(editor.toPlainText())
                self.status_bar.showMessage(f"已保存: {self.current_file}")
                return True
            except Exception as e:
                QMessageBox.critical(self, "错误", f"保存文件失败: {str(e)}")
                return False
        else:
            return self.save_as_file()
            
    def save_as_file(self):
        editor = self.get_current_editor()
        if not editor:
            return False
            
        path, _ = QFileDialog.getSaveFileName(
            self, "保存文件", "", "Markdown文件 (*.md);;所有文件 (*)"
        )
        if path:
            try:
                with open(path, 'w', encoding='utf-8') as f:
                    f.write(editor.toPlainText())
                self.current_file = path
                
                # 更新标签页标题
                index = self.tab_widget.currentIndex()
                self.tab_widget.setTabText(index, os.path.basename(path))
                
                # 更新标签页图标
                self.set_tab_icon(index, path)
                
                self.add_to_recent_files(path)
                self.status_bar.showMessage(f"已保存: {path}")
                return True
            except Exception as e:
                QMessageBox.critical(self, "错误", f"保存文件失败: {str(e)}")
                return False
        return False
        
    def save_all_files(self):
        # 简化实现：只保存当前文件
        self.save_file()
        
    def close_tab(self, index):
        if self.tab_widget.count() <= 1:
            self.close()
        else:
            self.tab_widget.removeTab(index)

    def auto_save(self):
        """自动保存功能"""
        if self.get_current_editor() and self.current_file:
            try:
                with open(self.current_file, 'w', encoding='utf-8') as f:
                    f.write(self.get_current_editor().toPlainText())
                self.status_bar.showMessage(f"自动保存: {os.path.basename(self.current_file)}")
            except Exception:
                pass

    def ai_assistant(self, action_type):
        """AI助手功能"""
        if not self.ai_assistant_enabled:
            QMessageBox.information(self, "AI助手", "请在设置中启用AI助手功能")
            return
            
        editor = self.get_current_editor()
        if not editor:
            return
            
        text = editor.textCursor().selectedText() or editor.toPlainText()
        if not text:
            QMessageBox.warning(self, "提示", "请先选择文本或输入内容")
            return
            
        self.progress_bar.setVisible(True)
        self.progress_bar.setRange(0, 0)  # 无限进度条
        
        # 启动本地AI处理线程
        self.ai_thread = LocalAIAssistant(action_type, text)
        self.ai_thread.response_received.connect(self.on_ai_response)
        self.ai_thread.error_occurred.connect(self.on_ai_error)
        self.ai_thread.start()
        
    def on_ai_response(self, response):
        self.progress_bar.setVisible(False)
        editor = self.get_current_editor()
        if editor:
            editor.insertPlainText("\n\n" + response)
        
    def on_ai_error(self, error):
        self.progress_bar.setVisible(False)
        QMessageBox.critical(self, "AI助手错误", f"处理失败: {error}")

    def create_backup(self):
        """创建备份"""
        if self.backup_enabled and self.current_file:
            backup_dir = os.path.join(os.path.dirname(self.current_file), ".backup")
            os.makedirs(backup_dir, exist_ok=True)
            
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            backup_file = os.path.join(backup_dir, f"{os.path.basename(self.current_file)}.{timestamp}.bak")
            
            try:
                with open(backup_file, 'w', encoding='utf-8') as f:
                    f.write(self.get_current_editor().toPlainText())
                self.status_bar.showMessage(f"备份已创建: {os.path.basename(backup_file)}")
            except Exception as e:
                QMessageBox.warning(self, "备份错误", f"创建备份失败: {e}")

    def restore_backup(self):
        """恢复备份"""
        if not self.current_file:
            return
            
        backup_dir = os.path.join(os.path.dirname(self.current_file), ".backup")
        if not os.path.exists(backup_dir):
            QMessageBox.information(self, "恢复备份", "没有找到备份文件")
            return
            
        backup_files = [f for f in os.listdir(backup_dir) if f.endswith('.bak')]
        if not backup_files:
            QMessageBox.information(self, "恢复备份", "没有找到备份文件")
            return
            
        file, ok = QInputDialog.getItem(self, "恢复备份", "选择备份文件:", backup_files, 0, False)
        if ok and file:
            backup_path = os.path.join(backup_dir, file)
            try:
                with open(backup_path, 'r', encoding='utf-8') as f:
                    content = f.read()
                self.get_current_editor().setPlainText(content)
                self.status_bar.showMessage(f"已从备份恢复: {file}")
            except Exception as e:
                QMessageBox.critical(self, "恢复错误", f"恢复备份失败: {e}")

    def update_outline(self):
        """更新文档大纲"""
        editor = self.get_current_editor()
        if not editor:
            return
            
        text = editor.toPlainText()
        self.outline_widget.clear()
        
        import re
        headers = re.findall(r'^(#{1,6})\s+(.*)$', text, re.MULTILINE)
        
        for level, title in headers:
            level_num = len(level)
            indent = "  " * (level_num - 1)
            item = QListWidgetItem(f"{indent}{title.strip()}")
            self.outline_widget.addItem(item)

    def export_pdf(self):
        """导出PDF"""
        editor = self.get_current_editor()
        if not editor:
            return
            
        path, _ = QFileDialog.getSaveFileName(self, "导出PDF", "", "PDF文件 (*.pdf)")
        if path:
            printer = QPrinter(QPrinter.HighResolution)
            printer.setOutputFormat(QPrinter.PdfFormat)
            printer.setOutputFileName(path)
            
            document = QTextDocument()
            document.setPlainText(editor.toPlainText())
            document.print_(printer)
            
            self.status_bar.showMessage(f"已导出PDF: {path}")

    def export_html(self):
        """导出HTML"""
        editor = self.get_current_editor()
        if not editor:
            return
            
        path, _ = QFileDialog.getSaveFileName(self, "导出HTML", "", "HTML文件 (*.html)")
        if path:
            try:
                text = editor.toPlainText()
                html = markdown.markdown(text, extensions=['extra', 'codehilite', 'tables'])
                full_html = self.get_preview_html(html)
                
                with open(path, 'w', encoding='utf-8') as f:
                    f.write(full_html)
                self.status_bar.showMessage(f"已导出: {path}")
                QMessageBox.information(self, "成功", f"HTML已导出到: {path}")
            except Exception as e:
                QMessageBox.critical(self, "错误", f"导出失败: {e}")

    def insert_table(self):
        """插入表格"""
        editor = self.get_current_editor()
        if editor:
            table_md = """| 列1 | 列2 | 列3 |
|-----|-----|-----|
| 内容 | 内容 | 内容 |
| 内容 | 内容 | 内容 |"""
            editor.insertPlainText(table_md)

    def insert_bold(self):
        editor = self.get_current_editor()
        if editor:
            cursor = editor.textCursor()
            if cursor.hasSelection():
                text = cursor.selectedText()
                cursor.insertText(f"**{text}**")
            else:
                cursor.insertText("****")
                cursor.movePosition(QTextCursor.Left, QTextCursor.MoveAnchor, 2)
                editor.setTextCursor(cursor)
                
    def insert_italic(self):
        editor = self.get_current_editor()
        if editor:
            cursor = editor.textCursor()
            if cursor.hasSelection():
                text = cursor.selectedText()
                cursor.insertText(f"*{text}*")
            else:
                cursor.insertText("**")
                cursor.movePosition(QTextCursor.Left, QTextCursor.MoveAnchor, 1)
                editor.setTextCursor(cursor)
                
    def insert_heading(self, level):
        editor = self.get_current_editor()
        if editor:
            cursor = editor.textCursor()
            cursor.insertText("#" * level + " ")

    def change_font(self, font):
        self.editor_font = font.family()
        editor = self.get_current_editor()
        if editor:
            current_font = editor.font()
            current_font.setFamily(self.editor_font)
            editor.setFont(current_font)
            
    def change_font_size(self, size):
        self.editor_font_size = int(size)
        editor = self.get_current_editor()
        if editor:
            current_font = editor.font()
            current_font.setPointSize(self.editor_font_size)
            editor.setFont(current_font)

    def show_settings(self):
        dialog = SettingsDialog(self)
        dialog.exec_()
        
    def apply_settings(self):
        # 应用字体设置
        editor = self.get_current_editor()
        if editor:
            font = QFont(self.editor_font, self.editor_font_size)
            editor.setFont(font)
            
        # 应用主题
        self.apply_theme()
        
        # 应用自动保存
        if self.auto_save_enabled:
            self.auto_save_timer.start(self.auto_save_interval * 60 * 1000)
        else:
            self.auto_save_timer.stop()
            
        # 应用自动备份
        if self.backup_enabled:
            self.backup_timer.start(30 * 60 * 1000)  # 30分钟备份一次
        else:
            self.backup_timer.stop()
            
    def apply_theme(self):
        theme_styles = {
            "默认": """
                QMainWindow { background-color: #f5f5f5; color: #000000; }
                QTextEdit { background-color: white; color: black; }
            """,
            "暗色": """
                QMainWindow { background-color: #2d2d2d; color: #ffffff; }
                QTextEdit { background-color: #1e1e1e; color: #ffffff; }
            """,
            "护眼绿": """
                QMainWindow { background-color: #cce8cf; color: #333333; }
                QTextEdit { background-color: #e8f5e9; color: #333333; }
            """,
            "深蓝": """
                QMainWindow { background-color: #1a365d; color: #e2e8f0; }
                QTextEdit { background-color: #2d3748; color: #e2e8f0; }
            """
        }
        
        style = theme_styles.get(self.current_theme, theme_styles["默认"])
        self.setStyleSheet(style)

    def update_preview(self, editor, preview):
        text = editor.toPlainText()
        html = markdown.markdown(text, extensions=['extra', 'codehilite', 'tables', 'toc'])
        preview.setHtml(self.get_preview_html(html))

    def get_preview_html(self, content):
        theme_css = self.get_theme_css()
        return f"""
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <style>
                {theme_css}
                body {{
                    font-family: 'Segoe UI', Arial, sans-serif;
                    line-height: 1.6;
                    padding: 20px;
                    max-width: 800px;
                    margin: 0 auto;
                }}
                .codehilite {{
                    background: #f8f8f8;
                    padding: 10px;
                    border-radius: 5px;
                    overflow: auto;
                }}
                table {{
                    border-collapse: collapse;
                    width: 100%;
                    margin: 10px 0;
                }}
                th, td {{
                    border: 1px solid #ddd;
                    padding: 8px;
                    text-align: left;
                }}
                th {{
                    background-color: #f2f2f2;
                }}
                .toc {{
                    background: #f9f9f9;
                    border: 1px solid #ddd;
                    padding: 10px;
                    margin: 10px 0;
                }}
            </style>
        </head>
        <body>
            {content}
        </body>
        </html>
        """

    def get_theme_css(self):
        themes = {
            "默认": "",
            "暗色": """
                body { background-color: #2d2d2d; color: #f0f0f0; }
                h1, h2, h3, h4, h5, h6 { color: #ffffff; }
                a { color: #66ccff; }
                code { background: #3d3d3d; color: #f0f0f0; }
                pre { background: #3d3d3d; color: #f0f0f0; }
                blockquote { border-left-color: #666; color: #ccc; }
                table { border-color: #555; }
                th, td { border-color: #555; }
                th { background-color: #3d3d3d; }
            """,
            "护眼绿": """
                body { background-color: #cce8cf; color: #333; }
                h1, h2, h3, h4, h5, h6 { color: #2d5016; }
                a { color: #1e6f3c; }
            """,
            "深蓝": """
                body { background-color: #1a365d; color: #e2e8f0; }
                h1, h2, h3, h4, h5, h6 { color: #ffffff; }
                a { color: #63b3ed; }
                code { background: #2d3748; }
                pre { background: #2d3748; }
            """
        }
        return themes.get(self.current_theme, "")

    def get_current_editor(self):
        current_widget = self.tab_widget.currentWidget()
        if current_widget and isinstance(current_widget, QSplitter):
            return current_widget.widget(0)
        return None

    def get_current_preview(self):
        current_widget = self.tab_widget.currentWidget()
        if current_widget and isinstance(current_widget, QSplitter):
            return current_widget.widget(1)
        return None

    def toggle_preview(self):
        preview = self.get_current_preview()
        if preview:
            preview.setVisible(not preview.isVisible())
            
    def toggle_file_explorer(self):
        self.file_explorer.setVisible(not self.file_explorer.isVisible())
        
    def toggle_outline(self):
        self.outline_dock.setVisible(not self.outline_dock.isVisible())

    def print_document(self):
        editor = self.get_current_editor()
        if not editor:
            return
            
        printer = QPrinter()
        dialog = QPrintDialog(printer, self)
        if dialog.exec_() == QPrintDialog.Accepted:
            editor.print_(printer)
            
    def show_word_count(self):
        editor = self.get_current_editor()
        if not editor:
            return
            
        text = editor.toPlainText()
        char_count = len(text)
        word_count = len(text.split())
        line_count = text.count('\n') + 1
        
        QMessageBox.information(self, "字数统计", 
                               f"字符数: {char_count}\n单词数: {word_count}\n行数: {line_count}")
                               
    def add_to_recent_files(self, file_path):
        if file_path in self.recent_files:
            self.recent_files.remove(file_path)
        self.recent_files.insert(0, file_path)
        self.recent_files = self.recent_files[:10]  # 保持最近10个文件
        self.update_recent_menu()
        
    def update_recent_menu(self):
        self.recent_menu.clear()
        for file_path in self.recent_files:
            action = QAction(os.path.basename(file_path), self)
            action.triggered.connect(lambda checked, path=file_path: self.open_file(path))
            self.recent_menu.addAction(action)
            
    def update_status(self):
        editor = self.get_current_editor()
        if editor:
            text = editor.toPlainText()
            lines = text.count('\n') + 1
            words = len(text.split())
            self.status_bar.showMessage(f"行数: {lines} | 单词: {words}")

    def load_settings(self):
        # 加载设置
        geometry = self.settings.value("geometry")
        if geometry:
            self.restoreGeometry(geometry)
            
        self.editor_font = self.settings.value("editor_font", "Consolas")
        self.editor_font_size = int(self.settings.value("editor_font_size", 12))
        self.current_theme = self.settings.value("theme", "默认")
        self.auto_save_enabled = self.settings.value("auto_save", "false") == "true"
        self.auto_save_interval = int(self.settings.value("auto_save_interval", 5))
        self.backup_enabled = self.settings.value("backup_enabled", "true") == "true"
        self.ai_assistant_enabled = self.settings.value("ai_assistant_enabled", "true") == "true"
        self.cloud_sync_enabled = self.settings.value("cloud_sync_enabled", "true") == "true"
        
        self.recent_files = self.settings.value("recent_files", [])
        
        self.apply_settings()

    def save_settings(self):
        # 保存设置
        self.settings.setValue("geometry", self.saveGeometry())
        self.settings.setValue("editor_font", self.editor_font)
        self.settings.setValue("editor_font_size", self.editor_font_size)
        self.settings.setValue("theme", self.current_theme)
        self.settings.setValue("auto_save", "true" if self.auto_save_enabled else "false")
        self.settings.setValue("auto_save_interval", self.auto_save_interval)
        self.settings.setValue("backup_enabled", "true" if self.backup_enabled else "false")
        self.settings.setValue("ai_assistant_enabled", "true" if self.ai_assistant_enabled else "false")
        self.settings.setValue("cloud_sync_enabled", "true" if self.cloud_sync_enabled else "false")
        self.settings.setValue("recent_files", self.recent_files)

    def closeEvent(self, event):
        self.save_settings()
        event.accept()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setApplicationName("SunsetMD Pro")
    app.setApplicationVersion("2.0")
    app.setApplicationDisplayName("SunsetMD Pro - 专业Markdown编辑器")
    
    window = ProfessionalMarkdownEditor()
    window.show()
    
    sys.exit(app.exec_())