1454 lines
61 KiB
JavaScript
1454 lines
61 KiB
JavaScript
/**
|
||
* Electron 主进程
|
||
*
|
||
* 职责：
|
||
* - 应用生命周期 + 单实例锁
|
||
* - 系统托盘（含右键菜单，单击打开历史窗口）
|
||
* - 主窗口（无边框、置顶、Frameless）
|
||
* - 轮询剪贴板（默认 1000ms，可在设置里改）→ 去重 → 写 SQLite
|
||
* - IPC：list / search / movetop / delete / clear / favorites / theme / settings
|
||
* - 点选一条：写系统剪贴板 + 置顶（不自动粘贴，用户自己按 Ctrl+V）
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
const {
|
||
app, BrowserWindow, Tray, Menu, ipcMain,
|
||
clipboard, nativeImage, screen, dialog, shell,
|
||
nativeTheme, globalShortcut,
|
||
} = require('electron');
|
||
const path = require('node:path');
|
||
const crypto = require('node:crypto');
|
||
const fs = require('node:fs');
|
||
|
||
const Database = require('better-sqlite3');
|
||
|
||
const configMod = require('./config');
|
||
const favorites = require('./favorites');
|
||
const { buildTrayMenuTemplate } = require('./tray-menu.js');
|
||
const { devLog, devWarn } = require('./lib/log');
|
||
const { normalizeImageForStorage } = require('./lib/image-cap');
|
||
const { applyPatch } = require('./lib/settings-handlers');
|
||
const { createSubscribers } = require('./lib/notify-fanout');
|
||
const { migrate } = require('./lib/migrate');
|
||
const { computePollMs } = require('./lib/adaptive-poll');
|
||
const { shouldReadImage } = require('./lib/poll-guard');
|
||
const { clipPayload } = require('./lib/clip-payload');
|
||
const { planSearch, likePatterns } = require('./lib/search-plan');
|
||
const { isSameDir } = require('./lib/same-dir');
|
||
const { createEchoSuppress } = require('./lib/echo-suppress');
|
||
|
||
|
||
// ---------- 配置 ----------
|
||
|
||
const APP_NAME = '剪贴板';
|
||
|
||
let appConfig = configMod.loadConfig();
|
||
let MAX_ITEMS = appConfig.maxItems; // 运行时可变
|
||
let POLL_MS = appConfig.pollMs; // 运行时可变
|
||
|
||
// 数据目录默认固定在 D:\Clipboard Data（见 config.js），可在设置里迁移，
|
||
// 或用环境变量 CLIPBOARD_APP_DATA_DIR 临时覆盖（测试也用它隔离）。
|
||
// 一律走 appConfig.dataDir 现取，不缓存到常量 —— 迁移后旧值就是错的。
|
||
//
|
||
// sessionDataDir：本会话内的临时目录。仅当用户配置的 dataDir 在本次启动
|
||
// 时不可用（盘符缺失 / 权限不足）才被赋值；不影响磁盘上的 config.json。
|
||
// 这样盘符恢复后下次启动会自动回到用户原本选的目录，不会因为一次"临
|
||
// 时坏掉"把用户的偏好覆盖掉。
|
||
let sessionDataDir = null;
|
||
function effectiveDataDir() { return sessionDataDir || appConfig.dataDir; }
|
||
function getDbPath() { return path.join(effectiveDataDir(), 'history.db'); }
|
||
function getFavDbPath() { return path.join(effectiveDataDir(), 'favorites.db'); }
|
||
|
||
|
||
// ---------- 存储 ----------
|
||
|
||
let db;
|
||
let favDb = null;
|
||
const stmt = {};
|
||
// favorites 的动态 IN 语句按占位符个数缓存
|
||
const favStmtCache = new Map();
|
||
|
||
let ftsAvailable = null;
|
||
function hasFts5(d) {
|
||
if (!d) return false;
|
||
if (ftsAvailable != null) return ftsAvailable;
|
||
try { d.prepare('SELECT 1 FROM clips_fts LIMIT 0').all(); ftsAvailable = true; }
|
||
catch { ftsAvailable = false; }
|
||
return ftsAvailable;
|
||
}
|
||
|
||
// 列表/搜索不需要 image BLOB —— 单条最大 2MB，200 条能到几百 MB。
|
||
// 只取渲染需要的列，图片走 clips:get-image 按需拉取。
|
||
const listCols = (p = '') =>
|
||
`${p}id, ${p}type, ${p}text, ${p}preview, ${p}top_at, ${p}created_at, (${p}image IS NOT NULL) AS has_image`;
|
||
|
||
/**
|
||
* 排序：按最近活跃时间倒序 —— 无论是外部新复制进来（created_at = now），
|
||
* 还是用户点过「复制」（movetop 把 created_at 也置为 now），最新活跃的
|
||
* 一律排在最上面。这是「第一个就是当前剪贴板内容」契约的根基：
|
||
*
|
||
* 1. 刚被复制进来的内容 → created_at = now → 排到顶
|
||
* 2. 用户点过复制的项 → created_at = now（被 movetop 同步更新）→ 排到顶
|
||
* 3. 其它项按 created_at DESC 自然排列
|
||
*
|
||
* 用 id DESC 作 tiebreaker：created_at 用 ms 精度，同 ms 内多次变更
|
||
* （理论上几乎不可能，但 poll tick + 用户点击落在同一 tick 上的极端
|
||
* 场景下能撞上）给一个稳定次序。
|
||
*
|
||
* top_at 仍然保留 —— 它现在只用于「trim / 清空历史」时保护被用户点过
|
||
* 复制的项（见 trimOldest / clearNonTop），不再参与排序。
|
||
*/
|
||
const orderBy = (p = '') => `${p}created_at DESC, ${p}id DESC`;
|
||
|
||
function openDb() {
|
||
fs.mkdirSync(appConfig.dataDir, { recursive: true });
|
||
ftsAvailable = null; // 换库后能力可能不同，重新探测
|
||
clipCount = null; // 行数缓存绑定旧库，换库后必须回源重查
|
||
db = new Database(getDbPath());
|
||
db.pragma('journal_mode = WAL');
|
||
db.pragma('synchronous = NORMAL'); // WAL 下足够安全，省掉每次写的 fsync
|
||
db.exec(`
|
||
CREATE TABLE IF NOT EXISTS clips (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
type TEXT NOT NULL, -- 'text' | 'image'
|
||
text TEXT,
|
||
image BLOB,
|
||
preview TEXT,
|
||
top_at REAL, -- NULL = 自然位置；非空 = 用户点过「复制」（trim / 清空历史 跳过）
|
||
created_at REAL NOT NULL -- 最近活跃时间：外部新复制 = 入库时间；点过「复制」= 同步更新到 now
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_clips_created_id ON clips(created_at DESC, id DESC);
|
||
`);
|
||
// 兼容不带 top_at 列的旧 DB（早期版本无置顶状态）：补上
|
||
try { db.exec(`ALTER TABLE clips ADD COLUMN top_at REAL`); } catch (e) {}
|
||
// 列表排序是 created_at DESC, id DESC（见 orderBy 的注释）—— 复合索引
|
||
// idx_clips_created_id 正好覆盖 ORDER BY 的两列，扫到 LIMIT 就停，不会
|
||
// 因为「id DESC 兜底」触发 TEMP B-TREE FOR LAST TERM OF ORDER BY。
|
||
// 早期版本用过的 idx_clips_created_at(created_at DESC)（单列，不够覆盖）
|
||
// 和 idx_clips_top_created(top_at DESC, created_at DESC) 都已不再使用，
|
||
// 启动时主动 drop 一次，避免无意义的索引拖慢写入。
|
||
try { db.exec(`DROP INDEX IF EXISTS idx_clips_top_created`); } catch (_) {}
|
||
try { db.exec(`DROP INDEX IF EXISTS idx_clips_created_at`); } catch (_) {}
|
||
// 启动时清掉所有 top_at —— "不是长期固定"，重启就归零
|
||
db.prepare(`UPDATE clips SET top_at = NULL WHERE top_at IS NOT NULL`).run();
|
||
|
||
migrate(db, 1, appConfig.schemaVersion);
|
||
|
||
stmt.insertText = db.prepare(`INSERT INTO clips(type, text, preview, top_at, created_at) VALUES('text', ?, ?, ?, ?)`);
|
||
stmt.insertImage = db.prepare(`INSERT INTO clips(type, image, preview, top_at, created_at) VALUES('image', ?, ?, ?, ?)`);
|
||
stmt.count = db.prepare(`SELECT COUNT(*) AS n FROM clips`);
|
||
// 排序：created_at DESC, id DESC（最近活跃优先，见 orderBy 注释）
|
||
stmt.listAll = db.prepare(`SELECT ${listCols()} FROM clips ORDER BY ${orderBy()} LIMIT ?`);
|
||
stmt.get = db.prepare(`SELECT * FROM clips WHERE id = ?`);
|
||
stmt.getMeta = db.prepare(`SELECT ${listCols()} FROM clips WHERE id = ?`);
|
||
stmt.getImage = db.prepare(`SELECT image FROM clips WHERE id = ?`);
|
||
stmt.moveToTop = db.prepare(`UPDATE clips SET top_at = ?, created_at = ? WHERE id = ?`);
|
||
stmt.clearTop = db.prepare(`UPDATE clips SET top_at = NULL WHERE id = ?`);
|
||
stmt.delete = db.prepare(`DELETE FROM clips WHERE id = ?`);
|
||
stmt.clearNonTop = db.prepare(`DELETE FROM clips WHERE top_at IS NULL`);
|
||
// 之前每次入库都现场 prepare 一遍，热路径上白白编译
|
||
stmt.trimOldest = db.prepare(`
|
||
DELETE FROM clips
|
||
WHERE id IN (
|
||
SELECT id FROM clips WHERE top_at IS NULL
|
||
ORDER BY created_at ASC LIMIT ?
|
||
)
|
||
`);
|
||
if (hasFts5(db)) {
|
||
stmt.searchFts = db.prepare(`
|
||
SELECT ${listCols('c.')}
|
||
FROM clips_fts f JOIN clips c ON c.id = f.rowid
|
||
WHERE clips_fts MATCH ?
|
||
ORDER BY ${orderBy('c.')}
|
||
LIMIT ?
|
||
`);
|
||
}
|
||
}
|
||
|
||
function openFavDb() {
|
||
fs.mkdirSync(appConfig.dataDir, { recursive: true });
|
||
favStmtCache.clear(); // 语句绑定在旧连接上，换库后必须丢掉
|
||
favDb = favorites.open(getFavDbPath());
|
||
}
|
||
|
||
// 行数在内存里跟踪，避免每次入库都跑一次 COUNT(*) 全表扫描。
|
||
// null = 尚未初始化（下次用到时回源查一次）。
|
||
let clipCount = null;
|
||
|
||
function getClipCount() {
|
||
if (clipCount == null) clipCount = stmt.count.get().n;
|
||
return clipCount;
|
||
}
|
||
|
||
function enforceLimit() {
|
||
if (MAX_ITEMS <= 0) return; // 0 = 不限制
|
||
const total = getClipCount();
|
||
if (total <= MAX_ITEMS) return;
|
||
// 优先删除最旧的"自然位置"项（top_at IS NULL），不动置顶中的
|
||
const removed = stmt.trimOldest.run(total - MAX_ITEMS).changes;
|
||
clipCount = total - removed;
|
||
}
|
||
|
||
// 多 token 的 LIKE 搜索：每个 token 独立子串、AND 组合（与 FTS MATCH 多短语的
|
||
// 语义对齐），不要求原文连空格一起逐字出现。patterns 已由 lib/search-plan
|
||
// 转义好（% _ \），这里一律带 ESCAPE '\'。语句形状随 token 数变化没法预编译
|
||
// 缓存，现 prepare —— SQLite 编译这种简单查询是 µs 级，热路径可接受。
|
||
function searchLikeRows(patterns, limit) {
|
||
if (!patterns.length) return stmt.listAll.all(limit);
|
||
const where = patterns.map(() => `text LIKE ? ESCAPE '\\'`).join(' AND ');
|
||
return db.prepare(
|
||
`SELECT ${listCols()} FROM clips WHERE ${where} ORDER BY ${orderBy()} LIMIT ?`
|
||
).all(...patterns, limit);
|
||
}
|
||
|
||
function makePreview(text, maxLen = 120) {
|
||
const flat = String(text || '').replace(/\s+/g, ' ').trim();
|
||
return flat.length > maxLen ? flat.slice(0, maxLen - 1) + '…' : flat;
|
||
}
|
||
|
||
// row 来自 listCols()（无 image 列，带 has_image）或 SELECT *（有 image 列）。
|
||
// 两种都不在这里做 base64 —— 图片由渲染进程按需调 clips:get-image 拉。
|
||
function rowToClip(row) {
|
||
if (!row) return null;
|
||
return {
|
||
id: row.id,
|
||
type: row.type,
|
||
text: row.text || '',
|
||
hasImage: row.has_image != null ? row.has_image === 1 : row.image != null,
|
||
preview: row.preview || '',
|
||
topAt: row.top_at, // null = 未被用户点过「复制」；非空 = 用户点过（trim / 清空历史 跳过）
|
||
createdAt: row.created_at,
|
||
};
|
||
}
|
||
|
||
function listWithFavorited(rows) {
|
||
if (!favDb || rows.length === 0) return rows;
|
||
const ids = rows.map(r => r.id);
|
||
// 按占位符个数缓存语句：列表长度只有少数几种取值（200 / 命中数），
|
||
// 之前每次列表都重新 prepare 一条动态 IN 语句。
|
||
let st = favStmtCache.get(ids.length);
|
||
if (!st) {
|
||
st = favDb.prepare(
|
||
`SELECT source_clip_id, id FROM favorites WHERE source_clip_id IN (${ids.map(() => '?').join(',')})`
|
||
);
|
||
if (favStmtCache.size < 64) favStmtCache.set(ids.length, st);
|
||
}
|
||
const favs = st.all(...ids);
|
||
if (favs.length === 0) return rows;
|
||
const favMap = new Map(favs.map(f => [f.source_clip_id, f.id]));
|
||
return rows.map(r => ({
|
||
...r,
|
||
favorited: favMap.has(r.id),
|
||
favId: favMap.get(r.id),
|
||
}));
|
||
}
|
||
|
||
|
||
// ---------- 剪贴板轮询 ----------
|
||
|
||
let pollTimer = null;
|
||
// 回声抑制：区分"我们自己写进剪贴板的"和"外部新复制"。两份独立状态机
|
||
// （文本 / 图片指纹），规则与踩坑记录见 lib/echo-suppress.js。
|
||
const textSuppress = createEchoSuppress();
|
||
const imageSuppress = createEchoSuppress();
|
||
let pollTick = 0; // 累计轮询次数
|
||
|
||
/**
|
||
* 图片指纹。走 getBitmap()（原始 BGRA，一次 memcpy）而不是 toPNG()。
|
||
*
|
||
* toPNG() 要做完整的 PNG 压缩 —— 剪贴板上放一张 5MB 截图时，每个 tick 都要
|
||
* 花 ~50ms 重新编码一遍，哪怕图根本没变。改成 hash 原始位图后，同样的判断
|
||
* 快了将近一个数量级，而且仍然是精确比较（不会把两张同尺寸的不同图判成一样）。
|
||
* toPNG() 现在只在确认图变了之后跑一次。
|
||
*/
|
||
function imageFingerprint(img) {
|
||
const size = img.getSize();
|
||
return crypto.createHash('sha1')
|
||
.update(`${size.width}x${size.height}:`)
|
||
.update(img.getBitmap())
|
||
.digest('hex');
|
||
}
|
||
|
||
function pollClipboard() {
|
||
pollTick++;
|
||
|
||
// 读文本
|
||
let text = null; // null = 读文本失败（被其他进程独占 / 系统 API 抽风）
|
||
try {
|
||
text = clipboard.readText() || '';
|
||
} catch (e) {
|
||
console.error('[poll] readText error:', e.message);
|
||
}
|
||
|
||
// 每 20 次打一次心跳，方便确认轮询是否在跑（间隔 = 20 × pollMs）
|
||
if (pollTick % 20 === 1) {
|
||
devLog(`[poll] tick=${pollTick} textLen=${text == null ? -1 : text.length}`);
|
||
}
|
||
|
||
// 文本变化检测（规则见 lib/echo-suppress.js）。
|
||
// readText 抛错时（text === null）**不调 observe** —— 否则 last 会被改成
|
||
// '' 触发 'empty' 直接退出，但剪贴板上可能有图片；图片分支被一并跳过，
|
||
// 用户刚复制的那张图就静默丢失。等下次 tick readText 恢复时再正常观察。
|
||
if (text !== null) {
|
||
const verdict = textSuppress.observe(text);
|
||
if (verdict === 'empty') {
|
||
// 剪贴板被清空或原本就空，跳过（不消化回声标记）
|
||
return;
|
||
}
|
||
if (verdict === 'suppressed') {
|
||
devLog('[poll] suppressed (was our own paste)');
|
||
return;
|
||
}
|
||
if (verdict === 'new') {
|
||
devLog(`[poll] NEW TEXT len=${text.length} preview=${JSON.stringify(text.slice(0, 60))}`);
|
||
try {
|
||
const now = Date.now() / 1000;
|
||
const info = stmt.insertText.run(text, makePreview(text), null, now);
|
||
if (clipCount != null) clipCount++;
|
||
enforceLimit();
|
||
notifyNew(rowToClip(stmt.getMeta.get(info.lastInsertRowid)));
|
||
devLog(`[poll] inserted id=${info.lastInsertRowid}`);
|
||
} catch (e) {
|
||
// 入库失败：observe 已经把 last 改成新内容，不回滚下次 tick 会判
|
||
// 'unchanged' 把这条内容**永久吞掉**（直到重启重新 seed）。abort
|
||
// 后下次 tick 再判 'new' 重试一次，符合预期。
|
||
console.error('[poll] DB insert error:', e.message, e.stack);
|
||
textSuppress.abortLastObserve();
|
||
}
|
||
return;
|
||
}
|
||
// verdict === 'unchanged' —— 文本没变，继续看图片分支
|
||
} else {
|
||
devLog('[poll] readText skipped (last read failed), still probing image branch');
|
||
}
|
||
|
||
// 守卫：剪贴板若没有图片格式，跳过读图避免 ~33MB memcpy + sha1
|
||
// （剪贴板只有文本时这是 100% 的常见情况）。
|
||
// availableFormats 也用 try 裹住：它只是守卫，抛了（剪贴板被别的进程
|
||
// 独占 / 系统 API 抽风）就跳过本 tick 的图片分支 —— 漏一张图的代价
|
||
// 远小于未捕获异常打挂主进程（Node 默认 uncaughtException = 退出）。
|
||
let formats;
|
||
try {
|
||
formats = clipboard.availableFormats();
|
||
} catch (e) {
|
||
console.error('[poll] availableFormats error:', e.message);
|
||
return;
|
||
}
|
||
if (!shouldReadImage(formats)) return;
|
||
|
||
// 读图片
|
||
try {
|
||
const img = clipboard.readImage();
|
||
if (!img || img.isEmpty()) return;
|
||
const size = img.getSize();
|
||
if (size.width < 2 || size.height < 2) {
|
||
// 1×1 透明图，按"没东西"处理：重置基线，下一次任何真图都算"新"
|
||
imageSuppress.resetBaseline();
|
||
return;
|
||
}
|
||
const hash = imageFingerprint(img);
|
||
// unchanged（没变，不编码）/ suppressed（自己的回声）都不入库
|
||
if (imageSuppress.observe(hash) !== 'new') return;
|
||
|
||
// 确认是新图，才付 PNG 编码的代价
|
||
const buf = img.toPNG();
|
||
devLog(`[poll] NEW IMAGE ${size.width}x${size.height} bytes=${buf.length}`);
|
||
try {
|
||
const now = Date.now() / 1000;
|
||
const { buf: resized, preview: capPreview } = normalizeImageForStorage(buf);
|
||
const preview = capPreview || '[图片]';
|
||
const info = stmt.insertImage.run(resized, preview, null, now);
|
||
if (clipCount != null) clipCount++;
|
||
enforceLimit();
|
||
notifyNew(rowToClip(stmt.getMeta.get(info.lastInsertRowid)));
|
||
devLog(`[poll] inserted id=${info.lastInsertRowid}`);
|
||
} catch (e) {
|
||
// 入库失败：跟文本分支对称地回滚基线，避免 PNG 编码的代价被白付 +
|
||
// 下次 tick 把同样的图当 unchanged 静默吞掉。
|
||
console.error('[poll] DB insert error:', e.message, e.stack);
|
||
imageSuppress.abortLastObserve();
|
||
}
|
||
} catch (e) {
|
||
console.error('[poll] readImage error:', e.message);
|
||
}
|
||
}
|
||
|
||
function startPolling() {
|
||
stopPolling();
|
||
// 立即跑一次，再开定时器
|
||
pollClipboard();
|
||
const visible = !mainWindow || mainWindow.isDestroyed() ? true : mainWindow.isVisible();
|
||
const ms = computePollMs(POLL_MS, visible);
|
||
pollTimer = setInterval(pollClipboard, ms);
|
||
devLog(`[poll] started, interval=${ms}ms (visible=${visible})`);
|
||
}
|
||
|
||
// 启动时给文本/图片基线喂一次当前剪贴板，**不**入库。
|
||
// 之前这里只有 null；要是用户开了第二次（比如上午开过、下午又开），
|
||
// 第一次 tick 就会把剪贴板里"上次会话就在的"那条内容当作新内容重入一次。
|
||
// seed 只设基线、不标记回声，后面用户的真实外部复制照常入库。
|
||
function initializeClipboardState() {
|
||
let textLen = 0;
|
||
let hasImage = false;
|
||
try {
|
||
const text = clipboard.readText() || '';
|
||
textSuppress.seed(text);
|
||
textLen = text.length;
|
||
} catch (e) {
|
||
devWarn('[poll] init readText failed:', e.message);
|
||
}
|
||
try {
|
||
const img = clipboard.readImage();
|
||
if (img && !img.isEmpty()) {
|
||
const size = img.getSize();
|
||
if (size.width >= 2 && size.height >= 2) {
|
||
// 1×1 透明图不值得记指纹（前面 poll 也会按"没东西"处理）
|
||
imageSuppress.seed(imageFingerprint(img));
|
||
hasImage = true;
|
||
}
|
||
}
|
||
} catch (e) {
|
||
devWarn('[poll] init readImage failed:', e.message);
|
||
}
|
||
devLog(`[poll] init clipboard state seeded: textLen=${textLen} hasImage=${hasImage}`);
|
||
}
|
||
|
||
function attachAdaptivePoll(window) {
|
||
if (!window) return;
|
||
window.on('show', () => startPolling());
|
||
window.on('hide', () => startPolling());
|
||
}
|
||
function stopPolling() {
|
||
if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
|
||
}
|
||
|
||
// ---------- 主题广播 ----------
|
||
|
||
function broadcastTheme() {
|
||
const sysDark = nativeTheme.shouldUseDarkColors;
|
||
const effective = configMod.effectiveTheme(appConfig, sysDark);
|
||
const payload = {
|
||
// 旧字段保留：渲染端旧版本只读 payload.theme。新代码应优先用 effectiveTheme。
|
||
theme: effective,
|
||
effectiveTheme: effective,
|
||
rawTheme: appConfig.theme,
|
||
accent: appConfig.accent,
|
||
followSystem: appConfig.followSystem,
|
||
systemDark: sysDark,
|
||
};
|
||
subscribers.notifyTheme('theme:system-changed', payload);
|
||
}
|
||
|
||
nativeTheme.on('updated', () => {
|
||
devLog('[theme] system theme changed, broadcasting');
|
||
broadcastTheme();
|
||
});
|
||
|
||
function applyMaxItems(n) {
|
||
MAX_ITEMS = n;
|
||
try { enforceLimit(); } catch (e) { console.error('[cfg] enforceLimit failed:', e.message); }
|
||
}
|
||
|
||
function applyPollMs(ms) {
|
||
POLL_MS = ms;
|
||
startPolling(); // startPolling 内部会先 stopPolling
|
||
}
|
||
|
||
// 窗口置顶：不落盘，重启回到默认（开启）——与本功能开发前的行为一致
|
||
let alwaysOnTop = true;
|
||
|
||
function applyAlwaysOnTop(on) {
|
||
alwaysOnTop = on === true;
|
||
if (mainWindow && !mainWindow.isDestroyed()) {
|
||
try { mainWindow.setAlwaysOnTop(alwaysOnTop); }
|
||
catch (e) { devWarn('[window] setAlwaysOnTop failed:', e.message); }
|
||
}
|
||
return alwaysOnTop;
|
||
}
|
||
|
||
|
||
// ---------- 窗口 ----------
|
||
|
||
let mainWindow = null;
|
||
|
||
function createFramelessWindow({ width, height, file, onClose, minimizable = false }) {
|
||
const w = new BrowserWindow({
|
||
width, height,
|
||
show: false,
|
||
frame: false,
|
||
resizable: true,
|
||
minimizable,
|
||
maximizable: false,
|
||
skipTaskbar: true,
|
||
// 跟随当前的置顶开关。写死 true 会让用户关掉置顶、关窗、再开窗之后
|
||
// 窗口又变回置顶，而按钮状态仍显示"已关闭"。
|
||
alwaysOnTop,
|
||
// 背景色跟随主题：之前写死 #FFFFFF，5/6 的主题首帧会闪白。
|
||
backgroundColor: configMod.themeBgColor(appConfig.theme),
|
||
// OS 级窗口图标：alt-tab、任务管理器进程图标、Win+Tab 任务视图。
|
||
// 工厂被主窗口和设置窗口共用，一行设置两窗生效。
|
||
icon: path.join(__dirname, 'icon.ico'),
|
||
webPreferences: {
|
||
preload: path.join(__dirname, 'preload.js'),
|
||
contextIsolation: true,
|
||
nodeIntegration: false,
|
||
sandbox: false,
|
||
},
|
||
});
|
||
// 外链一律不许在应用内开窗 / 导航：关于页的链接由渲染进程拦下走
|
||
// shell.openExternal（scheme 白名单在主进程），这里是纵深防御 —— 万一
|
||
// 将来有链接漏过了点击拦截（中键点击 / 拖拽 / JS 直跳），也不能把
|
||
// frameless 窗口顶成外部网页，或弹一个没有我们 preload 的裸窗口。
|
||
w.webContents.setWindowOpenHandler(() => ({ action: 'deny' }));
|
||
w.webContents.on('will-navigate', (e, url) => {
|
||
e.preventDefault();
|
||
devWarn('[window] blocked in-page navigation to', url);
|
||
});
|
||
w.loadFile(path.join(__dirname, 'renderer', file));
|
||
forwardRendererLog(w.webContents);
|
||
if (onClose) w.on('closed', onClose);
|
||
return w;
|
||
}
|
||
|
||
function createMainWindow() {
|
||
mainWindow = createFramelessWindow({
|
||
// 默认高度按"刚好显示 5 条单行内容"。每个部件的实测高度（用 headless
|
||
// chromium 跑过，subpixel 取整后）：
|
||
// 拖动区 42 #drag-bar = padding 8+7 + icon 26 + border 1
|
||
// Tab 条 33 #tabs = padding 0 + .tab 27 + border 2 + .tab margin-bottom -1 + container border 1
|
||
// （.tab 里 16px 高的 .tab-count 把行盒顶到 33）
|
||
// 搜索区 50 #search-row = padding 8+10 + input 32
|
||
// 状态栏 33 #status = padding 7+7 + 18px kbd + border 1
|
||
// （<kbd> 18px 高，比 11px×1.4 文字高，把容器撑到 33）
|
||
// 列表内边距 16 #list-wrap padding 8+8
|
||
// 5×卡片 ~69.8 .card = padding 9+10 + head 24 + margin 4 + body 20.8 + border 2
|
||
// （.action.fav 里 14px SVG 比 11px 文字高，把 head 撑到 24）
|
||
// 4×间距 24 #list gap: 6px
|
||
// 根容器边框 2 #root border-top+border-bottom
|
||
// 总和 42+33+50+33+16+5×69.8+4×6+2 = 549.4 → 550 正好够，第 5
|
||
// 条底部贴底但不溢出，list-wrap 不出现滚动条（549 时 5 条全可见，
|
||
// 540 时第 5 条已被裁掉）。
|
||
// 之前的注释算成 470 / 520 都没考虑到 .tab-count / kbd / SVG 把
|
||
// 容器顶高的几个隐式 max-height，所以差了几十 px；用户反馈"可以
|
||
// 高一些，刚好 5 条"就是要 5 条稳稳占满、无需滚动。
|
||
// 默认尺寸：
|
||
// 宽度 500 —— 460 时 text-preview 一行只能显示 ~28 个汉字，长一点的 URL/
|
||
// 路径/代码片段经常被截到第二行；500 让单行可显示 ~38 字，多数短文/
|
||
// URL 一行内看完。设置窗口是 420，这里再宽 80 形成"主宽 / 设窄"的
|
||
// 层级，仍能在 1080p 屏幕上居中不显拥挤。
|
||
// 高度 550 —— 刚好显示 5 条单行卡片（详见上方注释的逐项实测）。
|
||
// 用户拖窗可自由调整，跟旧行为一致。
|
||
width: 500, height: 550,
|
||
file: 'index.html',
|
||
onClose: () => { mainWindow = null; },
|
||
// 自动粘贴移除后没有代码会主动最小化它；保留 true 只是不拦截
|
||
// Win+M 之类的系统行为，toggleWindow() 里有 isMinimized → restore 兜底。
|
||
minimizable: true,
|
||
});
|
||
mainWindow.webContents.on('before-input-event', (_e, input) => {
|
||
if (input.key === 'F12' ||
|
||
((input.control || input.meta) && input.shift && input.key.toLowerCase() === 'i')) {
|
||
mainWindow.webContents.toggleDevTools();
|
||
}
|
||
});
|
||
// 必须在这里挂，不能只在启动时挂一次 —— 用户关掉窗口后 toggleWindow()
|
||
// 会重建一个新的 BrowserWindow，旧窗口上的监听随之失效，自适应轮询就哑了。
|
||
attachAdaptivePoll(mainWindow);
|
||
return mainWindow;
|
||
}
|
||
|
||
function toggleWindow() {
|
||
// 窗口已销毁（用户主动关闭过）→ 重新创建一个并显示
|
||
if (!mainWindow || mainWindow.isDestroyed()) {
|
||
createMainWindow();
|
||
mainWindow.once('ready-to-show', () => {
|
||
positionAtTopCenter();
|
||
mainWindow.show();
|
||
mainWindow.focus();
|
||
});
|
||
return;
|
||
}
|
||
if (mainWindow.isVisible()) {
|
||
mainWindow.hide();
|
||
} else {
|
||
if (mainWindow.isMinimized()) mainWindow.restore();
|
||
positionAtTopCenter();
|
||
mainWindow.show();
|
||
mainWindow.focus();
|
||
// 之前这里是 mainWindow.reload() —— 每次打开都重新解析全部 CSS、重跑
|
||
// preload 和 renderer.js，100~300ms 的可感延迟。渲染进程本来就订阅了
|
||
// clips:refresh，推一条通知让它自己重拉列表就够了。
|
||
notifyRefresh();
|
||
}
|
||
}
|
||
|
||
let settingsWindow = null;
|
||
|
||
function openSettingsWindow() {
|
||
if (settingsWindow && !settingsWindow.isDestroyed()) { settingsWindow.show(); settingsWindow.focus(); return; }
|
||
settingsWindow = createFramelessWindow({
|
||
// 480 是初版只有三四个开关时的高度；加了 Tab 页、「更改目录」「清空历史」
|
||
// 和快捷键之后，「通用」页内容已有 ~550px，而 #settings-body 是
|
||
// overflow:hidden（设计上设置窗口就该一屏放下、不滚动）—— 旧高度下
|
||
// 底部整块被裁掉且没有滚动条，「清空历史」按钮根本点不到。
|
||
// 690 = 内容 ~545 + 标题栏/Tab 条/状态栏 ~125 + 余量（见 settings-tabs 测试）。
|
||
width: 420, height: 690,
|
||
file: 'settings.html',
|
||
onClose: () => { settingsWindow = null; },
|
||
});
|
||
settingsWindow.webContents.on('before-input-event', (_e, input) => { if (input.key === 'F12') settingsWindow.webContents.toggleDevTools(); });
|
||
settingsWindow.show();
|
||
}
|
||
|
||
function positionAtTopCenter() {
|
||
if (!mainWindow) return;
|
||
const display = screen.getPrimaryDisplay();
|
||
const wa = display.workArea;
|
||
const w = mainWindow.getBounds().width;
|
||
const x = Math.round(wa.x + (wa.width - w) / 2);
|
||
const y = Math.round(wa.y + wa.height * 0.18);
|
||
mainWindow.setPosition(x, y);
|
||
}
|
||
|
||
|
||
// ---------- 全局快捷键 ----------
|
||
|
||
// 当前实际注册成功的 accelerator。改键 / 退出时用它精确解绑。
|
||
// '' = 此刻没注册任何东西（配置为禁用，或注册失败）。
|
||
let registeredHotkey = '';
|
||
|
||
/**
|
||
* 按 appConfig.hotkey 重新注册全局唤起快捷键 → toggleWindow()。
|
||
*
|
||
* 幂等：先解绑上一次注册成功的键，再注册新键。启动、设置里改键两条路
|
||
* 都走这里。返回 true = 生效（注册成功，或配置就是禁用）；false = 想注册
|
||
* 但没成（accelerator 被别的程序占用 / 无效），设置界面据此提示用户。
|
||
*
|
||
* 必须在 app.whenReady() 之后调用 —— globalShortcut 在这之前不可用。
|
||
*/
|
||
function applyHotkey() {
|
||
// 记下旧的（成功注册过、且这次想换）—— 失败时把它注册回去。
|
||
// 不留这个快照的话：从能用的 'A' 改成被占用的 'B' 会让用户
|
||
// 暂时完全没有全局快捷键（unregister A 已成事实，B 又注册不上）。
|
||
const prev = registeredHotkey;
|
||
if (prev) {
|
||
try { globalShortcut.unregister(prev); } catch (_) {}
|
||
registeredHotkey = '';
|
||
}
|
||
const acc = appConfig.hotkey;
|
||
if (!acc) return true; // 配置为禁用 —— 不是失败
|
||
const tryRegister = (target) => {
|
||
try {
|
||
// register 同步返回 boolean：false = 组合键已被占用，回调永远不会触发
|
||
return globalShortcut.register(target, () => toggleWindow());
|
||
} catch (_) {
|
||
// accelerator 格式非法时 register 会抛异常（而不是返回 false）
|
||
return false;
|
||
}
|
||
};
|
||
if (tryRegister(acc)) {
|
||
registeredHotkey = acc;
|
||
devLog(`[hotkey] registered ${acc}`);
|
||
return true;
|
||
}
|
||
devWarn(`[hotkey] register failed (in use or invalid): ${acc}`);
|
||
if (prev && tryRegister(prev)) {
|
||
registeredHotkey = prev;
|
||
devLog(`[hotkey] recovered previous ${prev} after failed re-register`);
|
||
return false; // 仍然告诉设置界面「这次没注册上」
|
||
}
|
||
return false;
|
||
}
|
||
|
||
|
||
// ---------- 托盘 ----------
|
||
|
||
let tray = null;
|
||
let trayIconCache = null;
|
||
|
||
function getTrayIcon() {
|
||
if (trayIconCache) return trayIconCache;
|
||
// 优先用随包发布的 icon.ico（多尺寸 16~256），缺失或解析失败时回退程序化绘制
|
||
try {
|
||
const iconPath = path.join(__dirname, 'icon.ico');
|
||
if (fs.existsSync(iconPath)) {
|
||
const img = nativeImage.createFromPath(iconPath);
|
||
if (!img.isEmpty()) {
|
||
trayIconCache = img;
|
||
return trayIconCache;
|
||
}
|
||
devWarn('[tray] icon.ico loaded as empty image, falling back to drawn icon');
|
||
} else {
|
||
devWarn('[tray] icon.ico not found at', iconPath, ', falling back to drawn icon');
|
||
}
|
||
} catch (e) {
|
||
devWarn('[tray] load icon.ico failed:', e.message, ', falling back to drawn icon');
|
||
}
|
||
trayIconCache = buildTrayIcon();
|
||
return trayIconCache;
|
||
}
|
||
|
||
function buildTrayIcon() {
|
||
// 64×64 程序化绘制
|
||
const size = 64;
|
||
const img = nativeImage.createEmpty();
|
||
const buf = Buffer.alloc(size * size * 4);
|
||
const setPx = (x, y, r, g, b, a = 255) => {
|
||
const i = (y * size + x) * 4;
|
||
buf[i] = b; buf[i + 1] = g; buf[i + 2] = r; buf[i + 3] = a;
|
||
};
|
||
|
||
// 圆角蓝底
|
||
for (let y = 0; y < size; y++) {
|
||
for (let x = 0; x < size; x++) {
|
||
const dx = Math.max(0, Math.max(4 - x, x - (size - 5)));
|
||
const dy = Math.max(0, Math.max(4 - y, y - (size - 5)));
|
||
const r2 = dx * dx + dy * dy;
|
||
if (r2 <= 14 * 14) setPx(x, y, 59, 130, 246); // #3B82F6
|
||
else setPx(x, y, 0, 0, 0, 0);
|
||
}
|
||
}
|
||
// 顶部夹子
|
||
for (let y = 8; y < 16; y++)
|
||
for (let x = 22; x < 42; x++) setPx(x, y, 255, 255, 255);
|
||
// 下方白板
|
||
for (let y = 20; y < 52; y++)
|
||
for (let x = 14; x < 50; x++) setPx(x, y, 255, 255, 255);
|
||
// 内层蓝线
|
||
for (let x = 20; x < 44; x++) { setPx(x, 30, 59, 130, 246); setPx(x, 36, 59, 130, 246); }
|
||
for (let x = 20; x < 38; x++) setPx(x, 42, 59, 130, 246);
|
||
|
||
return nativeImage.createFromBuffer(buf, { width: size, height: size });
|
||
}
|
||
|
||
// ---------- 应用图标（标题栏左上角 + OS 窗口图标） ----------
|
||
|
||
let appIconDataUrlCache = null;
|
||
|
||
/**
|
||
* 把 icon.ico 转成 32×32 PNG data URL，给渲染进程当 `<img src>` 用。
|
||
*
|
||
* 与 getTrayIcon 独立缓存：托盘要的是 nativeImage（喂给 Tray.setImage），
|
||
* 标题栏要的是 data URL（浏览器渲染），且目标尺寸也不同。
|
||
*
|
||
* 缓存命中空字符串表示"曾经加载失败"，避免每个窗口启动时都重新尝试。
|
||
*/
|
||
function getAppIconDataUrl() {
|
||
if (appIconDataUrlCache !== null) return appIconDataUrlCache;
|
||
try {
|
||
const iconPath = path.join(__dirname, 'icon.ico');
|
||
if (!fs.existsSync(iconPath)) throw new Error('icon.ico not found');
|
||
const img = nativeImage.createFromPath(iconPath);
|
||
if (img.isEmpty()) throw new Error('empty image');
|
||
// 32×32：标题栏 CSS 显示 16px，2x HiDPI 下仍锐利。
|
||
// .ico 内置最大 256×256，resize 是高质量降采样。
|
||
const resized = img.resize({ width: 32, height: 32, quality: 'best' });
|
||
appIconDataUrlCache = resized.toDataURL();
|
||
return appIconDataUrlCache;
|
||
} catch (e) {
|
||
devWarn('[app-icon] failed to load icon.ico:', e.message);
|
||
appIconDataUrlCache = '';
|
||
return '';
|
||
}
|
||
}
|
||
|
||
// ---------- 主题元数据 ----------
|
||
|
||
function applyThemeChange(patch) {
|
||
appConfig = configMod.sanitize({ ...appConfig, ...patch });
|
||
// 落盘失败要带给 UI（同 settings:set）：本次会话生效、重启还原，得让用户知道。
|
||
let saved = true;
|
||
try { configMod.saveConfig(appConfig); }
|
||
catch (e) { saved = false; console.error('[theme] saveConfig failed:', e.message); }
|
||
broadcastTheme();
|
||
// 同步返回 effectiveTheme —— settings.js 拿到后要用它设 data-theme，
|
||
// 不用 raw 主题。返回的 rawTheme 字段给 localStorage / 测试 / 调试用。
|
||
const sysDark = nativeTheme.shouldUseDarkColors;
|
||
const effective = configMod.effectiveTheme(appConfig, sysDark);
|
||
return {
|
||
theme: effective,
|
||
effectiveTheme: effective,
|
||
rawTheme: appConfig.theme,
|
||
accent: appConfig.accent,
|
||
followSystem: appConfig.followSystem,
|
||
systemDark: sysDark,
|
||
saved,
|
||
};
|
||
}
|
||
|
||
function buildTray() {
|
||
if (tray) { try { tray.destroy(); } catch (_) {} tray = null; }
|
||
tray = new Tray(getTrayIcon());
|
||
tray.setToolTip(APP_NAME);
|
||
tray.setContextMenu(Menu.buildFromTemplate(buildTrayMenuTemplate({
|
||
onShow: () => toggleWindow(),
|
||
onSettings: () => openSettingsWindow(),
|
||
onQuit: () => app.quit(),
|
||
})));
|
||
tray.on('click', () => toggleWindow());
|
||
// 不要同时挂 double-click：单击触发 click → 再过 ~500ms 又触发 double-click，
|
||
// 两次 toggleWindow 让用户「双击托盘」变「开一下立刻关掉」。
|
||
// 单击是主流用法，需要双击唤起的用户极少；硬要可托 tray.setIgnoreDoubleClickEvents(true)。
|
||
}
|
||
|
||
|
||
// ---------- 复制到剪贴板 ----------
|
||
|
||
// 共用的"载荷 → 系统剪贴板"一步，带回声抑制：记下写进去的内容，
|
||
// 让轮询在真正读到它时吞掉，避免自己的写入被当成新内容入库。
|
||
function writePayloadToClipboard(payload) {
|
||
// markOwnWrite 预置基线 + 回声标记，返回的 undo 供写入失败时回滚：
|
||
// 失败时剪贴板上还是旧内容，基线却已是新值，不回滚下个 tick 会把真实
|
||
// 旧内容当"新变化"重复入库。写入成功则基线保持预置，下一 tick 直接走
|
||
// "无变化"分支，连读图/编码的代价都不付。
|
||
if (payload.kind === 'text') {
|
||
// 记下"我们写进去的内容"，poll 真正读到这串内容时才吞。
|
||
// 比占位 flag 更严：中间夹了外部复制也不会误吞。
|
||
const undo = textSuppress.markOwnWrite(payload.text);
|
||
try { clipboard.writeText(payload.text); }
|
||
catch (e) { undo(); throw e; }
|
||
} else {
|
||
const img = nativeImage.createFromBuffer(payload.buffer);
|
||
if (img.isEmpty()) throw new Error('图片解码失败');
|
||
// 必须和 pollClipboard 用同一套指纹（原始位图，不是 PNG 字节），
|
||
// 否则下一个 tick 会把我们自己写进去的图当成新图。
|
||
const undo = imageSuppress.markOwnWrite(imageFingerprint(img));
|
||
try { clipboard.writeImage(img); }
|
||
catch (e) { undo(); throw e; }
|
||
}
|
||
}
|
||
|
||
// 把某条历史记录写入系统剪贴板（不触发重复入库）
|
||
function copyClipToClipboard(clipId) {
|
||
const row = stmt.get.get(clipId);
|
||
if (!row) return false;
|
||
try {
|
||
writePayloadToClipboard(clipPayload(row));
|
||
devLog(`[clipboard] copied id=${clipId} type=${row.type}`);
|
||
return true;
|
||
} catch (e) {
|
||
// 失败时清掉刚记下的 echo 标记，否则会吞掉用户接下来的一次真实复制
|
||
textSuppress.clearPending();
|
||
imageSuppress.clearPending();
|
||
console.error('[clipboard] copy failed:', e.message);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 把收藏自身存下的内容写入系统剪贴板。
|
||
// 收藏与历史分库，favId 和历史 id 是两套独立自增数 —— 绝不能拿 favId
|
||
// 走 copyClipToClipboard，那会按同号去 clips 表查到一条无关的历史记录
|
||
// （两个库都有 id=1 时必中），把错误内容静默写进剪贴板。
|
||
function copyFavToClipboard(favId) {
|
||
const row = favorites.getRaw(favDb, favId);
|
||
if (!row) return false;
|
||
try {
|
||
writePayloadToClipboard(clipPayload(row));
|
||
devLog(`[clipboard] copied fav id=${favId} type=${row.type}`);
|
||
} catch (e) {
|
||
textSuppress.clearPending();
|
||
imageSuppress.clearPending();
|
||
console.error('[clipboard] fav copy failed:', e.message);
|
||
return false;
|
||
}
|
||
// 收藏 Tab 复制也要在历史 Tab 留一份 —— 收藏与历史分库，源记录可能已
|
||
// 被清理（那才是用户去收藏 Tab 点复制的原因）。源还在 → 置顶（与历史
|
||
// Tab 复制行为对齐），源不在 / 无源 → 当作新内容入库。
|
||
try {
|
||
bringFavoriteIntoHistory(row);
|
||
} catch (e) {
|
||
// 入库失败不能把整个复制操作搞砸 —— 剪贴板已经写好了，
|
||
// 用户最差就是看到「历史 Tab 没冒新条目」，比「复制失败」轻得多。
|
||
console.error('[clipboard] fav copy → history bridge failed:', e.message);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 把收藏的内容带到历史 Tab。源记录还在 → 置顶；不在 → 当新条目入库。
|
||
// 入库路径与 pollClipboard 一致：clipCount++ / enforceLimit / notifyNew，
|
||
// 让 poll 缓存、上限清理、横切通知这些只剩一份实现。
|
||
function bringFavoriteIntoHistory(row) {
|
||
const sourceId = row.source_clip_id;
|
||
if (sourceId != null) {
|
||
const existing = stmt.get.get(sourceId);
|
||
if (existing) {
|
||
const now = Date.now() / 1000;
|
||
stmt.moveToTop.run(now, now, sourceId);
|
||
notifyRefresh();
|
||
return;
|
||
}
|
||
}
|
||
const now = Date.now() / 1000;
|
||
let info;
|
||
if (row.type === 'text') {
|
||
const text = row.text || '';
|
||
const preview = row.preview || makePreview(text);
|
||
info = stmt.insertText.run(text, preview, null, now);
|
||
} else {
|
||
// 图片：复用 poll 的尺寸/预览判定，超大图压成 800px 宽保证 SOFT_CAP 不爆
|
||
const buf = Buffer.isBuffer(row.image) ? row.image : Buffer.from(row.image || []);
|
||
const { buf: resized, preview: capPreview } = normalizeImageForStorage(buf);
|
||
const preview = capPreview || '[图片]';
|
||
info = stmt.insertImage.run(resized, preview, null, now);
|
||
}
|
||
if (clipCount != null) clipCount++;
|
||
enforceLimit();
|
||
notifyNew(rowToClip(stmt.getMeta.get(info.lastInsertRowid)));
|
||
}
|
||
|
||
// 通知所有订阅者刷新（用于 clear-top 等场景）
|
||
function notifyRefresh() {
|
||
subscribers.notifyClip('clips:refresh');
|
||
}
|
||
|
||
// 通知所有订阅者收藏列表已变更
|
||
function notifyFavoritesChanged() {
|
||
subscribers.notifyFav('favorites:changed');
|
||
}
|
||
|
||
|
||
// ---------- IPC ----------
|
||
|
||
const subscribers = createSubscribers();
|
||
|
||
function notifyNew(clip) {
|
||
subscribers.notifyClip('clips:added', clip);
|
||
}
|
||
// 把渲染进程的 console 转发到主进程终端（方便调试）
|
||
function forwardRendererLog(webContents) {
|
||
if (process.env.CB_LOG !== '1') return;
|
||
webContents.on('console-message', (_e, level, message) => {
|
||
const tag = ['DBG', 'INF', 'WRN', 'ERR'][level] || 'LOG';
|
||
devLog(`[renderer ${tag}] ${message}`);
|
||
});
|
||
}
|
||
|
||
function registerIpc() {
|
||
ipcMain.handle('clips:list', (_e, { query = '', limit = 0 } = {}) => {
|
||
// limit = 0 → 用配置的界面显示条数；设置改了之后渲染进程重新拉就生效
|
||
const eff = limit > 0 ? limit : (appConfig.displayLimit || 300);
|
||
const plan = planSearch(query);
|
||
let rows;
|
||
if (plan.mode === 'fts' && stmt.searchFts) {
|
||
try {
|
||
rows = stmt.searchFts.all(plan.match, eff);
|
||
} catch (e) {
|
||
// FTS 出问题就退回 LIKE，不要把搜索整个打死
|
||
devWarn('[clips:list] FTS search failed, falling back to LIKE:', e.message);
|
||
rows = searchLikeRows(likePatterns(query), eff);
|
||
}
|
||
} else if (plan.mode === 'fts') {
|
||
// 没有 FTS 索引（老库 / 这个 SQLite 不带 FTS5）
|
||
rows = searchLikeRows(likePatterns(query), eff);
|
||
} else if (plan.mode === 'like') {
|
||
rows = searchLikeRows(plan.patterns, eff);
|
||
} else {
|
||
rows = stmt.listAll.all(eff);
|
||
}
|
||
return listWithFavorited(rows.map(rowToClip));
|
||
});
|
||
|
||
// 图片按需拉取：列表只带 hasImage 标记，渲染进程滚到哪张才取哪张。
|
||
// 之前 clips:list 会把 200 条的 image BLOB 全部 base64 后过 IPC，
|
||
// 几十条图片就是几百 MB 的字符串。
|
||
ipcMain.handle('clips:get-image', (_e, { id }) => {
|
||
const row = stmt.getImage.get(id);
|
||
if (!row || !row.image) return null;
|
||
// row.image 是 better-sqlite3 BLOB 列，原生就是 Buffer；
|
||
// 之前 Buffer.from(row.image) 是一次额外拷贝（2MB 图 → 2MB 浪费）。
|
||
// Buffer.prototype.toString('base64') 不需要再 wrap一层。
|
||
return row.image.toString('base64');
|
||
});
|
||
|
||
ipcMain.handle('clips:count', () => getClipCount());
|
||
|
||
ipcMain.handle('clips:movetop', async (_e, { id }) => {
|
||
const now = Date.now() / 1000;
|
||
stmt.moveToTop.run(now, now, id);
|
||
// 把该内容写入系统剪贴板，用户切到目标窗口自己按 Ctrl+V 即可。
|
||
const copied = copyClipToClipboard(id);
|
||
notifyRefresh();
|
||
// 渲染到 IPC 之间可能已被自动清理（enforceLimit）—— row 可能不存在。
|
||
// 但剪贴板已经写成功了，渲染端必须能正确报"已写入"，
|
||
// 而不是把它当失败。让 row 缺失只影响回显字段，copied 不动。
|
||
const row = stmt.getMeta.get(id);
|
||
if (!row) return { copied, pasted: false, clip: null };
|
||
|
||
// 不做自动粘贴、不隐藏/最小化窗口 —— 界面任何时候都保持可见。
|
||
// （自动粘贴需要交出焦点必然要藏窗口，会产生"缩一下"的动画，用户明确不要。）
|
||
return { ...listWithFavorited([rowToClip(row)])[0], copied, pasted: false };
|
||
});
|
||
|
||
ipcMain.handle('clips:delete', (_e, { id }) => {
|
||
const changes = stmt.delete.run(id).changes;
|
||
if (clipCount != null) clipCount -= changes;
|
||
if (changes) notifyRefresh();
|
||
return true;
|
||
});
|
||
|
||
// clips:clear-natural 已彻底移除 —— 历史 Tab 从不调用它，
|
||
// 唯一在用的清空历史入口是 settings:clear-history（设置窗口）。
|
||
// 两份路径完全是同实现（clearNonTop + clipCount = null + notifyRefresh），
|
||
// 留一条就够了 —— ipc-wiring 守的是双向一致，一删都删。
|
||
|
||
ipcMain.handle('clips:subscribe', (e) => {
|
||
subscribers.addClip(e.sender);
|
||
e.sender.on('destroyed', () => subscribers.drop(e.sender));
|
||
return true;
|
||
});
|
||
|
||
ipcMain.handle('settings:open', () => {
|
||
openSettingsWindow();
|
||
return true;
|
||
});
|
||
|
||
function favGuard() {
|
||
if (!favDb) throw new Error('favorites 不可用');
|
||
}
|
||
|
||
ipcMain.handle('favorites:add', (_e, { clipId }) => {
|
||
favGuard();
|
||
const row = stmt.get.get(clipId);
|
||
if (!row) throw new Error('源记录不存在');
|
||
// 幂等：重复收藏同一条（双击竞态 / 快速连点）不抛 UNIQUE 约束错，
|
||
// 直接返回已有收藏行。
|
||
const existFavId = favorites.isFavorited(favDb, row.id);
|
||
if (existFavId) return favorites.get(favDb, existFavId);
|
||
const result = favorites.add(favDb, {
|
||
id: row.id,
|
||
type: row.type,
|
||
text: row.text,
|
||
image: row.image,
|
||
preview: row.preview,
|
||
createdAt: row.created_at,
|
||
});
|
||
notifyFavoritesChanged();
|
||
return result;
|
||
});
|
||
|
||
ipcMain.handle('favorites:remove', (_e, { favId }) => {
|
||
favGuard();
|
||
const ok = favorites.remove(favDb, favId);
|
||
notifyFavoritesChanged();
|
||
return ok;
|
||
});
|
||
|
||
ipcMain.handle('favorites:list', (_e, { query = '', limit = 0 } = {}) => {
|
||
favGuard();
|
||
// 收藏列表也走 displayLimit —— 渲染层 limit=0 → 用配置档位
|
||
const eff = limit > 0 ? limit : (appConfig.displayLimit || 300);
|
||
return favorites.list(favDb, query, eff);
|
||
});
|
||
|
||
// 只要一个数字。之前渲染进程为了显示收藏计数会拉全部 5000 条（含图片 base64），
|
||
// 收藏里有几百张图时就是几百 MB 的无谓开销。
|
||
ipcMain.handle('favorites:count', () => (favDb ? favorites.count(favDb) : 0));
|
||
|
||
ipcMain.handle('favorites:get-image', (_e, { favId }) => {
|
||
if (!favDb) return null;
|
||
return favorites.getImage(favDb, favId);
|
||
});
|
||
|
||
// 收藏 Tab 的"复制"：写收藏自己存的内容（源记录可能早已被清理）。
|
||
// 返回形状与 clips:movetop 对齐：copied / pasted（不自动粘贴，恒 false）。
|
||
ipcMain.handle('favorites:copy', (_e, { favId }) => {
|
||
favGuard();
|
||
const copied = copyFavToClipboard(favId);
|
||
return copied ? { copied: true, pasted: false } : null;
|
||
});
|
||
|
||
ipcMain.handle('favorites:subscribe', (e) => {
|
||
subscribers.addFav(e.sender);
|
||
e.sender.on('destroyed', () => subscribers.drop(e.sender));
|
||
return true;
|
||
});
|
||
|
||
ipcMain.handle('window:hide', () => {
|
||
if (mainWindow) mainWindow.hide();
|
||
});
|
||
|
||
// on 省略（undefined）→ 翻转；传 boolean → 直接设置
|
||
ipcMain.handle('window:toggle-always-on-top', (_e, { on } = {}) =>
|
||
applyAlwaysOnTop(typeof on === 'boolean' ? on : !alwaysOnTop));
|
||
|
||
ipcMain.handle('window:get-always-on-top', () => alwaysOnTop);
|
||
|
||
// 标题栏左上角小图标：返回 PNG data URL，渲染进程直接喂给 <img src>。
|
||
// 命中缓存后基本零成本（一次 IPC 往返 + 一个字符串赋值）。
|
||
ipcMain.handle('app:get-icon', () => getAppIconDataUrl());
|
||
|
||
ipcMain.handle('theme:get', () => {
|
||
// 跟 broadcastTheme / applyThemeChange 同形 —— 渲染端拿到时直接用 effectiveTheme
|
||
// 设 data-theme，不需要自己再判 followSystem（之前由渲染端各自判，反而因为
|
||
// IPC 顺序竞争让设置窗口 / 主窗口在「跟随系统」开着的状态下显示 raw 主题）。
|
||
const sysDark = nativeTheme.shouldUseDarkColors;
|
||
const effective = configMod.effectiveTheme(appConfig, sysDark);
|
||
return {
|
||
theme: effective,
|
||
effectiveTheme: effective,
|
||
rawTheme: appConfig.theme,
|
||
accent: appConfig.accent,
|
||
followSystem: appConfig.followSystem,
|
||
systemDark: sysDark,
|
||
};
|
||
});
|
||
|
||
// 没有这个订阅，broadcastTheme() 就是在往一个永远空的集合里发 ——
|
||
// "跟随系统"改了主题后，已经打开的窗口收不到任何通知。
|
||
ipcMain.handle('theme:subscribe', (e) => {
|
||
subscribers.addTheme(e.sender);
|
||
e.sender.on('destroyed', () => subscribers.drop(e.sender));
|
||
return true;
|
||
});
|
||
|
||
ipcMain.handle('theme:set', (_e, { theme }) => {
|
||
if (!configMod.ALLOWED_THEMES.includes(theme)) return null;
|
||
return applyThemeChange({ theme, followSystem: false });
|
||
});
|
||
|
||
ipcMain.handle('theme:set-accent', (_e, { accent }) => {
|
||
if (!configMod.ALLOWED_ACCENTS.includes(accent)) return null;
|
||
return applyThemeChange({ accent });
|
||
});
|
||
|
||
ipcMain.handle('theme:set-follow-system', (_e, { followSystem }) => {
|
||
return applyThemeChange({ followSystem: followSystem === true });
|
||
});
|
||
|
||
ipcMain.handle('settings:get', () => ({ ...appConfig }));
|
||
|
||
ipcMain.handle('settings:set', (_e, { key, value }) => {
|
||
appConfig = applyPatch(appConfig, { key, value });
|
||
let extra = {};
|
||
if (key === 'autoLaunch') {
|
||
try { app.setLoginItemSettings({ openAtLogin: appConfig.autoLaunch }); }
|
||
catch (e) { console.error('[settings] setLoginItem failed:', e.message); }
|
||
} else if (key === 'maxItems') {
|
||
applyMaxItems(appConfig.maxItems);
|
||
} else if (key === 'pollMs') {
|
||
applyPollMs(appConfig.pollMs);
|
||
} else if (key === 'hotkey') {
|
||
// 立刻换键生效。注册失败（被占用）也照存配置 —— 占用是暂时的，
|
||
// 重启后可能就空出来了；同时把失败状态带给设置界面提示用户。
|
||
extra = { hotkeyRegistered: applyHotkey() };
|
||
} else if (key === 'displayLimit') {
|
||
// 推到所有 BrowserWindow，渲染层订阅后自己 reload()（用新 limit 重拉）。
|
||
// 不直接 reload：跨窗口（设置窗口改、主窗口收）需要统一走 IPC 通知。
|
||
for (const w of BrowserWindow.getAllWindows()) {
|
||
try { w.webContents.send('settings:display-limit-changed', { displayLimit: appConfig.displayLimit }); }
|
||
catch (_) {}
|
||
}
|
||
}
|
||
// 落盘失败不能只打日志：运行时状态（轮询间隔/快捷键/登录项）已经改了，
|
||
// 但重启会按磁盘旧值还原 —— 必须如实告诉渲染端，由 UI 提示"未保存"。
|
||
try { configMod.saveConfig(appConfig); }
|
||
catch (e) {
|
||
console.error('[settings] saveConfig failed:', e.message);
|
||
extra = { ...extra, saved: false, saveError: e.message };
|
||
}
|
||
return { ...appConfig, ...extra };
|
||
});
|
||
|
||
ipcMain.handle('settings:clear-history', () => {
|
||
// 与 clips:clear-natural 同构：行数缓存必须作废，否则下次入库
|
||
// enforceLimit 按过期行数算差值，会把刚插入的新记录（乃至所有
|
||
// 非置顶项）误删；开着的主窗口也要推一条刷新，不然列表停在已删除的项上。
|
||
try {
|
||
const changes = stmt.clearNonTop.run().changes;
|
||
clipCount = null; // 重新回源计数
|
||
if (changes) notifyRefresh();
|
||
return changes;
|
||
} catch (e) {
|
||
console.error('[settings] clear-history failed:', e.message);
|
||
return 0;
|
||
}
|
||
});
|
||
|
||
ipcMain.handle('settings:open-dir', () => {
|
||
// openPath 返回 Promise<string>：失败原因是 resolve 出来的错误串（不是 reject），
|
||
// 同步 try/catch 接不到任何东西，失败时用户点了没反应、日志里也没痕迹。
|
||
// 走 effectiveDataDir() —— 启动兜底后用户看的是真正在用的目录，而不是坏的盘符。
|
||
shell.openPath(effectiveDataDir()).then(
|
||
(err) => { if (err) console.error('[settings] openPath failed:', err); },
|
||
(e) => { console.error('[settings] openPath failed:', e.message); }
|
||
);
|
||
});
|
||
|
||
// 外链一律交给系统浏览器：设置窗口直接导航出去会把整个页面拖走。
|
||
// scheme 必须卡死在 http/https —— shell.openExternal 接受任意 scheme
|
||
// （file:、自定义协议），渲染进程递来的字符串不校验就是 RCE 面。
|
||
// openExternal 返回 Promise：OS 拒绝时 reject，必须 await —— 不 await 的话
|
||
// try/catch 接不住，Node 20 默认把 unhandled rejection 升级成主进程崩溃。
|
||
ipcMain.handle('settings:open-external', async (_e, { url } = {}) => {
|
||
if (typeof url !== 'string' || !/^https?:\/\//i.test(url)) return { ok: false };
|
||
try {
|
||
await shell.openExternal(url);
|
||
return { ok: true };
|
||
} catch (e) {
|
||
console.error('[settings] openExternal failed:', e.message);
|
||
return { ok: false };
|
||
}
|
||
});
|
||
|
||
function copyIfExists(src, dst) {
|
||
if (fs.existsSync(src)) fs.copyFileSync(src, dst);
|
||
}
|
||
|
||
function dbFileSet(dir) {
|
||
return [
|
||
path.join(dir, 'history.db'),
|
||
path.join(dir, 'history.db-wal'),
|
||
path.join(dir, 'history.db-shm'),
|
||
path.join(dir, 'favorites.db'),
|
||
path.join(dir, 'favorites.db-wal'),
|
||
path.join(dir, 'favorites.db-shm'),
|
||
];
|
||
}
|
||
|
||
// 迁移复制只搬 db + wal。-shm 是 WAL 的临时共享内存索引，SQLite 打开时
|
||
// 自己重建，搬一个可能与 wal 不同步的快照过去反而更糟（与 config.js
|
||
// migrateLegacyData 的处理一致）。dbFileSet 保留 -shm 是给「删旧文件 /
|
||
// 清理失败目标」用的 —— 删的时候要删干净。
|
||
const COPY_NAMES = ['history.db', 'history.db-wal', 'favorites.db', 'favorites.db-wal'];
|
||
|
||
ipcMain.handle('settings:choose-dir', async () => {
|
||
// 1. 选目录
|
||
const pick = await dialog.showOpenDialog({
|
||
title: '选择数据保存位置',
|
||
properties: ['openDirectory', 'createDirectory'],
|
||
});
|
||
if (pick.canceled || !pick.filePaths[0]) return { ok: false };
|
||
const newDir = pick.filePaths[0];
|
||
// Windows 大小写不敏感：D:\X 与 d:\x 是同一目录，必须按平台语义比较，
|
||
// 否则重选当前目录会绕过这个提示、走到下面"目标已有数据"自己迁自己。
|
||
// 比较 effectiveDataDir()（含 session 降级）—— 用户在兜底状态下重选
|
||
// 同一个 session 目录时不弹迁移对话框自己迁自己。
|
||
if (isSameDir(newDir, effectiveDataDir())) {
|
||
return { ok: false, message: '已经是当前数据位置' };
|
||
}
|
||
|
||
// 2. 可写校验
|
||
try {
|
||
fs.mkdirSync(newDir, { recursive: true });
|
||
const probe = path.join(newDir, '.write-test');
|
||
fs.writeFileSync(probe, 'ok'); fs.unlinkSync(probe);
|
||
} catch (e) {
|
||
return { ok: false, message: '目标目录不可写：' + e.message };
|
||
}
|
||
|
||
const targetDb = path.join(newDir, 'history.db');
|
||
const targetExists = fs.existsSync(targetDb);
|
||
|
||
// 3. 目标已有 db → 二选一
|
||
if (targetExists) {
|
||
const r = dialog.showMessageBoxSync({
|
||
type: 'question',
|
||
buttons: ['使用该目录的现有数据', '取消'],
|
||
defaultId: 1,
|
||
cancelId: 1,
|
||
title: '目标已有数据',
|
||
message: '该目录已存在剪贴板数据。是否直接使用它？',
|
||
detail: '选择「使用现有数据」将切换到该目录的数据库（不会合并当前数据）。',
|
||
});
|
||
if (r !== 0) return { ok: false, message: '已取消' };
|
||
const oldDir = effectiveDataDir();
|
||
stopPolling(); // 马上退出；别让轮询在退出前的间隙再写旧库
|
||
appConfig.dataDir = newDir;
|
||
sessionDataDir = null; // 用户已正式选定新目录，session 兜底退出
|
||
try { configMod.saveConfig(appConfig); }
|
||
catch (e) {
|
||
// 失败后应用留在旧目录继续运行：回滚内存配置 + 恢复轮询，
|
||
// 否则剪贴板监听静默死掉，且后续任何 settings:set 会把错误的
|
||
// newDir 落盘（内存/落盘分叉，同 choose-dir 迁移分支修过的坑）。
|
||
appConfig.dataDir = oldDir;
|
||
startPolling();
|
||
return { ok: false, message: '保存配置失败：' + e.message };
|
||
}
|
||
app.relaunch();
|
||
app.quit();
|
||
return { ok: true };
|
||
}
|
||
|
||
// 4. 迁移：停轮询 → 关闭 db → 复制 → 校验 → 删旧 → 写 config → 重启
|
||
// 轮询的 prepared statements 绑在旧连接上：必须先停轮询再关库，否则迁移
|
||
// 期间（复制+校验有几十~几百 ms 窗口）tick 触发会抛 "database is closed"，
|
||
// 这一两秒里的外部复制也会被静默丢掉。失败恢复路径里会重新 startPolling()。
|
||
stopPolling();
|
||
// 旧目录可能是 sessionDataDir 兜底出来的 —— 用 effectiveDataDir()，
|
||
// 不要再用裸 appConfig.dataDir，否则 session 状态下会从用户原本选的
|
||
// （不可用的）目录复制，而当前在用的兜底目录里的数据被丢在原地。
|
||
const oldDir = effectiveDataDir();
|
||
try {
|
||
if (db) { const d = db; db = null; d.close(); }
|
||
if (favDb) { const f = favDb; favDb = null; favorites.close(f); }
|
||
} catch (e) {
|
||
// db.close 抛错时把句柄置空再恢复轮询：留着旧句柄会让下一个 tick
|
||
// 在已关闭的连接上 prepare，抛 "database is closed" 打到控制台。
|
||
db = null; favDb = null;
|
||
startPolling(); // 关库失败也要恢复轮询，应用还留在旧目录运行
|
||
return { ok: false, message: '关闭数据库失败：' + e.message };
|
||
}
|
||
|
||
try {
|
||
const oldFavDbExists = fs.existsSync(path.join(oldDir, 'favorites.db'));
|
||
for (const name of COPY_NAMES) {
|
||
copyIfExists(path.join(oldDir, name), path.join(newDir, name));
|
||
}
|
||
|
||
const testH = new Database(path.join(newDir, 'history.db'));
|
||
testH.prepare('SELECT COUNT(*) AS n FROM clips').get();
|
||
testH.close();
|
||
|
||
// 旧目录没有 favorites.db（升级自旧版本）→ 用 favorites.open() 初始化空库
|
||
if (!oldFavDbExists) {
|
||
const initFav = favorites.open(path.join(newDir, 'favorites.db'));
|
||
favorites.close(initFav);
|
||
}
|
||
|
||
const testF = new Database(path.join(newDir, 'favorites.db'));
|
||
testF.prepare('SELECT COUNT(*) AS n FROM favorites').get();
|
||
testF.close();
|
||
} catch (e) {
|
||
try { for (const f of dbFileSet(newDir)) if (fs.existsSync(f)) fs.unlinkSync(f); } catch (_) {}
|
||
try { openDb(); } catch (_) {}
|
||
try { openFavDb(); } catch (_) {}
|
||
startPolling(); // 迁移失败、留在旧目录：必须恢复剪贴板监听
|
||
return { ok: false, message: '迁移失败，已保留原数据：' + e.message };
|
||
}
|
||
|
||
// 先写 config + 重开新库（指向新位置），再删旧文件 —— 避免崩溃窗口遗留孤儿数据。
|
||
// 失败分支语义：新文件已复制成功但配置未落盘 → 不删旧文件（两边都在，下次启动
|
||
// 仍能从旧目录恢复），内存里切到新目录让会话内可用，重启后由 config 决定位置。
|
||
appConfig.dataDir = newDir;
|
||
sessionDataDir = null; // 用户已正式选定新目录，session 兜底退出
|
||
try { configMod.saveConfig(appConfig); }
|
||
catch (e) {
|
||
try { openDb(); } catch (_) {}
|
||
try { openFavDb(); } catch (_) {}
|
||
startPolling(); // 应用继续运行（已切到新库）：恢复监听
|
||
return { ok: false, message: '数据已迁移但配置未保存：' + e.message };
|
||
}
|
||
try { for (const f of dbFileSet(oldDir)) if (fs.existsSync(f)) fs.unlinkSync(f); } catch (_) {}
|
||
|
||
app.relaunch();
|
||
app.quit();
|
||
return { ok: true };
|
||
});
|
||
}
|
||
|
||
|
||
// ---------- 单实例 + 启动 ----------
|
||
|
||
const gotLock = app.requestSingleInstanceLock();
|
||
if (!gotLock) {
|
||
app.quit();
|
||
} else {
|
||
// 老版本把数据放在 %USERPROFILE%\.clipboard-app，现在默认固定在
|
||
// D:\Clipboard Data。第一次跑到新目录时把老数据搬过来（复制，老文件保留）。
|
||
// 放在单实例锁之后：否则被忽略的第二个实例会去复制正在被写的 WAL。
|
||
try {
|
||
const mig = configMod.migrateLegacyData();
|
||
if (mig.migrated) {
|
||
devLog(`[main] 数据已从 ${mig.from} 迁移到 ${mig.to}：${mig.files.join(', ') || '(仅配置)'}`);
|
||
appConfig = configMod.loadConfig();
|
||
MAX_ITEMS = appConfig.maxItems;
|
||
POLL_MS = appConfig.pollMs;
|
||
}
|
||
} catch (e) {
|
||
console.error('[main] 老数据迁移失败（继续用新目录启动）:', e.message);
|
||
}
|
||
|
||
app.on('second-instance', () => toggleWindow());
|
||
|
||
app.whenReady().then(() => {
|
||
try {
|
||
devLog('[main] whenReady, opening db...');
|
||
|
||
// 用户在设置里改过 dataDir、之后那块盘符断电 / 被拔 / 改权限了，
|
||
// openDb 的 mkdirSync 会抛 ENOENT —— 之前会一路冒到外层 catch
|
||
// 弹「启动失败」对话框。这里主动兜一次：本会话切到 defaultDataDir()
|
||
// （它本身已经做了 D 盘 → home 的二级降级），配置页也能打开。
|
||
//
|
||
// 注意：这里只动 sessionDataDir，不改 appConfig.dataDir，也不写盘 —
|
||
// 用户原本选的目录可能只是临时坏掉（外接硬盘拔了、临时网盘断连），
|
||
// 盘符恢复后下次启动会回到原配置；现在覆盖掉的话用户得手动重选。
|
||
if (!configMod.isDirUsable(appConfig.dataDir)) {
|
||
const fallback = configMod.defaultDataDir();
|
||
console.warn(`[main] dataDir ${appConfig.dataDir} 不可用，本会话切到 ${fallback}`);
|
||
sessionDataDir = fallback;
|
||
}
|
||
|
||
openDb();
|
||
try {
|
||
openFavDb();
|
||
devLog('[main] favorites db opened');
|
||
} catch (e) {
|
||
// favorites DB 损坏/不可用 —— 不让整个应用挂掉；收藏功能降级为不可用
|
||
console.error('[main] openFavDb failed (favorites disabled):', e.message, e.stack);
|
||
favDb = null;
|
||
}
|
||
devLog('[main] db opened');
|
||
|
||
registerIpc();
|
||
devLog('[main] ipc registered');
|
||
|
||
// 启动时把模块级 alwaysOnTop 同步到磁盘配置 —— 之前硬编码 true，
|
||
// 用户在主窗口点了图钉关闭置顶之后重启，配置里若有 ever-set 的
|
||
// false 状态也会被无视。应用层只暴露主窗口图钉一个入口，
|
||
// 所以这个字段大多停留在默认值；只是把"读 config、推模块变量"
|
||
// 的链路补上，避免和磁盘分叉。
|
||
// 必须在 createMainWindow 之前调用：模块级 alwaysOnTop 默认 true，
|
||
// 窗口构造时会读它，晚了就要先建后改（多一次 setAlwaysOnTop 调用）。
|
||
applyAlwaysOnTop(appConfig.alwaysOnTop);
|
||
|
||
createMainWindow(); // 内部已经挂好自适应轮询的 show/hide 监听
|
||
devLog('[main] window created');
|
||
|
||
// 启动时窗口默认隐藏 —— 靠托盘图标唤出。createFramelessWindow 已经
|
||
// 用 show:false 创建，这里不再触发 ready-to-show 弹窗，否则每次开机
|
||
// 都会抢焦点，和"剪贴板工具"的预期行为不一致。
|
||
//
|
||
// 不在此时广播主题：渲染窗口还没起来、没人订阅，setImmediate 这条只
|
||
// 是对着空 Set 发了一次消息；初始状态由 theme:get 主动拉。
|
||
|
||
buildTray();
|
||
devLog('[main] tray built');
|
||
|
||
// 全局快捷键必须在 whenReady 之后注册。被占用时不致命：
|
||
// 托盘唤出仍然可用，只是少了键盘入口（applyHotkey 内部有日志）。
|
||
applyHotkey();
|
||
|
||
try {
|
||
app.setLoginItemSettings({ openAtLogin: appConfig.autoLaunch });
|
||
} catch (e) { console.error('[main] setLoginItem failed:', e.message); }
|
||
|
||
// 先采样当前剪贴板作为"上次状态"，再开 poll。否则第一个 tick
|
||
// 就会把当前剪贴板里的内容当成"新内容"再入一次库。
|
||
initializeClipboardState();
|
||
startPolling();
|
||
devLog(`[main] ready, polling every ${POLL_MS}ms; db = ${getDbPath()}`);
|
||
} catch (e) {
|
||
console.error('[main] startup FAILED:', e.message, e.stack);
|
||
// ENOENT/EACCES/EPERM：数据目录出问题最常见的三种 —— 引导用户去设置里改。
|
||
const code = e && e.code;
|
||
const hint = (code === 'ENOENT' || code === 'EACCES' || code === 'EPERM')
|
||
? '\n\n可能是数据目录不可用（盘符缺失、权限不足等）。\n请到「设置 → 通用 → 数据保存位置」换一个位置，或检查该盘符/文件夹是否可访问。'
|
||
: '';
|
||
dialog.showErrorBox(APP_NAME, '启动失败：' + e.message + hint);
|
||
}
|
||
});
|
||
|
||
app.on('window-all-closed', () => {
|
||
// 不退出，靠托盘
|
||
});
|
||
|
||
app.on('will-quit', () => {
|
||
stopPolling();
|
||
// 退出时释放全局快捷键。进程正常退出时系统本来也会回收，但崩溃窗口
|
||
// 里残留注册会影响下次启动抢占同名组合键 —— 显式清掉最干净。
|
||
try { globalShortcut.unregisterAll(); } catch (_) {}
|
||
if (db) db.close();
|
||
if (favDb) favorites.close(favDb);
|
||
});
|
||
} |