Files
Thing/src/modules/editor/EditorWindow.vue
T
2026-10-10 14:29:48 +08:00

1001 lines
37 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<script setup lang="ts">
/**
* 编辑器独立窗口根组件(`#editor-window`)。
*
* # 为什么是独立窗口
*
* 主模块页只做设置与管理;真正的编辑发生在这里 —— 可多开、可拖到副屏,
* 编辑体验接近一个独立应用(与终端 / 下载 / 翻译窗口同一范式)。
*
* # 生命周期要点
*
* - 窗口由 `openWindow.ts` **隐藏创建**,本组件 `applyTheme` 之后才 `show`
* (否则深色模式下会先闪一下纯白窗口);
* - 自带一份 Pinia(`main.ts` 里为独立窗口注入),store 通过 IPC 与 Rust 对齐;
* - 监听 `editor-settings` / `editor-library-changed` / `editor-file-changed`
* 实现与主窗口及外部编辑器的实时同步。
*
* # P1 新增的三种「异步危险」
*
* 1. **外部改动**:库文件在别的编辑器里被改了,而我们这边有未保存内容 —— 不能
* 静默重载(会丢掉用户刚敲的字),弹出横幅让用户选;
* 2. **打开库外文件**:路径来自系统对话框,必须先 `authorize` 才能写回;
* 3. **大文件**:超过阈值时关掉 Live Preview / 折叠 / 补全(降级在 `core.ts`,
* 这里只负责把 `large` 标记和提示露出来)。
*/
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { open, save } from '@tauri-apps/plugin-dialog'
import { AlertTriangle, History, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import type { PathReplaceResult } from '@/types/editor'
import LibrarySidebar from './components/LibrarySidebar.vue'
import EditorHost from './components/EditorHost.vue'
import EditorToolbar from './components/EditorToolbar.vue'
import QuickOpen from './components/QuickOpen.vue'
import DrawerPanel from './components/DrawerPanel.vue'
import EditorTabs from './components/EditorTabs.vue'
import EditorSearch, { type SearchScope } from './components/EditorSearch.vue'
import SearchResultsPanel from './components/SearchResultsPanel.vue'
import { useEditorSearchStore } from '@/stores/editorSearchStore'
import type { Command, EditorView } from '@codemirror/view'
const logger = createLogger('editor')
const win = getCurrentWindow()
const store = useEditorStore()
const searchStore = useEditorSearchStore()
const isDark = ref(false)
const sidebarVisible = ref(true)
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
const cursorColumn = ref(1)
// ===== 统一搜索器(P4-6):一个输入区覆盖「当前文件 / 当前目录 / 笔记库」 =====
const searchOpen = ref(false)
const searchScope = ref<SearchScope>('file')
/** 右侧抽屉模式(`null` = 关闭):大纲 / 双链 / 图谱 */
const drawerMode = ref<'outline' | 'links' | 'graph' | null>(null)
// ===== 主题与窗口效果(与主应用同步) =====
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
if (raw) {
const s = JSON.parse(raw) as { theme?: string; effect?: string }
return { theme: s.theme ?? 'system', effect: s.effect ?? 'mica' }
}
} catch {
/* 设置不可读时按默认处理 */
}
return { theme: 'system', effect: 'mica' }
}
function resolveIsDark(theme: string): boolean {
if (theme === 'dark') return true
if (theme === 'light') return false
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
try {
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
const dark = resolveIsDark(theme)
isDark.value = dark
root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
root.classList.add(`effect-${effect}`)
if (dark) root.classList.add('dark')
applyStoredAccent(root, dark ? 'dark' : 'light', STORAGE_KEYS.appSettings)
try {
// setEffects 会直接覆盖当前效果,无需 clearEffects(那个命令未在 capability 中授权)
if (effect === 'mica') {
await win.setEffects({
effects: [Effect.Mica],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else if (effect === 'acrylic') {
await win.setEffects({
effects: [Effect.Acrylic],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else {
const bg = dark ? '#16161a' : '#ffffff'
await win.setBackgroundColor(bg)
root.style.setProperty('--popup-bg', bg)
}
} catch {
/* 忽略效果设置失败 */
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
/** 关闭窗口确认(任一标签有未保存改动时) */
const closeConfirmOpen = ref(false)
/** 关闭标签确认 */
const tabCloseConfirmOpen = ref(false)
const pendingCloseTabId = ref('')
/** 关闭临时草稿的三选一(保存到别处 / 删除 / 取消) */
const scratchCloseOpen = ref(false)
/** 请求关闭某个标签(脏数据时弹确认;临时草稿则问「保存到别处 / 删除」)。 */
function requestCloseTab(id: string): void {
const tab = store.tabs.find(t => t.id === id)
if (!tab) return
// 草稿优先:它的收尾是「存到别处 or 删掉」,与普通的「未保存改动」不是一回事
if (store.isScratchTab(id)) {
pendingCloseTabId.value = id
scratchCloseOpen.value = true
return
}
const dirty = id === store.activeTabId ? store.dirty : tab.dirty
if (dirty) {
pendingCloseTabId.value = id
tabCloseConfirmOpen.value = true
return
}
store.closeTab(id)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
* 「保存」走系统「另存为」对话框(`save()`),落盘后原草稿一并删除 —— 内容已经在新
* 位置了;因为是**复制到用户指定路径**,这也顺带给了草稿一个「正经身份」,此后它不再
* 被认作草稿(判据是路径)。
*/
async function saveScratchAndClose(): Promise<void> {
const id = pendingCloseTabId.value
const tab = store.tabs.find(t => t.id === id)
scratchCloseOpen.value = false
if (!tab) return
store.activateTab(id)
const suggested = store.fileDoc?.name ?? '草稿.txt'
try {
const target = await save({
title: '保存草稿到…',
defaultPath: suggested,
filters: [
{ name: '文本文件', extensions: ['txt'] },
{ name: '所有文件', extensions: ['*'] }
]
})
if (typeof target !== 'string') {
// 用户在系统对话框里取消了:当作没点过,草稿与标签都留着
return
}
await store.saveScratchAs(target)
store.closeTab(id)
toast.success('草稿已保存')
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
/** 草稿关闭:删除临时文件并关掉标签。 */
async function discardScratchAndClose(): Promise<void> {
const id = pendingCloseTabId.value
scratchCloseOpen.value = false
if (!id) return
store.activateTab(id)
try {
await store.discardScratch()
} finally {
store.closeTab(id)
}
}
/** 确认关闭脏标签:先切过去保存,再关闭。 */
async function confirmCloseTab(): Promise<void> {
const id = pendingCloseTabId.value
tabCloseConfirmOpen.value = false
store.activateTab(id)
try {
await store.saveCurrent()
} catch {
/* 保存失败仍关闭(用户已确认) */
}
store.closeTab(id)
}
async function doClose(): Promise<void> {
if (store.anyDirty) {
closeConfirmOpen.value = true
return
}
await forceClose()
}
async function forceClose(): Promise<void> {
const original = store.activeTabId
// 逐个标签切换并保存(保存只作用于活动文档)
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致
if (original) store.activateTab(original)
// 关窗前记录会话(下次无目标打开时恢复)
store.saveSession()
win.close().catch(() => undefined)
}
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `forceClose` 会写,但 Alt+F4 / 任务栏
* 关闭不走前端流程,`onBeforeUnmount` 在 WebView 被销毁时也不保证执行 —— 会话就是这么
* 丢的。持续写把这个缺口堵上。
*
* 依赖的是「标签形态」而不是整个 store:光标移动不会触发写盘,光标行只在写入的那一刻
* 取当前值(恢复时是最佳努力,不追求逐次精确)。
*/
const sessionShape = computed(() =>
[store.activeTabId, ...store.tabs.map(t => `${t.kind}|${t.relPath}|${t.path}`)].join('\u0000')
)
let sessionTimer: ReturnType<typeof setTimeout> | null = null
watch(sessionShape, () => {
if (sessionTimer) clearTimeout(sessionTimer)
sessionTimer = setTimeout(() => {
sessionTimer = null
store.saveSession()
}, 300)
})
// ===== 编辑器命令转发 =====
function applyCommand(command: Command): void {
const view = hostRef.value?.getView() as EditorView | null | undefined
if (view) command(view)
}
async function doSave(): Promise<void> {
try {
await store.saveCurrent()
// 成功不弹提示(项目约定:无错误即无声)—— Ctrl+S 是高频动作,toast 反而打扰
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
function onCursorMoved(line: number, column: number): void {
store.setCursorLine(line)
cursorColumn.value = column
}
/** 顶部导航:切侧栏视图(并确保侧栏可见)。 */
function onNav(view: 'library' | 'directory' | 'recent'): void {
sidebarVisible.value = true
store.setSideView(view)
}
// ===== 统一搜索器 =====
/** 取当前 CM6 视图(未打开文档时为 null)。 */
function getEditorView(): EditorView | null {
return hostRef.value?.getView() ?? null
}
/** 从路径取所在目录(同时兼容 `\` 与 `/`)。 */
function dirNameOf(path: string): string {
const index = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'))
return index > 0 ? path.slice(0, index) : ''
}
/**
* 「当前目录」的检索根。
*
* 优先用侧栏已打开的目录;没有就用**当前文件所在目录** —— 用户在编辑某个文件时
* 想「在这个文件附近找一下」,这是最符合直觉的默认。
*/
const searchDir = computed(() => {
if (store.dirListing?.cwd) return store.dirListing.cwd
if (store.kind === 'file' && store.fileDoc?.path) return dirNameOf(store.fileDoc.path)
if (store.kind === 'note' && store.currentRelPath) {
return dirNameOf(store.noteAbsPath(store.currentRelPath))
}
return ''
})
const libraryPath = computed(() => store.info?.root ?? '')
function openSearch(scope: SearchScope = 'file'): void {
searchScope.value = scope
searchOpen.value = true
}
/** 结果点击:打开文件并跳到那一行(检索期间文件可能已被改动,由 jumpToLine 夹取)。 */
async function onSearchOpenFile(payload: {
path: string
line: number
column: number
}): Promise<void> {
try {
await store.openDoc(payload.path)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
return
}
await nextTick()
hostRef.value?.jumpToLine(payload.line, payload.column)
}
/**
* 新建临时草稿文件(工具条的「新建临时文件」)。
*
* 文件落在 `{app_data_dir}/editor/scratch/`,**不随应用退出删除** —— 只有用户关闭这个
* 文件时才会被问「保存到别处 / 删除」(见 `requestCloseTab`)。
*/
async function doNewScratch(): Promise<void> {
try {
await store.newScratchFile()
} catch (e) {
toast.error(`新建临时文件失败:${String(e)}`)
}
}
/**
* 目录 / 库的批量替换完成:磁盘上一批文件已被改写,当前文档可能就是其中之一。
*
* 走 `reloadAfterExternal`:没有未保存改动就直接重载;有改动只挂 `externalChange`
* 提示,绝不静默丢掉用户正在写的内容(取舍见 store 里的注释)。库内文件另外还有
* 文件监听事件负责刷新侧栏,这里只管当前文档。
*/
async function onPathReplaced(result: PathReplaceResult): Promise<void> {
await store.reloadAfterExternal()
const scope = `${result.replacements} 处 / ${result.filesChanged} 个文件`
if (result.skipped.length) {
// 跳过的原因(编码装不下替换内容 / 写入失败 / 编码无法字节级还原)逐个记日志:
// toast 只报数量,具体到哪个文件为什么跳过看日志更合适
logger.warn(
`目录替换跳过 ${result.skipped.length} 个文件:` +
result.skipped.map(s => `${s.path}(${s.reason})`).join(';')
)
toast.warning(`已替换 ${scope},${result.skipped.length} 个文件被跳过(原因见日志)`)
} else if (result.truncated) {
toast.warning(`已替换 ${scope}(达到上限,未处理完)`)
} else {
toast.success(`已替换 ${scope}`)
}
}
/**
* 点击 `[[wikilink]]`。
*
* 目标是**库内相对路径**(`名字.md`)—— 与 Rust 侧 `resolve_link` 的「按名字 + 相对
* 当前目录」判据保持一致。找不到就按这个名字在当前笔记所在目录新建一篇:
* 「先写链接、后补内容」是双链笔记的标准用法,静默失败会让这个习惯立刻失效。
*/
async function onWikilink(target: string): Promise<void> {
const name = target.trim()
if (!name) return
const dir = store.currentRelPath.split('/').slice(0, -1).join('/')
const relPath = dir ? `${dir}/${name}.md` : `${name}.md`
if (store.entries.some(entry => entry.relPath === relPath)) {
await store.openNote(relPath)
return
}
try {
await store.createNote(dir, name)
toast.success(`已新建「${name}」`)
} catch (e) {
toast.error(`新建失败:${String(e)}`)
}
}
// ===== 打开库外文件 =====
async function doOpenFile(): Promise<void> {
try {
const selected = await open({
multiple: false,
directory: false,
title: '打开文件',
filters: [
{ name: '文本 / 代码', extensions: ['md', 'txt', 'json', 'yaml', 'yml', 'toml', 'ini', 'log', 'csv'] },
{ name: '全部文件', extensions: ['*'] }
]
})
if (typeof selected !== 'string') return
await store.openFile(selected)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
}
// ===== 外部改动 =====
const externalConfirmOpen = ref(false)
async function reloadFromExternal(): Promise<void> {
try {
await store.reloadCurrent()
store.externalChange = null
toast.success('已重新载入')
} catch (e) {
toast.error(`重新载入失败:${String(e)}`)
} finally {
externalConfirmOpen.value = false
}
}
/** 「保留我的改动」:只清掉提示,磁盘上的版本仍是外部那份(用户下次保存会覆盖它) */
function keepLocal(): void {
store.externalChange = null
externalConfirmOpen.value = false
}
// ===== 全局按键(窗口级) =====
function onKeydown(event: KeyboardEvent): void {
const mod = event.ctrlKey || event.metaKey
if (!mod) return
const key = event.key.toLowerCase()
if (key === 's') {
event.preventDefault()
void doSave()
} else if (key === 'w') {
// 关闭当前标签(Ctrl+W)
event.preventDefault()
if (store.activeTabId) requestCloseTab(store.activeTabId)
} else if (key === 'tab') {
// 文档间切换(Ctrl+Tab / Ctrl+Shift+Tab)
event.preventDefault()
store.cycleTab(event.shiftKey ? -1 : 1)
} else if (key === 'p' && !event.shiftKey) {
event.preventDefault()
quickOpen.value = true
} else if (key === 'o' && !event.shiftKey) {
event.preventDefault()
void doOpenFile()
} else if (key === 'f') {
// Ctrl+F = 当前文件;Ctrl+Shift+F = 在路径中查找(有目录用目录,否则用笔记库)
event.preventDefault()
openSearch(event.shiftKey ? (searchDir.value ? 'dir' : 'library') : 'file')
} else if (key === 'm' && event.shiftKey) {
event.preventDefault()
store.setViewMode(store.viewMode === 'wysiwyg' ? 'source' : 'wysiwyg')
} else if (key === 'o' && event.shiftKey) {
// 切换右侧抽屉:大纲
event.preventDefault()
drawerMode.value = drawerMode.value === 'outline' ? null : 'outline'
} else if (key === 'b' && event.shiftKey) {
// 切换右侧抽屉:双链
event.preventDefault()
drawerMode.value = drawerMode.value === 'links' ? null : 'links'
} else if (key === 'g' && event.shiftKey) {
// 切换右侧抽屉:双链图谱
event.preventDefault()
drawerMode.value = drawerMode.value === 'graph' ? null : 'graph'
} else if (key === 'n' && event.shiftKey) {
// 与全局快捷键同义:窗口内有焦点时在本窗口直接开对话框,不必绕 Rust 一圈
event.preventDefault()
sidebarVisible.value = true
sidebarRef.value?.showNewNote()
}
}
/** 从 hash 查询串解析初始要打开的文档(`file` = 库内笔记,`path` = 库外文件,`folder` = 本地目录)。 */
function initialTarget(): { relPath: string; path: string; folder: string } {
const hash = window.location.hash
const queryIndex = hash.indexOf('?')
if (queryIndex < 0) return { relPath: '', path: '', folder: '' }
const params = new URLSearchParams(hash.slice(queryIndex + 1))
return {
relPath: params.get('file') ?? '',
path: params.get('path') ?? '',
folder: params.get('folder') ?? ''
}
}
onMounted(async () => {
darkMedia.addEventListener('change', onThemeChange)
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 检索历史与面板高度来自 localStorage:尽早读取,状态栏按钮与结果面板都要用
searchStore.init()
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
await applyTheme()
try {
await win.show()
await win.setFocus()
} catch (e) {
logger.warn(`显示笔记窗口失败:${String(e)}`)
}
await store.init()
store.setViewMode(store.settings.defaultView === 'source' ? 'source' : 'wysiwyg')
const { relPath: targetRel, path: targetPath, folder: targetFolder } = initialTarget()
if (targetRel) {
await store.openNote(targetRel)
} else if (targetPath) {
try {
await store.openFile(targetPath)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
} else if (targetFolder) {
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
await store.openFolder(targetFolder).catch(e => toast.error(`打开文件夹失败:${String(e)}`))
} else if (store.hasSession()) {
// 无目标:恢复上次会话(打开的文档 + 光标位置)
await store.restoreSession()
} else if (store.recentFiles.length) {
await store.openDoc(store.recentFiles[0]!.path).catch(() => undefined)
}
})
onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
if (sessionTimer) {
clearTimeout(sessionTimer)
sessionTimer = null
}
store.saveSession()
store.disposeListeners()
})
// ===== 状态栏 =====
const title = computed(() => store.currentName || '编辑器')
const statusText = computed(() => {
if (store.saving) return '保存中…'
if (store.dirty) return '未保存'
if (!store.hasDocument) return '未打开文档'
return '已保存'
})
/** 编码 / 换行只在库外文件里有意义(笔记永远是 UTF-8 + 换行跟随原文) */
const encodingLabel = computed(() => (store.kind === 'file' ? store.fileDoc?.encoding ?? '' : ''))
const eolLabel = computed(() => {
if (store.kind !== 'file') return ''
return store.fileDoc?.eol === 'crlf' ? 'CRLF' : 'LF'
})
/** 状态栏可切换的编码(值与 `terminal::encoding::normalize` 的规范形态一致)。 */
const ENCODING_OPTIONS = [
{ value: 'utf-8', label: 'UTF-8' },
{ value: 'utf-8-bom', label: 'UTF-8 BOM' },
{ value: 'gb18030', label: 'GB18030' },
{ value: 'gbk', label: 'GBK' },
{ value: 'big5', label: 'Big5' },
{ value: 'shift_jis', label: 'Shift_JIS' },
{ value: 'euc-kr', label: 'EUC-KR' },
{ value: 'latin1', label: 'Latin-1' }
]
// ===== 切换编码(§5.3:有未保存改动时三选一) =====
const encodingDialogOpen = ref(false)
const pendingEncoding = ref('')
/**
* 请求把当前文件按新编码重新解释。
*
* 语义是「换一种方式解释磁盘字节」,因此会从磁盘重新解码并整篇替换内容 ——
* 有未保存改动时必须先让用户选:丢弃 / 先保存 / 取消。
*/
function requestEncoding(encoding: string): void {
if (store.kind !== 'file' || !store.fileDoc) return
if (encoding === store.fileDoc.encoding) return
if (store.dirty) {
pendingEncoding.value = encoding
encodingDialogOpen.value = true
return
}
void store.redecode(encoding).catch(e => toast.error(`切换编码失败:${String(e)}`))
}
async function discardAndRedecode(): Promise<void> {
const encoding = pendingEncoding.value
encodingDialogOpen.value = false
try {
await store.redecode(encoding)
} catch (e) {
toast.error(`切换编码失败:${String(e)}`)
}
}
async function saveThenRedecode(): Promise<void> {
const encoding = pendingEncoding.value
encodingDialogOpen.value = false
try {
// 先按旧编码落盘(用户能立刻看出旧编码是否选错),再按新编码读回
await store.saveCurrent()
await store.redecode(encoding)
} catch (e) {
toast.error(`切换编码失败:${String(e)}`)
}
}
</script>
<template>
<div class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground">
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<!--
这里**不要**再挂 `@mousedown="startDrag"`:`data-tauri-drag-region` 本身已处理
「按住拖动 + 双击最大化/还原」,再手动调一次 `startDragging()` 会让第一次按下
就进入拖动模式,双击的第二下落进拖动里 —— 表现就是「抽搐一下」而不是最大化。
(终端 / 文件窗口同样只靠这个属性。)
-->
<div
class="flex h-full min-w-0 flex-1 items-center gap-2 pl-1"
data-tauri-drag-region
>
<NotebookPen class="size-3.5 shrink-0 text-primary" />
<span class="pointer-events-none truncate text-xs font-medium">{{ title }}</span>
<span v-if="store.dirty" class="size-1.5 shrink-0 rounded-full bg-primary" />
</div>
<div class="w-px h-4 bg-border shrink-0" />
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doMinimize">
<Minus class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最小化</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doToggleMaximize">
<Square class="size-3" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最大化 / 还原</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
class="hover:!bg-destructive hover:!text-destructive-foreground"
@click="doClose"
>
<X class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">关闭窗口</TooltipContent>
</Tooltip>
</TooltipProvider>
</header>
<!-- 主体:侧栏自导航行起贯通到底;导航行 / 标签栏 / 编辑器同处右侧「编辑列」 -->
<div class="flex min-h-0 flex-1">
<LibrarySidebar v-if="sidebarVisible" ref="sidebarRef" @open="store.openNote($event)" />
<div class="flex min-h-0 min-w-0 flex-1 flex-col">
<!-- 导航行:快捷图标操作行 -->
<EditorToolbar
:apply="applyCommand"
:view-mode="store.viewMode"
:dirty="store.dirty"
:saving="store.saving"
:sidebar-visible="sidebarVisible"
@update:view-mode="store.setViewMode($event)"
@save="doSave"
@open-file="doOpenFile"
@new-file="doNewScratch"
@quick-open="quickOpen = true"
@toggle-sidebar="sidebarVisible = !sidebarVisible"
@nav="onNav"
@open-search="openSearch(searchDir ? 'dir' : 'library')"
/>
<!-- 文档标签栏(多文档) -->
<EditorTabs v-if="store.tabs.length" @close="requestCloseTab" />
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
v-if="store.externalChange"
class="flex shrink-0 items-center gap-2 border-b border-border bg-warning-soft px-3 py-1.5 text-xs"
>
<AlertTriangle class="size-3.5 shrink-0 text-warning" />
<span class="min-w-0 flex-1 truncate">
该文件已在应用外被
{{ store.externalChange.kind === 'removed' ? '删除' : '修改' }}
—— 你的未保存改动仍在编辑器里
</span>
<Button variant="outline" size="sm" @click="keepLocal">保留我的改动</Button>
<Button variant="outline" size="sm" @click="externalConfirmOpen = true">查看并重载</Button>
</div>
<!-- 大文件降级提示 -->
<div
v-if="store.fileDoc?.large"
class="flex shrink-0 items-center gap-2 border-b border-border bg-muted px-3 py-1 text-[11px] text-muted-foreground"
>
<AlertTriangle class="size-3 shrink-0" />
文件较大,已关闭「所见即所得 / 折叠 / 自动补全」以保证输入流畅
</div>
<!-- 统一搜索栏:横跨编辑列宽度,压在内容上方(IDEA 的 Find 栏位置) -->
<EditorSearch
v-model:open="searchOpen"
v-model:scope="searchScope"
:dir-path="searchDir"
:library-path="libraryPath"
:get-view="getEditorView"
@open-file="onSearchOpenFile"
@replaced="onPathReplaced"
/>
<main class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<div v-if="!store.hasDocument" class="flex min-h-0 flex-1 items-center justify-center">
<StateBlock
variant="empty"
title="未打开文档"
description="从左侧选择一篇笔记、新建一篇,或用 Ctrl+O 打开磁盘上的文件"
:min-height="200"
>
<template #action>
<div class="flex gap-2">
<Button variant="outline" size="sm" @click="sidebarVisible = true">
<PanelLeft class="size-3.5" />打开侧栏
</Button>
<Button variant="outline" size="sm" @click="doOpenFile">打开文件…</Button>
</div>
</template>
</StateBlock>
</div>
<EditorHost
v-show="store.hasDocument"
ref="hostRef"
:is-dark="isDark"
:live-preview="store.viewMode === 'wysiwyg'"
@cursor-moved="onCursorMoved"
@wikilink="onWikilink"
/>
</main>
<!-- 目录 / 库检索结果面板:编辑列底部(IDE 的「Find in Path」工具窗位置) -->
<SearchResultsPanel @open-file="onSearchOpenFile" />
</div>
<!-- 右侧抽屉:大纲 / 双链(描述当前文档,而非「去哪找文件」) -->
<DrawerPanel
v-if="drawerMode"
:mode="drawerMode"
:cursor-line="store.cursorLine"
@update:mode="drawerMode = $event"
@close="drawerMode = null"
@jump="hostRef?.jumpTo($event)"
@open="store.openNote($event)"
/>
</div>
<!-- 状态栏 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border px-3 text-[11px] text-muted-foreground"
>
<span>{{ statusText }}</span>
<span v-if="store.hasDocument" class="tabular-nums">
{{ store.wordCount }} 字 · {{ store.lineCount }} 行
</span>
<span v-if="store.hasDocument" class="tabular-nums">行 {{ store.cursorLine }} : {{ cursorColumn }}</span>
<span v-if="store.hasDocument">语法:{{ store.languageLabel }}</span>
<span
v-if="store.fileDoc?.readonly"
class="rounded-sm bg-warning-soft px-1.5 py-0.5 text-[10px] text-warning"
>
只读
</span>
<template v-if="store.kind === 'file'">
<DropdownMenu>
<DropdownMenuTrigger as-child>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[10px] uppercase transition-colors hover:bg-hover"
title="切换编码(重新解释磁盘字节)"
>
{{ encodingLabel }}
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" class="w-44">
<DropdownMenuLabel>编码</DropdownMenuLabel>
<DropdownMenuItem
v-for="opt in ENCODING_OPTIONS"
:key="opt.value"
@click="requestEncoding(opt.value)"
>
{{ opt.label }}
<span
v-if="store.fileDoc?.encoding === opt.value"
class="ml-auto text-[10px] text-muted-foreground"
>
当前
</span>
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
<DropdownMenu>
<DropdownMenuTrigger as-child>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[10px] transition-colors hover:bg-hover"
title="切换换行(只影响下次保存)"
>
{{ eolLabel }}
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" class="w-32">
<DropdownMenuLabel>换行</DropdownMenuLabel>
<DropdownMenuItem @click="store.setEol('lf')">
LF
<span v-if="store.fileDoc?.eol !== 'crlf'" class="ml-auto text-[10px] text-muted-foreground">当前</span>
</DropdownMenuItem>
<DropdownMenuItem @click="store.setEol('crlf')">
CRLF
<span v-if="store.fileDoc?.eol === 'crlf'" class="ml-auto text-[10px] text-muted-foreground">当前</span>
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</template>
<!--
目录检索历史:点开底部结果面板(与编码 / 换行同属「状态栏可操作项」分组)。
始终可见而非「有历史才出现」—— 它是结果面板的唯一入口,藏起来用户就找不到
「上次搜了什么」了;没有历史时点开会看到空态说明。
-->
<button
type="button"
class="flex shrink-0 items-center gap-1 rounded-sm px-1.5 py-0.5 transition-colors duration-150 hover:bg-hover hover:text-foreground"
:class="searchStore.panelOpen && 'bg-active text-foreground'"
:title="
searchStore.records.length
? `目录检索历史(${searchStore.records.length} 条)—— 点击开关结果面板`
: '目录检索历史 —— 还没有记录,去搜索栏选「目录」范围搜一次'
"
@click="searchStore.togglePanel()"
>
<History class="size-3" />
<span>检索历史</span>
<span v-if="searchStore.records.length" class="tabular-nums">{{ searchStore.records.length }}</span>
</button>
<span class="ml-auto truncate">{{ store.fileDoc?.path || store.libraryRoot }}</span>
</footer>
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 重载确认 -->
<ConfirmDialog
v-model:open="externalConfirmOpen"
title="重新载入将丢弃未保存的改动"
description="磁盘上的版本会覆盖编辑器里的内容,你当前的改动无法恢复。"
variant="danger"
confirm-text="丢弃并重载"
@confirm="reloadFromExternal"
/>
<!-- 关闭标签确认 -->
<ConfirmDialog
v-model:open="tabCloseConfirmOpen"
title="该标签有未保存的改动"
description="关闭标签会丢失这些改动(选择「保存并关闭」会先保存再关闭)。"
confirm-text="保存并关闭"
@confirm="confirmCloseTab"
/>
<!--
关闭临时草稿:三选一(保存到别处 / 删除 / 取消)。
不用 ConfirmDialog —— 它是「确认 / 取消」两键,而这里必须给出第三条明确出路,
否则用户只能在「丢掉草稿」与「不关标签」之间二选一。
-->
<Dialog :open="scratchCloseOpen" @update:open="scratchCloseOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>关闭临时文件</DialogTitle>
<DialogDescription>
这是一个临时草稿文件,存放在应用数据目录。「保存到别处」会把它另存到你指定的
路径(原临时文件随即删除);「删除」则直接丢弃。
</DialogDescription>
</DialogHeader>
<DialogFooter class="gap-2">
<Button variant="outline" @click="scratchCloseOpen = false">取消</Button>
<Button variant="destructive" @click="discardScratchAndClose">删除</Button>
<Button @click="saveScratchAndClose">保存到别处…</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 切换编码:有未保存改动时三选一(§5.3) -->
<Dialog :open="encodingDialogOpen" @update:open="encodingDialogOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>有未保存的改动</DialogTitle>
</DialogHeader>
<p class="text-xs leading-relaxed text-muted-foreground">
切换编码会以「{{ pendingEncoding }}」重新解释磁盘字节并整篇替换编辑器内容。
当前有未保存的改动,请选择如何处理:
</p>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="discardAndRedecode">
丢弃我的改动并按新编码重读
</Button>
<Button variant="outline" class="w-full" @click="saveThenRedecode">
先按旧编码保存,再按新编码重读
</Button>
<Button variant="ghost" class="w-full" @click="encodingDialogOpen = false">
取消
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<Toaster />
</div>
</template>
<style scoped>
/* 窗口根容器:mica/acrylic 下透明,普通模式用不透明底色(--popup-bg 由 applyTheme 写入) */
.editor-window {
background: var(--popup-bg, var(--background));
}
</style>