1677 lines
66 KiB
Vue
1677 lines
66 KiB
Vue
<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>
|