Files
Thing/src/modules/editor/EditorWindow.vue
T
2026-10-23 17:25:17 +08:00

1677 lines
66 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 { invoke } from '@tauri-apps/api/core'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { open, save } from '@tauri-apps/plugin-dialog'
import {
AlertTriangle,
FileCode2,
FileText,
History,
Loader2,
Minus,
NotebookPen,
PanelLeft,
Settings,
Square,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { ScrollArea } from '@/components/ui/scroll-area'
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 { EVENTS, STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from './editorClient'
import { EDITOR_THEMES } from './editor/themes'
import type { EditorOpenTabPayload, 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 EditorSettingsDialog from './components/EditorSettingsDialog.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 dragOver = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
/** 主窗口发来的「在既有窗口加标签」监听(见 openWindow.ts) */
let unlistenOpenTab: UnlistenFn | null = null
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
/** 设置对话框(库设置 / 编辑器设置,见 EditorSettingsDialog) */
const settingsOpen = ref(false)
const cursorColumn = ref(1)
const searchRef = ref<InstanceType<typeof EditorSearch> | null>(null)
// ===== 统一搜索器(P4-6):一个输入区覆盖「当前文件 / 当前目录 / 笔记库」 =====
const searchOpen = ref(false)
const searchScope = ref<SearchScope>('file')
/** 右侧抽屉模式(`null` = 关闭):大纲 / 双链 / 图谱 */
const drawerMode = ref<'outline' | 'links' | 'graph' | null>(null)
// ===== 主题与窗口效果(与主应用同步) =====
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
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
}
/**
* 编辑器窗口当前应当采用的深浅(着色由它统一推导:外壳、mica 底色、编辑区)。
*
* - **跟随主应用主题**(设置开关打开):整体跟随应用 —— 读主应用写在同一份
* `localStorage` 里的主题;
* - **不跟随**(默认):由**配色方案**决定 —— 具体主题看它自身的亮暗归属,
* 配色方案为「跟随系统」时按应用解析出的系统深浅(应用本身为「跟随系统」即操作系统)。
*
* 这样窗口外壳(标题栏 / 侧栏 / 状态栏)与编辑区始终同深同浅,「内外统一」。
*/
function windowIsDark(): boolean {
// 应用的深浅(应用为「跟随系统」时按系统偏好解析)
const appDark = resolveIsDark(readMainTheme().theme)
if (store.settings.followAppTheme) return appDark
const theme = String(store.settings.editorTheme)
if (theme === 'system') return appDark
// 具体主题取自身的亮暗归属;未知取值回落到 vscode-dark(与 effectiveThemeName 一致,
// 避免外壳与编辑区深浅对不上)
return EDITOR_THEMES[theme]?.dark ?? EDITOR_THEMES['vscode-dark']?.dark ?? true
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme: appTheme, effect } = readMainTheme()
const dark = windowIsDark()
try {
// 原生窗口主题**只跟应用主题走**,与其它独立窗口(终端 / 托盘 / 快速面板…)一致。
//
// ⚠️ 绝不能按编辑器自己的配色方案传 'dark'/'light':`setTheme` 会改写**整个应用**的
// `prefers-color-scheme`(同 appStore 的注释),于是托盘菜单、快速面板等靠
// `matchMedia` 取深浅的窗口会被编辑器一起带偏(表现为它们的文字与底色反了)。
// 编辑器自身的深浅由下面的 CSS class 决定,不依赖这里的原生主题。
await win.setTheme(appTheme === 'system' ? null : (appTheme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
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') {
// 用 micaDark / micaLight 明确指定着色:编辑器窗口的深浅可以与应用 / 系统不同
// (不跟随时由配色方案决定),沿用 `Effect.Mica` 会跟随系统深浅,深色编辑器配
// 浅色糊化层会「内深外浅」。同 appStore 的做法。
const micaEffect = (dark ? 'micaDark' : 'micaLight') as unknown as Effect
await win.setEffects({
effects: [micaEffect],
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 onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// 设置里改了「跟随主应用主题」或「配色方案」:窗口整体重新着色(外壳 + 编辑区)。
// 用逐项 watch 而不是 `() => [a, b]`:后者每次都会生成新数组,设置一刷新就误触发。
watch([() => store.settings.followAppTheme, () => String(store.settings.editorTheme)], () =>
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)
}
// ===== 标签栏右键菜单:批量关闭 =====
//
// 单标签关闭有「保存 / 放弃」三选一(见 requestCloseTab);批量关多个时逐个三选一
// 会把用户淹没,因此退化为**一次确认**:有脏数据 / 临时草稿就提示「会丢失改动」,
// 确认后统一放弃关闭。
/** 除指定标签外的全部 id。 */
function tabIdsExcept(id: string): string[] {
return store.tabs.filter(t => t.id !== id).map(t => t.id)
}
/** 指定标签左侧的全部 id。 */
function tabIdsLeftOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(0, index).map(t => t.id)
}
/** 指定标签右侧的全部 id。 */
function tabIdsRightOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(index + 1).map(t => t.id)
}
const batchCloseOpen = ref(false)
const batchCloseIds = ref<string[]>([])
/** 关闭多个标签;被固定的标签跳过,其余有未保存改动或临时草稿时先弹确认。 */
function requestCloseTabs(ids: string[]): void {
const valid = ids.filter(id => {
const tab = store.tabs.find(t => t.id === id)
return !!tab && !tab.pinned
})
if (!valid.length) return
const risky = valid.some(id => {
const tab = store.tabs.find(t => t.id === id)
if (!tab) return false
const dirty = id === store.activeTabId ? store.dirty : tab.dirty
return dirty || store.isScratchTab(id)
})
if (risky) {
batchCloseIds.value = valid
batchCloseOpen.value = true
return
}
store.closeTabsByIds(valid)
}
function confirmBatchClose(): void {
batchCloseOpen.value = false
const ids = batchCloseIds.value
batchCloseIds.value = []
store.closeTabsByIds(ids)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
* 「保存」走系统「另存为」对话框(`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)
}
/**
* 放弃改动直接关闭标签(不保存)。
*
* 直接 `closeTab` 即可 —— 未保存的内容只在 store 的标签项 / 扁平 state 里,标签一移除
* 就随之丢弃。切走会触发 `docRevision` 变化,EditorHost 会顺手清掉挂起的自动保存定时器,
* 所以不会出现「关掉之后又被自动保存写回磁盘」。
*/
function discardAndCloseTab(): void {
const id = pendingCloseTabId.value
tabCloseConfirmOpen.value = false
if (!id) return
store.closeTab(id)
}
async function doClose(): Promise<void> {
if (store.anyDirty) {
closeConfirmOpen.value = true
return
}
await closeWindow(true)
}
/**
* 关闭窗口。
*
* `saveFirst` 为真时逐个标签切换并保存(保存只作用于活动文档);为假则**不写盘**直接关
* —— 用户在确认框里选了「放弃修改并关闭」。
*
* 两条路都要落一次会话:会话记的是「开过哪些标签、光标在哪」,不是内容本身;放弃内容
* 不等于要丢掉下次恢复的入口。
*/
async function closeWindow(saveFirst: boolean): Promise<void> {
const original = store.activeTabId
if (saveFirst) {
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)
}
/** 确认框里的「保存并关闭」。 */
const forceClose = () => closeWindow(true)
/** 确认框里的「放弃修改并关闭」:不写盘,直接关窗。 */
const discardAndCloseWindow = () => closeWindow(false)
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `closeWindow` 会写,但 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)
})
// ===== Markdown 预览(标签栏的「眼睛」按钮) =====
/**
* 处于预览状态的标签 id。
*
* **按标签独立**而非窗口一个开关:预览是「看这一篇的渲染结果」,切到下一篇应当还是
* 编辑器本体。放在组件本地而不是 store,是因为它是纯视图状态(不需要跨窗口同步、
* 也不必进会话),关掉重开标签后重新点一下本来也是合理预期。
*/
const previewIds = ref<string[]>([])
// ===== 并排分屏 =====
/**
* 副面板展示的标签 id(空串 = 不分屏)。
*
* 副面板绑定的是**非活动标签**:主面板始终对应活动文档,副面板再开一个独立缓冲,
* 于是两个文档可同时编辑。若副面板对应标签被切到前台(成为活动标签)或已被关闭,
* 分屏自动收起 —— 否则同一标签会被两个面板同时持有,改动互相打架。
*/
const splitTabId = ref('')
const splitTab = computed(() => store.tabs.find(t => t.id === splitTabId.value) ?? null)
function openSplit(id: string): void {
if (id !== store.activeTabId) splitTabId.value = id
}
watch(
() => [splitTabId.value, store.activeTabId, store.tabs.length] as const,
() => {
if (splitTabId.value && (!splitTab.value || splitTabId.value === store.activeTabId)) {
splitTabId.value = ''
}
}
)
/**
* 预览用的 HTML 片段(`renderMarkdownFragment` 的产物,已过 DOMPurify)。
*
* 它只作为**渲染产物**存在,是否允许显示由 [`previewReady`] 决定 —— 绝不把「上一份
* 内容」当占位显示(先出现旧内容再被替换,观感很差)。
*/
const previewHtml = ref('')
/** 当前活动标签是否正处于预览 */
const previewActive = computed(
() => !!store.activeTabId && previewIds.value.includes(store.activeTabId)
)
/**
* 现有 `previewHtml` 是「为哪个标签、哪一版内容」渲染的(`null` = 还没渲染出来)。
*
* 用「标签 + 内容」双判据而不是一个 `loading` 布尔:切标签、切预览、内容被外部改动
* 这几种情况都会让已有产物失效,判据写在数据里就不用在每个入口手动置位。
*/
const previewRenderedFor = ref<{ id: string; content: string } | null>(null)
/** 当前是否可以直接显示 `previewHtml`(对得上活动标签与当前内容) */
const previewReady = computed(() => {
const rendered = previewRenderedFor.value
return (
rendered !== null && rendered.id === store.activeTabId && rendered.content === store.content
)
})
/** 渲染令牌:丢弃过期的异步渲染结果(快速切换标签 / 连续修改内容时) */
let previewToken = 0
/**
* 渲染模块缓存。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js,约 1MB)与导出一样**按需 import**:
* 只有用户真的点开预览才付这份体积。缓存下来还能让后续渲染**同步完成** —— 否则每次
* 都要先过一个微任务,面板会闪一下「正在渲染」。
*/
let renderModule: typeof import('./editor/markdownExport') | null = null
/**
* 重新渲染预览(拿到的是**已消毒的 HTML 片段**,直接 `v-html`,不走 iframe)。
*
* `id` / `content` 在 await 之前取值:等待期间用户可能切了标签或改了内容,那样这次
* 结果就作废(令牌不一致),不能把旧文档的渲染挂到新文档上。
*/
async function refreshPreview(): Promise<void> {
const token = ++previewToken
if (!previewActive.value) return
const id = store.activeTabId
const content = store.content
// 先标失效:宁可短暂显示「正在渲染」,也不显示上一份内容
previewRenderedFor.value = null
try {
const mod = renderModule ?? (renderModule = await import('./editor/markdownExport'))
if (token !== previewToken || !previewActive.value) return
previewHtml.value = mod.renderMarkdownFragment(content)
previewRenderedFor.value = { id, content }
} catch (e) {
logger.error(`Markdown 预览渲染失败:${String(e)}`)
}
}
/** 切换某个标签的预览状态;开启时把它切到前台(否则点了看不到任何变化)。 */
function togglePreview(id: string): void {
const index = previewIds.value.indexOf(id)
if (index >= 0) {
previewIds.value.splice(index, 1)
return
}
previewIds.value.push(id)
// 切到前台;渲染由下面的 watch 触发(切标签与「开预览」都走同一条路径)
store.activateTab(id)
}
// 预览开关 / 内容变化要重渲染(深浅主题不需要:配色走 CSS 变量,自动跟随)。
// 非预览状态下的内容变化直接跳过 —— 否则每敲一个字都要重新渲染整篇。
watch([previewActive, () => store.content], () => {
if (!previewActive.value) return
void refreshPreview()
})
// ===== 编辑器命令转发 =====
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 {
const wasOpen = searchOpen.value
searchScope.value = scope
searchOpen.value = true
// 已经打开时再次 Ctrl+F:把新选中的文本换进输入框(与输入栏内容不同才替换)。
// 关闭状态下由 EditorSearch 的 open 监听统一预填,这里不重复触发。
if (wasOpen) searchRef.value?.refillFromSelection()
}
/** 结果点击:打开文件并跳到那一行(检索期间文件可能已被改动,由 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)}`)
}
}
// ===== 拖入文件打开 =====
/**
* 把拖入的路径逐个打开:文件夹进「目录」面板,文件按「库内笔记 / 库外文件」分流
* (分流规则在 `store.openDoc`)。
*
* # 为什么用 Tauri 原生拖放事件
*
* `dragDropEnabled` 默认开启时 Tauri 会替换 WebView2 的拖放处理器,HTML5 的
* `drop` 事件在 Windows 上拿不到外部文件路径;原生 `onDragDropEvent` 才能拿到
* `paths`。
*
* # 已知限制(非代码问题)
*
* Windows UIPI 会拦截从资源管理器(中完整性)拖入以**管理员**运行的窗口
* (高完整性),因此仅当 Thing 以普通权限运行时拖入才可用。
*/
async function onDroppedPaths(paths: string[]): Promise<void> {
for (const path of paths) {
try {
if ((await editorClient.pathKind(path)) === 'folder') {
await store.openFolder(path)
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
} else {
await store.openDoc(path)
}
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
}
/**
* HTML5 `drop` 兜底。
*
* 正常情况下拖放由 Tauri 原生处理器接管,页面根本收不到 `drop`;但在 Windows 上
* 一旦原生处理器没接管(例如透明/分层窗口),浏览器就会把文件当「可放置内容」交给
* 页面 —— CodeMirror 的 contenteditable 会把**文件内容插进当前文档**,这就是
* 「拖入后内容被写进正在编辑的文件」的原因。这里 `preventDefault` 拦住这个默认
* 行为(同时消除拖动过程中的卡顿),并在能拿到绝对路径时照样打开。
*/
/** HTML5 dragover:亮遮罩(只有在 Tauri 原生拖放未接管时才会触发,见 onDomDrop)。 */
function onDomDragOver(): void {
dragOver.value = true
}
function onDomDrop(event: DragEvent): void {
// 拦 `drop` 默认行为:Chromium 对 contenteditable 的默认处理会把文件内容插进文档
event.preventDefault()
dragOver.value = false
const files = Array.from(event.dataTransfer?.files ?? [])
const paths = files
.map(f => (f as File & { path?: string }).path)
.filter((p): p is string => !!p)
if (paths.length) {
void onDroppedPaths(paths)
} else if (files.length) {
logger.warn(`拖放未走原生通道(files=${files.length},取不到绝对路径)`)
toast.error('未取到拖入文件的绝对路径(拖放被浏览器接管),请改用「打开文件」')
}
}
// ===== 主窗口发来的「在既有窗口加标签」 =====
/**
* 在**本窗口**打开一个目标(加标签 / 切到已开的标签)。
*
* 主窗口在发现有编辑器窗口时不再开新窗口,而是 `emitTo` 这个事件(见
* `openWindow.ts`)。监听放在组件而不是 store:store 的监听每个窗口都注册,
* 放进去会让主窗口自己把目标也「打开」一遍(主窗口没有编辑器界面,纯属副作用)。
*
* 三种目标与 `openEditorWindow` 的入参一一对应:`relPath`(库内笔记,笔记语义)、
* `path` + `folder`(目录面板)、`path`(库外文件)。
*/
async function onOpenTabRequest(payload: EditorOpenTabPayload): Promise<void> {
try {
if (payload.relPath) {
await store.openNote(payload.relPath)
} else if (payload.path && payload.folder) {
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
await store.openFolder(payload.path)
} else if (payload.path) {
await store.openFile(payload.path)
}
} 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)
// 拖入文件打开:走 Tauri 原生拖放事件(`enter/over` 亮遮罩,`drop` 取 paths)。
// 用 webview 而非 window 注册:拖放事件在 Rust 侧是发给 webview 的。
const selfWebview = getCurrentWebview()
unlistenDragDrop = await selfWebview.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragOver.value = true
} else if (payload.type === 'drop') {
dragOver.value = false
logger.info(`原生拖放 drop:${payload.paths.length} 项`)
void onDroppedPaths(payload.paths)
} else {
dragOver.value = false
}
})
logger.info(`拖放监听已注册:webview=${selfWebview.label}`)
// 主窗口要求「在既有窗口里加标签」:定向事件(`emitTo`),只有本窗口会收到
unlistenOpenTab = await listen<EditorOpenTabPayload>(EVENTS.editorOpenTab, event => {
void onOpenTabRequest(event.payload ?? {})
})
// 检索历史与面板高度来自 localStorage:尽早读取,状态栏按钮与结果面板都要用
searchStore.init()
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)。
// 窗口深浅要按设置里的「跟随主应用主题 / 配色方案」推导,因此先取一次设置;
// `store.init()` 后面还会再读一次(无害,且那次要顺带做库扫描等初始化)。
await store.loadSettings()
await applyTheme()
// 任务栏身份:窗口级 AUMID(拆成独立任务栏按钮,不与主窗口合并)+ 组合图标
// (编辑器图形 + 右下角主程序图标)。**必须在 show() 之前**——任务栏按钮在窗口显示时
// 按 AUMID 决定分组,显示后再改往往要 hide/show 才生效。
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'editor' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
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)
unlistenDragDrop?.()
unlistenDragDrop = null
unlistenOpenTab?.()
unlistenOpenTab = null
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"
@dragenter.prevent="onDomDragOver"
@dragover.prevent="onDomDragOver"
@drop.prevent="onDomDrop"
>
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<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>
<!-- 设置:库设置 / 编辑器设置的快捷入口(在主界面对应「库」「编辑器」两页) -->
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="settingsOpen = true">
<Settings class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">设置</TooltipContent>
</Tooltip>
</TooltipProvider>
<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')"
/>
<!-- 外部改动提示(有未保存改动时才会出现) -->
<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
ref="searchRef"
v-model:open="searchOpen"
v-model:scope="searchScope"
:dir-path="searchDir"
:library-path="libraryPath"
:get-view="getEditorView"
:doc-revision="store.docRevision"
@open-file="onSearchOpenFile"
@replaced="onPathReplaced"
/>
<!-- 「并排分屏」行:不分屏时整行占满;分屏时左右各半 ——
左半是「标签栏 + 编辑栏」,右半是副文档(各带自己的 8px 标题行)。
副文档是**并排的一列**,不是嵌在编辑栏内部的一块。 -->
<div class="flex min-h-0 min-w-0 flex-1">
<div class="flex min-h-0 min-w-0 flex-col" :class="splitTab ? 'w-1/2' : 'flex-1'">
<!-- 文档标签栏(多文档):属于左半这一列 -->
<EditorTabs
v-if="store.tabs.length"
:preview-ids="previewIds"
@close="requestCloseTab"
@toggle-preview="togglePreview"
@close-others="requestCloseTabs(tabIdsExcept($event))"
@close-left="requestCloseTabs(tabIdsLeftOf($event))"
@close-right="requestCloseTabs(tabIdsRightOf($event))"
@close-all="requestCloseTabs(store.tabs.map(t => t.id))"
@split="openSplit"
/>
<main class="flex min-h-0 min-w-0 flex-1">
<div 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"
/>
<!--
Markdown 预览:盖在编辑器**之上**而不是替换它 —— EditorHost 保持挂载,
来回切换不会丢撤销历史、光标与滚动位置。滚动交给项目的 ScrollArea(原生滚动条
在深色主题下与整体观感割裂),内容直接用 `v-html`(已消毒片段)。
# 为什么不是 iframe `srcdoc`(原先的做法)
Tauri 的插件(这里的 snap-layout)会向**每个 document** 注入初始化脚本,iframe
里的 `about:srcdoc` 也在其中:注入脚本在无 `__TAURI_INTERNALS__` 的帧里抛错,
而且帧被销毁重建后 `srcdoc` 的二次导航在 WebView2 上不可靠 —— 表现就是「退出
预览后再点预览,一片空白」。改用应用内渲染后这两个问题都不存在,样式改由
下面 `.md-preview` 的 scoped 规则隔离(安全边界仍是 DOMPurify,与导出同一套)。
已知限制:正文里**相对路径的本地图片**在预览中不会加载 —— 面板没有「库根 /
当前笔记目录」这个上下文(Live Preview 是靠 `editor_read_asset` 把图片取成
data URL 才显示的)。
-->
<!--
⚠️ 定位必须落在**外层这层 div**上,不能直接给 `ScrollArea` 加 `absolute`:
reka-ui 的 ScrollAreaRoot 自带内联 `position: relative`,内联样式压过 class,
于是 `absolute` 失效 —— 根节点退化成内容高度,viewport 没有可滚动空间
(症状就是「预览显示出来了,但滚不动」)。
-->
<div v-if="previewActive" class="absolute inset-0 bg-background">
<ScrollArea v-if="previewReady" class="h-full w-full">
<!-- eslint-disable-next-line vue/no-v-html -- 内容来自 renderMarkdownFragment(已过 DOMPurify) -->
<div class="md-preview" v-html="previewHtml" />
</ScrollArea>
<!-- 渲染未就绪:显示占位而**不是**上一份内容(旧内容先出现再被替换的观感很差) -->
<div v-else class="flex h-full items-center justify-center gap-2 text-xs text-muted-foreground">
<Loader2 class="size-3.5 animate-spin" />
正在渲染预览…
</div>
</div>
</div>
</main>
</div>
<!--
并排副栏:与「标签栏 + 编辑栏」这一列等宽,绑定**另一个标签**自己的缓冲
(见 EditorHost 的 tabId)。`:key` 保证换目标时整块重建(编辑器实例不可跨文档复用)。
-->
<div
v-if="splitTab"
class="relative flex min-h-0 min-w-0 w-1/2 flex-col border-l border-border"
>
<div class="flex h-8 shrink-0 items-center gap-1.5 border-b border-border px-2 text-xs">
<FileText v-if="splitTab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate font-medium text-foreground">{{ splitTab.name }}</span>
<Button
variant="ghost"
size="icon-sm"
class="ml-auto"
title="关闭分屏"
@click="splitTabId = ''"
>
<X class="size-3.5" />
</Button>
</div>
<EditorHost
:key="splitTab.id"
:tab-id="splitTab.id"
:is-dark="isDark"
:live-preview="store.viewMode === 'wysiwyg'"
class="min-h-0 flex-1"
/>
</div>
</div>
<!-- 目录 / 库检索结果面板:编辑列底部(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)" />
<!-- 设置对话框:库设置 / 编辑器设置(即时生效,无需保存按钮) -->
<EditorSettingsDialog v-model:open="settingsOpen" />
<!--
关闭窗口:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
与下面「关闭脏标签」同一套取舍 —— ConfirmDialog 只有两键,而「放弃修改」是用户
在这里最常需要的那条出路,不能藏在「取消」里。
-->
<Dialog :open="closeConfirmOpen" @update:open="closeConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>有未保存的改动</DialogTitle>
<DialogDescription>
「保存并关闭」会先把每个标签写入磁盘再退出;「放弃修改并关闭」直接丢弃这些改动。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="forceClose">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseWindow">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="closeConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 重载确认 -->
<ConfirmDialog
v-model:open="externalConfirmOpen"
title="重新载入将丢弃未保存的改动"
description="磁盘上的版本会覆盖编辑器里的内容,你当前的改动无法恢复。"
variant="danger"
confirm-text="丢弃并重载"
@confirm="reloadFromExternal"
/>
<!--
关闭脏标签:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
不用 ConfirmDialog —— 它只有「确认 / 取消」两键,而「放弃修改」是用户在这里最常
需要的那条出路,不能藏在「取消」里(同下面草稿关闭对话框的取舍)。
-->
<Dialog :open="tabCloseConfirmOpen" @update:open="tabCloseConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>该标签有未保存的改动</DialogTitle>
<DialogDescription>
关闭标签会丢失这些改动。「保存并关闭」会先写入磁盘,再关闭标签。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="confirmCloseTab">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseTab">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="tabCloseConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 批量关闭确认:一次关多个标签,不做逐标签「保存 / 放弃」三选一 -->
<ConfirmDialog
v-model:open="batchCloseOpen"
title="关闭多个标签"
variant="danger"
confirm-text="放弃修改并关闭"
:description="`选中的 ${batchCloseIds.length} 个标签中有未保存的改动或临时草稿,关闭会丢失这些改动。`"
@confirm="confirmBatchClose"
/>
<!--
关闭临时草稿:三选一(保存到别处 / 删除 / 取消)。
不用 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>
<!-- 拖入提示遮罩(Tauri 原生拖放事件驱动;HTML5 拖放被 Tauri 接管,不可用) -->
<div
v-if="dragOver"
class="pointer-events-none absolute inset-0 z-50 flex items-center justify-center bg-background/70 backdrop-blur-sm"
>
<div
class="flex flex-col items-center gap-1.5 rounded-lg border-2 border-dashed border-primary px-8 py-6 text-center"
>
<NotebookPen class="size-6 text-primary" />
<span class="text-sm font-medium">松开以打开</span>
<span class="text-xs text-muted-foreground">
文件在本窗口打开,文件夹载入「目录」面板
</span>
</div>
</div>
<Toaster />
</div>
</template>
<style scoped>
/* 窗口根容器:mica/acrylic 下透明,普通模式用不透明底色(--popup-bg 由 applyTheme 写入) */
.editor-window {
background: var(--popup-bg, var(--background));
}
/* ===== Markdown 预览 =====
与导出(`markdownExport` 的 EXPORT_STYLE)是同一套排版语言,但配色**全部换成应用语义
变量**:导出物要离线自洽,必须写死颜色;预览在应用内,深浅主题应当自动跟随。
预览**不套卡片外壳**:没有 max-width、没有阴影、没有灰底,正文直接铺满整个编辑区,
滚动交给外层的 ScrollArea(原生滚动条与本项目观感不一致,见 EditorHost 的同款处理)。 */
.md-preview {
padding: 16px 30px 72px;
color: var(--foreground);
font-size: 14.5px;
line-height: 1.75;
overflow-wrap: break-word;
}
.md-preview :deep(h1),
.md-preview :deep(h2),
.md-preview :deep(h3),
.md-preview :deep(h4),
.md-preview :deep(h5),
.md-preview :deep(h6) {
margin: 1.6em 0 0.6em;
font-weight: 600;
line-height: 1.35;
}
.md-preview :deep(h1) {
font-size: 1.7em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h2) {
font-size: 1.4em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h3) { font-size: 1.2em; }
.md-preview :deep(h4) { font-size: 1.05em; }
.md-preview :deep(p) { margin: 0 0 1em; }
.md-preview :deep(a) {
color: var(--primary);
text-decoration: none;
border-bottom: 1px solid color-mix(in srgb, var(--primary) 35%, transparent);
}
.md-preview :deep(a:hover) { border-bottom-color: currentColor; }
.md-preview :deep(strong) { font-weight: 600; }
.md-preview :deep(mark) {
padding: 0 0.15em;
background: var(--warning-soft);
color: inherit;
border-radius: 2px;
}
.md-preview :deep(img) { max-width: 100%; height: auto; border-radius: 6px; }
.md-preview :deep(blockquote) {
margin: 0 0 1em;
padding: 0.2em 0 0.2em 1em;
border-left: 4px solid var(--border);
color: var(--fg-secondary);
}
.md-preview :deep(blockquote > :last-child) { margin-bottom: 0; }
.md-preview :deep(ul),
.md-preview :deep(ol) { margin: 0 0 1em; padding-left: 1.6em; }
.md-preview :deep(li) { margin: 0.25em 0; }
.md-preview :deep(li.task-list-item) { margin-left: -1.35em; list-style: none; }
.md-preview :deep(input[type='checkbox']) { margin-right: 0.45em; vertical-align: middle; }
.md-preview :deep(code) {
padding: 0.15em 0.35em;
font-family: var(--font-mono);
font-size: 0.9em;
background: var(--subtle);
border-radius: 4px;
}
.md-preview :deep(pre) {
margin: 0 0 1em;
padding: 12px 14px;
overflow-x: auto;
background: var(--subtle);
border: 1px solid var(--border);
border-radius: 6px;
line-height: 1.55;
}
.md-preview :deep(pre code) {
padding: 0;
font-size: 0.875em;
background: transparent;
white-space: pre;
}
.md-preview :deep(table) {
display: block;
max-width: 100%;
margin: 0 0 1em;
overflow-x: auto;
border-collapse: collapse;
}
.md-preview :deep(th),
.md-preview :deep(td) { padding: 6px 12px; border: 1px solid var(--border); }
.md-preview :deep(th) { font-weight: 600; background: var(--subtle); }
.md-preview :deep(hr) { height: 1px; margin: 1.8em 0; border: 0; background: var(--border); }
/* 高亮 token:只做「语义色 → 主题变量」的映射,深浅各自可读(对应导出的固定配色表) */
.md-preview :deep(.hljs-comment),
.md-preview :deep(.hljs-quote) { color: var(--muted-foreground); font-style: italic; }
.md-preview :deep(.hljs-keyword),
.md-preview :deep(.hljs-selector-tag),
.md-preview :deep(.hljs-literal),
.md-preview :deep(.hljs-section) { color: var(--danger); }
.md-preview :deep(.hljs-string),
.md-preview :deep(.hljs-regexp),
.md-preview :deep(.hljs-addition) { color: var(--success); }
.md-preview :deep(.hljs-number),
.md-preview :deep(.hljs-symbol),
.md-preview :deep(.hljs-bullet) { color: var(--info); }
.md-preview :deep(.hljs-title),
.md-preview :deep(.hljs-name),
.md-preview :deep(.hljs-selector-id),
.md-preview :deep(.hljs-selector-class) { color: var(--info); }
.md-preview :deep(.hljs-attr),
.md-preview :deep(.hljs-attribute),
.md-preview :deep(.hljs-variable),
.md-preview :deep(.hljs-template-variable) { color: var(--warning); }
.md-preview :deep(.hljs-built_in),
.md-preview :deep(.hljs-type) { color: var(--info); }
.md-preview :deep(.hljs-meta),
.md-preview :deep(.hljs-doctag),
.md-preview :deep(.hljs-deletion) { color: var(--danger); }
.md-preview :deep(.hljs-tag) { color: var(--success); }
.md-preview :deep(.hljs-emphasis) { font-style: italic; }
.md-preview :deep(.hljs-strong) { font-weight: 600; }
</style>