编辑调整、对比模块

This commit is contained in:
zhongluofeng committed 2026-10-16 13:18:32 +08:00
1 parent c9e61f38c5
commit 6cfa74c901
76 files changed
+9514 -626

No files matched your search

+709 -40
View File
@@ -25,11 +25,27 @@
*/
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, History, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
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,
@@ -47,11 +63,13 @@ import {
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { STORAGE_KEYS } from '@/lib/constants'
import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import type { PathReplaceResult } from '@/types/editor'
import { 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'
@@ -60,6 +78,7 @@ 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'
@@ -70,10 +89,18 @@ 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')
@@ -81,6 +108,8 @@ const searchScope = ref<SearchScope>('file')
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)
@@ -100,17 +129,44 @@ function resolveIsDark(theme: string): boolean {
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, effect } = readMainTheme()
const { theme: appTheme, effect } = readMainTheme()
const dark = windowIsDark()
try {
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
// 原生窗口主题**只跟应用主题走**,与其它独立窗口(终端 / 托盘 / 快速面板…)一致。
//
// ⚠️ 绝不能按编辑器自己的配色方案传 'dark'/'light':`setTheme` 会改写**整个应用**的
// `prefers-color-scheme`(同 appStore 的注释),于是托盘菜单、快速面板等靠
// `matchMedia` 取深浅的窗口会被编辑器一起带偏(表现为它们的文字与底色反了)。
// 编辑器自身的深浅由下面的 CSS class 决定,不依赖这里的原生主题。
await win.setTheme(appTheme === 'system' ? null : (appTheme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
const dark = resolveIsDark(theme)
isDark.value = dark
root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
root.classList.add(`effect-${effect}`)
@@ -120,8 +176,12 @@ async function applyTheme(): Promise<void> {
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: [Effect.Mica],
effects: [micaEffect],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
@@ -145,12 +205,17 @@ async function applyTheme(): Promise<void> {
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
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)
@@ -182,6 +247,60 @@ function requestCloseTab(id: string): void {
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)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
@@ -243,37 +362,66 @@ async function confirmCloseTab(): Promise<void> {
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 forceClose()
await closeWindow(true)
}
async function forceClose(): Promise<void> {
/**
* 关闭窗口。
*
* `saveFirst` 为真时逐个标签切换并保存(保存只作用于活动文档);为假则**不写盘**直接关
* —— 用户在确认框里选了「放弃修改并关闭」。
*
* 两条路都要落一次会话:会话记的是「开过哪些标签、光标在哪」,不是内容本身;放弃内容
* 不等于要丢掉下次恢复的入口。
*/
async function closeWindow(saveFirst: boolean): Promise<void> {
const original = store.activeTabId
// 逐个标签切换并保存(保存只作用于活动文档)
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
if (saveFirst) {
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致(不保存时活动标签没被动过,无需复原)
if (original) store.activateTab(original)
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致
if (original) store.activateTab(original)
// 关窗前记录会话(下次无目标打开时恢复)
store.saveSession()
win.close().catch(() => undefined)
}
/** 确认框里的「保存并关闭」。 */
const forceClose = () => closeWindow(true)
/** 确认框里的「放弃修改并关闭」:不写盘,直接关窗。 */
const discardAndCloseWindow = () => closeWindow(false)
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `forceClose` 会写,但 Alt+F4 / 任务栏
* 只在关窗时写是不够的:标题栏的关闭按钮走 `closeWindow` 会写,但 Alt+F4 / 任务栏
* 关闭不走前端流程,`onBeforeUnmount` 在 WebView 被销毁时也不保证执行 —— 会话就是这么
* 丢的。持续写把这个缺口堵上。
*
@@ -292,6 +440,117 @@ watch(sessionShape, () => {
}, 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
@@ -349,8 +608,12 @@ const searchDir = computed(() => {
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 夹取)。 */
@@ -451,6 +714,95 @@ async function doOpenFile(): Promise<void> {
}
}
// ===== 拖入文件打开 =====
/**
* 把拖入的路径逐个打开:文件夹进「目录」面板,文件按「库内笔记 / 库外文件」分流
* (分流规则在 `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)
@@ -540,11 +892,44 @@ onMounted(async () => {
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()
@@ -580,6 +965,10 @@ 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
@@ -660,7 +1049,12 @@ async function saveThenRedecode(): Promise<void> {
</script>
<template>
<div class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground">
<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">
<!--
@@ -678,6 +1072,18 @@ async function saveThenRedecode(): Promise<void> {
<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">
@@ -736,7 +1142,17 @@ async function saveThenRedecode(): Promise<void> {
/>
<!-- 文档标签栏(多文档) -->
<EditorTabs v-if="store.tabs.length" @close="requestCloseTab" />
<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"
/>
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
@@ -764,16 +1180,19 @@ async function saveThenRedecode(): Promise<void> {
<!-- 统一搜索栏:横跨编辑列宽度,压在内容上方(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"
/>
<main class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<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"
@@ -800,6 +1219,73 @@ async function saveThenRedecode(): Promise<void> {
@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>
<!--
并排副面板:与主编辑列等宽,绑定**另一个标签**自己的缓冲(见 EditorHost 的 tabId)。
`:key` 保证换目标时整块重建(编辑器实例不可跨文档复用)。
-->
<div
v-if="splitTab"
class="relative flex min-h-0 w-1/2 min-w-0 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>
</main>
<!-- 目录 / 库检索结果面板:编辑列底部(IDE 的「Find in Path」工具窗位置) -->
@@ -914,14 +1400,31 @@ async function saveThenRedecode(): Promise<void> {
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 设置对话框:库设置 / 编辑器设置(即时生效,无需保存按钮) -->
<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
@@ -933,13 +1436,37 @@ async function saveThenRedecode(): Promise<void> {
@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="tabCloseConfirmOpen"
title="该标签有未保存的改动"
description="关闭标签会丢失这些改动(选择「保存并关闭」会先保存再关闭)。"
confirm-text="保存并关闭"
@confirm="confirmCloseTab"
v-model:open="batchCloseOpen"
title="关闭多个标签"
variant="danger"
confirm-text="放弃修改并关闭"
:description="`选中的 ${batchCloseIds.length} 个标签中有未保存的改动或临时草稿,关闭会丢失这些改动。`"
@confirm="confirmBatchClose"
/>
<!--
@@ -988,6 +1515,22 @@ async function saveThenRedecode(): Promise<void> {
</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>
@@ -997,4 +1540,130 @@ async function saveThenRedecode(): Promise<void> {
.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>