2018-03-26 01:41:29 +08:00
|
|
|
import treeService from './tree.js';
|
2019-05-11 03:43:40 +08:00
|
|
|
import TabContext from './tab_context.js';
|
2018-03-25 23:09:17 +08:00
|
|
|
import server from './server.js';
|
2019-08-27 02:21:43 +08:00
|
|
|
import ws from "./ws.js";
|
2018-03-26 11:25:17 +08:00
|
|
|
import treeCache from "./tree_cache.js";
|
|
|
|
import NoteFull from "../entities/note_full.js";
|
2019-05-09 02:14:41 +08:00
|
|
|
import treeUtils from "./tree_utils.js";
|
2019-05-12 01:44:58 +08:00
|
|
|
import tabRow from "./tab_row.js";
|
2020-01-12 18:15:23 +08:00
|
|
|
import appContext from "./app_context.js";
|
2019-05-05 16:59:34 +08:00
|
|
|
|
2019-05-09 01:55:24 +08:00
|
|
|
const $tabContentsContainer = $("#note-tab-container");
|
2019-05-04 03:50:14 +08:00
|
|
|
const $savedIndicator = $(".saved-indicator");
|
2018-03-25 23:09:17 +08:00
|
|
|
|
2019-01-02 02:32:34 +08:00
|
|
|
let detailLoadedListeners = [];
|
|
|
|
|
2018-03-25 23:09:17 +08:00
|
|
|
async function reload() {
|
|
|
|
// no saving here
|
2017-11-05 05:54:27 +08:00
|
|
|
|
2020-01-12 19:30:30 +08:00
|
|
|
await loadNoteDetail(appContext.getActiveTabNotePath());
|
2018-03-25 23:09:17 +08:00
|
|
|
}
|
2017-11-05 05:54:27 +08:00
|
|
|
|
2020-01-12 19:30:30 +08:00
|
|
|
async function reloadNote(tabContext) {
|
|
|
|
const note = await loadNote(tabContext.note.noteId);
|
2019-05-06 02:45:07 +08:00
|
|
|
|
2020-01-12 19:30:30 +08:00
|
|
|
await loadNoteDetailToContext(tabContext, note, tabContext.notePath);
|
2019-05-21 04:25:04 +08:00
|
|
|
}
|
|
|
|
|
2019-11-25 04:40:50 +08:00
|
|
|
async function openInTab(notePath, activate) {
|
|
|
|
await loadNoteDetail(notePath, { newTab: true, activate });
|
2019-05-03 04:24:43 +08:00
|
|
|
}
|
2019-05-02 05:06:18 +08:00
|
|
|
|
2019-05-09 02:14:41 +08:00
|
|
|
async function switchToNote(notePath) {
|
|
|
|
await saveNotesIfChanged();
|
2017-11-05 05:54:27 +08:00
|
|
|
|
2019-05-09 02:14:41 +08:00
|
|
|
await loadNoteDetail(notePath);
|
2019-05-12 01:27:33 +08:00
|
|
|
|
2020-01-12 19:48:17 +08:00
|
|
|
appContext.openTabsChanged();
|
2018-03-25 23:09:17 +08:00
|
|
|
}
|
2017-11-05 05:54:27 +08:00
|
|
|
|
2018-09-03 22:05:28 +08:00
|
|
|
function onNoteChange(func) {
|
2020-01-12 19:37:44 +08:00
|
|
|
return appContext.getActiveTabContext().getComponent().onNoteChange(func);
|
2018-09-03 22:05:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-02 04:19:29 +08:00
|
|
|
async function saveNotesIfChanged() {
|
2020-01-12 19:30:30 +08:00
|
|
|
for (const ctx of appContext.getTabContexts()) {
|
2019-05-02 04:19:29 +08:00
|
|
|
await ctx.saveNoteIfChanged();
|
2018-12-28 03:22:33 +08:00
|
|
|
}
|
|
|
|
|
2019-05-02 04:19:29 +08:00
|
|
|
// make sure indicator is visible in a case there was some race condition.
|
|
|
|
$savedIndicator.fadeIn();
|
|
|
|
}
|
2017-11-05 05:54:27 +08:00
|
|
|
|
2019-05-19 15:13:13 +08:00
|
|
|
function getActiveEditor() {
|
2020-01-12 19:37:44 +08:00
|
|
|
const activeTabContext = appContext.getActiveTabContext();
|
2019-05-19 15:13:13 +08:00
|
|
|
|
|
|
|
if (activeTabContext && activeTabContext.note && activeTabContext.note.type === 'text') {
|
|
|
|
return activeTabContext.getComponent().getEditor();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-07 17:15:55 +08:00
|
|
|
async function activateOrOpenNote(noteId) {
|
2020-01-12 19:37:44 +08:00
|
|
|
for (const tabContext of appContext.getTabContexts()) {
|
2019-07-07 17:15:55 +08:00
|
|
|
if (tabContext.note && tabContext.note.noteId === noteId) {
|
|
|
|
await tabContext.activate();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if no tab with this note has been found we'll create new tab
|
|
|
|
|
|
|
|
await loadNoteDetail(noteId, {
|
|
|
|
newTab: true,
|
|
|
|
activate: true
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-05-06 02:45:07 +08:00
|
|
|
/**
|
2019-05-09 01:55:24 +08:00
|
|
|
* @param {TabContext} ctx
|
2019-05-06 02:45:07 +08:00
|
|
|
* @param {NoteFull} note
|
2019-09-05 04:13:22 +08:00
|
|
|
* @param {string} notePath
|
2019-05-06 02:45:07 +08:00
|
|
|
*/
|
2019-05-09 02:14:41 +08:00
|
|
|
async function loadNoteDetailToContext(ctx, note, notePath) {
|
2019-08-27 01:49:19 +08:00
|
|
|
await ctx.setNote(note, notePath);
|
2018-11-01 02:08:31 +08:00
|
|
|
|
2020-01-12 19:48:17 +08:00
|
|
|
appContext.openTabsChanged();
|
2019-05-12 18:58:55 +08:00
|
|
|
|
2019-01-02 02:32:34 +08:00
|
|
|
fireDetailLoaded();
|
2018-04-09 10:38:52 +08:00
|
|
|
}
|
|
|
|
|
2019-05-12 18:58:55 +08:00
|
|
|
async function loadNoteDetail(origNotePath, options = {}) {
|
2019-05-11 03:43:40 +08:00
|
|
|
const newTab = !!options.newTab;
|
|
|
|
const activate = !!options.activate;
|
|
|
|
|
2020-01-08 02:48:26 +08:00
|
|
|
let notePath = await treeService.resolveNotePath(origNotePath);
|
2019-05-12 18:58:55 +08:00
|
|
|
|
|
|
|
if (!notePath) {
|
|
|
|
console.error(`Cannot resolve note path ${origNotePath}`);
|
2019-06-02 02:32:11 +08:00
|
|
|
|
|
|
|
// fallback to display something
|
2020-01-08 02:48:26 +08:00
|
|
|
notePath = 'root';
|
2019-05-12 18:58:55 +08:00
|
|
|
}
|
2019-05-12 03:27:27 +08:00
|
|
|
|
2019-05-09 02:14:41 +08:00
|
|
|
const noteId = treeUtils.getNoteIdFromNotePath(notePath);
|
2019-05-06 02:45:07 +08:00
|
|
|
const loadedNote = await loadNote(noteId);
|
2020-01-12 19:30:30 +08:00
|
|
|
const ctx = appContext.getTab(newTab, options.state);
|
2019-05-06 02:45:07 +08:00
|
|
|
|
|
|
|
// we will try to render the new note only if it's still the active one in the tree
|
|
|
|
// this is useful when user quickly switches notes (by e.g. holding down arrow) so that we don't
|
|
|
|
// try to render all those loaded notes one after each other. This only guarantees that correct note
|
|
|
|
// will be displayed independent of timing
|
2020-01-12 18:15:23 +08:00
|
|
|
const currentTreeNode = appContext.getMainNoteTree().getActiveNode();
|
2019-05-06 02:45:07 +08:00
|
|
|
if (!newTab && currentTreeNode && currentTreeNode.data.noteId !== loadedNote.noteId) {
|
|
|
|
return;
|
|
|
|
}
|
2019-09-04 04:01:45 +08:00
|
|
|
|
|
|
|
const loadPromise = loadNoteDetailToContext(ctx, loadedNote, notePath).then(() => {
|
|
|
|
if (activate) {
|
2020-01-13 06:03:55 +08:00
|
|
|
return appContext.activateTab(ctx);
|
2019-09-04 04:01:45 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
return Promise.resolve();
|
|
|
|
}
|
|
|
|
});
|
2019-05-06 02:45:07 +08:00
|
|
|
|
2019-09-04 04:01:45 +08:00
|
|
|
if (!options.async) {
|
|
|
|
await loadPromise;
|
2019-05-10 03:30:08 +08:00
|
|
|
}
|
2019-05-06 02:45:07 +08:00
|
|
|
}
|
|
|
|
|
2018-08-30 04:28:58 +08:00
|
|
|
async function loadNote(noteId) {
|
|
|
|
const row = await server.get('notes/' + noteId);
|
|
|
|
|
2019-10-26 15:51:08 +08:00
|
|
|
const noteShort = await treeCache.getNote(noteId);
|
|
|
|
|
|
|
|
return new NoteFull(treeCache, row, noteShort);
|
2018-08-30 04:28:58 +08:00
|
|
|
}
|
|
|
|
|
2019-05-21 03:50:01 +08:00
|
|
|
async function noteDeleted(noteId) {
|
2020-01-12 19:37:44 +08:00
|
|
|
for (const tc of appContext.getTabContexts()) {
|
2019-11-27 03:42:34 +08:00
|
|
|
// not removing active even if it contains deleted note since that one will move to another note (handled by deletion logic)
|
|
|
|
// and we would lose tab context state (e.g. sidebar visibility)
|
|
|
|
if (!tc.isActive() && tc.notePath && tc.notePath.split("/").includes(noteId)) {
|
2019-05-21 03:50:01 +08:00
|
|
|
await tabRow.removeTab(tc.$tab[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-07 16:50:05 +08:00
|
|
|
function focusOnTitle() {
|
2020-01-12 19:37:44 +08:00
|
|
|
appContext.getActiveTabContext().$noteTitle.trigger('focus');
|
2018-08-30 04:28:58 +08:00
|
|
|
}
|
|
|
|
|
2019-01-11 05:46:08 +08:00
|
|
|
function focusAndSelectTitle() {
|
2020-01-12 19:37:44 +08:00
|
|
|
appContext.getActiveTabContext()
|
2019-11-10 00:45:22 +08:00
|
|
|
.$noteTitle
|
|
|
|
.trigger('focus')
|
|
|
|
.trigger('select');
|
2019-01-11 05:46:08 +08:00
|
|
|
}
|
|
|
|
|
2019-01-02 02:32:34 +08:00
|
|
|
/**
|
|
|
|
* Since detail loading may take some time and user might just browse through the notes using UP-DOWN keys,
|
|
|
|
* we intentionally decouple activation of the note in the tree and full load of the note so just avaiting on
|
|
|
|
* fancytree's activate() won't wait for the full load.
|
|
|
|
*
|
|
|
|
* This causes an issue where in some cases you want to do some action after detail is loaded. For this reason
|
|
|
|
* we provide the listeners here which will be triggered after the detail is loaded and if the loaded note
|
|
|
|
* is the one registered in the listener.
|
|
|
|
*/
|
|
|
|
function addDetailLoadedListener(noteId, callback) {
|
|
|
|
detailLoadedListeners.push({ noteId, callback });
|
|
|
|
}
|
|
|
|
|
|
|
|
function fireDetailLoaded() {
|
|
|
|
for (const {noteId, callback} of detailLoadedListeners) {
|
2020-01-12 19:37:44 +08:00
|
|
|
if (noteId === appContext.getActiveTabNoteId()) {
|
2019-01-02 02:32:34 +08:00
|
|
|
callback();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// all the listeners are one time only
|
|
|
|
detailLoadedListeners = [];
|
|
|
|
}
|
|
|
|
|
2019-08-27 02:21:43 +08:00
|
|
|
ws.subscribeToOutsideSyncMessages(syncData => {
|
2019-06-01 18:14:09 +08:00
|
|
|
const noteIdsToRefresh = new Set();
|
|
|
|
|
|
|
|
syncData
|
|
|
|
.filter(sync => sync.entityName === 'notes')
|
|
|
|
.forEach(sync => noteIdsToRefresh.add(sync.entityId));
|
|
|
|
|
2019-08-07 04:39:27 +08:00
|
|
|
// we need to reload because of promoted attributes
|
2019-06-01 18:14:09 +08:00
|
|
|
syncData
|
|
|
|
.filter(sync => sync.entityName === 'attributes')
|
|
|
|
.forEach(sync => noteIdsToRefresh.add(sync.noteId));
|
|
|
|
|
|
|
|
for (const noteId of noteIdsToRefresh) {
|
2020-01-12 19:30:30 +08:00
|
|
|
appContext.refreshTabs(null, noteId);
|
2018-08-30 04:28:58 +08:00
|
|
|
}
|
2018-08-06 20:43:42 +08:00
|
|
|
});
|
|
|
|
|
2019-08-27 02:21:43 +08:00
|
|
|
ws.subscribeToAllSyncMessages(syncData => {
|
2020-01-12 19:37:44 +08:00
|
|
|
for (const tc of appContext.getTabContexts()) {
|
2019-09-04 03:31:39 +08:00
|
|
|
tc.eventReceived('syncData', syncData);
|
2019-08-07 04:39:27 +08:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2019-05-09 01:55:24 +08:00
|
|
|
$tabContentsContainer.on("dragover", e => e.preventDefault());
|
2019-02-27 04:37:15 +08:00
|
|
|
|
2019-05-09 01:55:24 +08:00
|
|
|
$tabContentsContainer.on("dragleave", e => e.preventDefault());
|
2019-02-27 04:37:15 +08:00
|
|
|
|
2019-08-21 03:40:47 +08:00
|
|
|
$tabContentsContainer.on("drop", async e => {
|
2020-01-12 19:37:44 +08:00
|
|
|
const activeNote = appContext.getActiveTabNote();
|
2019-05-22 02:24:40 +08:00
|
|
|
|
|
|
|
if (!activeNote) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-09-03 03:58:03 +08:00
|
|
|
const files = [...e.originalEvent.dataTransfer.files]; // chrome has issue that dataTransfer.files empties after async operation
|
|
|
|
|
2019-10-14 16:31:58 +08:00
|
|
|
const importService = await import("./import.js");
|
2019-09-03 03:58:03 +08:00
|
|
|
|
2019-10-14 16:31:58 +08:00
|
|
|
importService.uploadFiles(activeNote.noteId, files, {
|
2019-02-27 04:37:15 +08:00
|
|
|
safeImport: true,
|
|
|
|
shrinkImages: true,
|
|
|
|
textImportedAsText: true,
|
|
|
|
codeImportedAsCode: true,
|
|
|
|
explodeArchives: true
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2019-06-13 01:59:52 +08:00
|
|
|
function noteChanged() {
|
2020-01-12 19:37:44 +08:00
|
|
|
const activeTabContext = appContext.getActiveTabContext();
|
2019-06-13 01:59:52 +08:00
|
|
|
|
|
|
|
if (activeTabContext) {
|
|
|
|
activeTabContext.noteChanged();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-27 10:29:14 +08:00
|
|
|
// this makes sure that when user e.g. reloads the page or navigates away from the page, the note's content is saved
|
|
|
|
// this sends the request asynchronously and doesn't wait for result
|
2019-05-02 04:19:29 +08:00
|
|
|
$(window).on('beforeunload', () => { saveNotesIfChanged(); }); // don't convert to short form, handler doesn't like returned promise
|
2018-03-27 10:29:14 +08:00
|
|
|
|
2019-05-02 04:19:29 +08:00
|
|
|
setInterval(saveNotesIfChanged, 3000);
|
2018-03-25 23:09:17 +08:00
|
|
|
|
|
|
|
export default {
|
|
|
|
reload,
|
2019-05-03 04:24:43 +08:00
|
|
|
openInTab,
|
2018-03-25 23:09:17 +08:00
|
|
|
switchToNote,
|
|
|
|
loadNote,
|
2019-05-08 04:33:53 +08:00
|
|
|
loadNoteDetail,
|
2018-09-07 16:50:05 +08:00
|
|
|
focusOnTitle,
|
2019-01-11 05:46:08 +08:00
|
|
|
focusAndSelectTitle,
|
2019-05-02 04:19:29 +08:00
|
|
|
saveNotesIfChanged,
|
2019-01-02 02:32:34 +08:00
|
|
|
onNoteChange,
|
2019-05-05 04:44:25 +08:00
|
|
|
addDetailLoadedListener,
|
2019-05-19 15:13:13 +08:00
|
|
|
getActiveEditor,
|
2019-07-07 17:15:55 +08:00
|
|
|
activateOrOpenNote,
|
2019-05-21 04:25:04 +08:00
|
|
|
noteDeleted,
|
2019-08-15 16:04:03 +08:00
|
|
|
noteChanged,
|
2020-01-12 19:30:30 +08:00
|
|
|
reloadNote
|
2018-03-25 23:09:17 +08:00
|
|
|
};
|