egroupware/api/js/webodf/collab/EditorSession.js

660 lines
26 KiB
JavaScript
Raw Normal View History

/**
* Copyright (C) 2013 KO GmbH <copyright@kogmbh.com>
*
* @licstart
* This file is part of WebODF.
*
* WebODF is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License (GNU AGPL)
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* WebODF is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with WebODF. If not, see <http://www.gnu.org/licenses/>.
* @licend
*
* @source: http://www.webodf.org/
* @source: https://github.com/kogmbh/WebODF/
*/
/*global runtime, define, document, core, odf, gui, ops*/
define("webodf/editor/EditorSession", [
"dojo/text!resources/fonts/fonts.css"
], function (fontsCSS) { // fontsCSS is retrieved as a string, using dojo's text retrieval AMD plugin
"use strict";
runtime.loadClass("core.Async");
runtime.loadClass("core.DomUtils");
runtime.loadClass("odf.OdfUtils");
runtime.loadClass("ops.OdtDocument");
runtime.loadClass("ops.OdtStepsTranslator");
runtime.loadClass("ops.Session");
runtime.loadClass("odf.Namespaces");
runtime.loadClass("odf.OdfCanvas");
runtime.loadClass("odf.OdfUtils");
runtime.loadClass("gui.CaretManager");
runtime.loadClass("gui.Caret");
runtime.loadClass("gui.OdfFieldView");
runtime.loadClass("gui.SessionController");
runtime.loadClass("gui.SessionView");
runtime.loadClass("gui.HyperlinkTooltipView");
runtime.loadClass("gui.TrivialUndoManager");
runtime.loadClass("gui.SvgSelectionView");
runtime.loadClass("gui.SelectionViewManager");
runtime.loadClass("core.EventNotifier");
runtime.loadClass("gui.ShadowCursor");
runtime.loadClass("gui.CommonConstraints");
/**
* Instantiate a new editor session attached to an existing operation session
* @constructor
* @implements {core.EventSource}
* @param {!ops.Session} session
* @param {!string} localMemberId
* @param {{viewOptions:gui.SessionViewOptions,directParagraphStylingEnabled:boolean,annotationsEnabled:boolean}} config
*/
var EditorSession = function EditorSession(session, localMemberId, config) {
var self = this,
currentParagraphNode = null,
currentCommonStyleName = null,
currentStyleName = null,
caretManager,
selectionViewManager,
hyperlinkTooltipView,
odtDocument = session.getOdtDocument(),
textns = odf.Namespaces.textns,
fontStyles = document.createElement('style'),
formatting = odtDocument.getFormatting(),
domUtils = core.DomUtils,
odfUtils = odf.OdfUtils,
odfFieldView,
eventNotifier = new core.EventNotifier([
EditorSession.signalMemberAdded,
EditorSession.signalMemberUpdated,
EditorSession.signalMemberRemoved,
EditorSession.signalCursorAdded,
EditorSession.signalCursorMoved,
EditorSession.signalCursorRemoved,
EditorSession.signalParagraphChanged,
EditorSession.signalCommonStyleCreated,
EditorSession.signalCommonStyleDeleted,
EditorSession.signalParagraphStyleModified,
EditorSession.signalUndoStackChanged]),
shadowCursor = new gui.ShadowCursor(odtDocument),
sessionConstraints,
/**@const*/
NEXT = core.StepDirection.NEXT;
/**
* @return {Array.<!string>}
*/
function getAvailableFonts() {
var availableFonts, regex, matches;
availableFonts = {};
/*jslint regexp: true*/
regex = /font-family *: *(?:\'([^']*)\'|\"([^"]*)\")/gm;
/*jslint regexp: false*/
matches = regex.exec(fontsCSS);
while (matches) {
availableFonts[matches[1] || matches[2]] = 1;
matches = regex.exec(fontsCSS);
}
availableFonts = Object.keys(availableFonts);
return availableFonts;
}
function checkParagraphStyleName() {
var newStyleName,
newCommonStyleName;
newStyleName = currentParagraphNode.getAttributeNS(textns, 'style-name');
if (newStyleName !== currentStyleName) {
currentStyleName = newStyleName;
// check if common style is still the same
newCommonStyleName = formatting.getFirstCommonParentStyleNameOrSelf(newStyleName);
if (!newCommonStyleName) {
// Default style, empty-string name
currentCommonStyleName = newStyleName = currentStyleName = "";
self.emit(EditorSession.signalParagraphChanged, {
type: 'style',
node: currentParagraphNode,
styleName: currentCommonStyleName
});
return;
}
// a common style
if (newCommonStyleName !== currentCommonStyleName) {
currentCommonStyleName = newCommonStyleName;
self.emit(EditorSession.signalParagraphChanged, {
type: 'style',
node: currentParagraphNode,
styleName: currentCommonStyleName
});
}
}
}
/**
* Creates a NCName from the passed string
* @param {!string} name
* @return {!string}
*/
function createNCName(name) {
var letter,
result = "",
i;
// encode
for (i = 0; i < name.length; i += 1) {
letter = name[i];
// simple approach, can be improved to not skip other allowed chars
if (letter.match(/[a-zA-Z0-9.-_]/) !== null) {
result += letter;
} else {
result += "_" + letter.charCodeAt(0).toString(16) + "_";
}
}
// ensure leading char is from proper range
if (result.match(/^[a-zA-Z_]/) === null) {
result = "_" + result;
}
return result;
}
function uniqueParagraphStyleNCName(name) {
var result,
i = 0,
ncMemberId = createNCName(localMemberId),
ncName = createNCName(name);
// create default paragraph style
// localMemberId is used to avoid id conflicts with ids created by other members
result = ncName + "_" + ncMemberId;
// then loop until result is really unique
while (formatting.hasParagraphStyle(result)) {
result = ncName + "_" + i + "_" + ncMemberId;
i += 1;
}
return result;
}
function trackCursor(cursor) {
var node;
node = odfUtils.getParagraphElement(cursor.getNode());
if (!node) {
return;
}
currentParagraphNode = node;
checkParagraphStyleName();
}
function trackCurrentParagraph(info) {
var cursor = odtDocument.getCursor(localMemberId),
range = cursor && cursor.getSelectedRange(),
paragraphRange = odtDocument.getDOMDocument().createRange();
paragraphRange.selectNode(info.paragraphElement);
if ((range && domUtils.rangesIntersect(range, paragraphRange)) || info.paragraphElement === currentParagraphNode) {
self.emit(EditorSession.signalParagraphChanged, info);
checkParagraphStyleName();
}
paragraphRange.detach();
}
function onMemberAdded(member) {
self.emit(EditorSession.signalMemberAdded, member.getMemberId());
}
function onMemberUpdated(member) {
self.emit(EditorSession.signalMemberUpdated, member.getMemberId());
}
function onMemberRemoved(memberId) {
self.emit(EditorSession.signalMemberRemoved, memberId);
}
function onCursorAdded(cursor) {
self.emit(EditorSession.signalCursorAdded, cursor.getMemberId());
trackCursor(cursor);
}
function onCursorRemoved(memberId) {
self.emit(EditorSession.signalCursorRemoved, memberId);
}
function onCursorMoved(cursor) {
// Emit 'cursorMoved' only when *I* am moving the cursor, not the other users
if (cursor.getMemberId() === localMemberId) {
self.emit(EditorSession.signalCursorMoved, cursor);
trackCursor(cursor);
}
}
function onStyleCreated(newStyleName) {
self.emit(EditorSession.signalCommonStyleCreated, newStyleName);
}
function onStyleDeleted(styleName) {
self.emit(EditorSession.signalCommonStyleDeleted, styleName);
}
function onParagraphStyleModified(styleName) {
self.emit(EditorSession.signalParagraphStyleModified, styleName);
}
/**
* Call all subscribers for the given event with the specified argument
* @param {!string} eventid
* @param {Object} args
*/
this.emit = function (eventid, args) {
eventNotifier.emit(eventid, args);
};
/**
* Subscribe to a given event with a callback
* @param {!string} eventid
* @param {!Function} cb
*/
this.subscribe = function (eventid, cb) {
eventNotifier.subscribe(eventid, cb);
};
/**
* @param {!string} eventid
* @param {!Function} cb
* @return {undefined}
*/
this.unsubscribe = function (eventid, cb) {
eventNotifier.unsubscribe(eventid, cb);
};
this.getCursorPosition = function () {
return odtDocument.getCursorPosition(localMemberId);
};
this.getCursorSelection = function () {
return odtDocument.getCursorSelection(localMemberId);
};
this.getOdfCanvas = function () {
return odtDocument.getOdfCanvas();
};
this.getCurrentParagraph = function () {
return currentParagraphNode;
};
this.getAvailableParagraphStyles = function () {
return formatting.getAvailableParagraphStyles();
};
this.getCurrentParagraphStyle = function () {
return currentCommonStyleName;
};
/**
* Applies the paragraph style with the given
* style name to all the paragraphs within
* the cursor selection.
* @param {!string} styleName
* @return {undefined}
*/
this.setCurrentParagraphStyle = function (styleName) {
var range = odtDocument.getCursor(localMemberId).getSelectedRange(),
paragraphs = odfUtils.getParagraphElements(range),
opQueue = [];
paragraphs.forEach(function (paragraph) {
var paragraphStartPoint = odtDocument.convertDomPointToCursorStep(paragraph, 0, NEXT),
paragraphStyleName = paragraph.getAttributeNS(odf.Namespaces.textns, "style-name"),
opSetParagraphStyle;
if (paragraphStyleName !== styleName) {
opSetParagraphStyle = new ops.OpSetParagraphStyle();
opSetParagraphStyle.init({
memberid: localMemberId,
styleName: styleName,
position: paragraphStartPoint
});
opQueue.push(opSetParagraphStyle);
}
});
if (opQueue.length > 0) {
session.enqueue(opQueue);
}
};
this.insertTable = function (initialRows, initialColumns, tableStyleName, tableColumnStyleName, tableCellStyleMatrix) {
var op = new ops.OpInsertTable();
op.init({
memberid: localMemberId,
position: self.getCursorPosition(),
initialRows: initialRows,
initialColumns: initialColumns,
tableStyleName: tableStyleName,
tableColumnStyleName: tableColumnStyleName,
tableCellStyleMatrix: tableCellStyleMatrix
});
session.enqueue([op]);
};
/**
* Takes a style name and returns the corresponding paragraph style
* element. If the style name is an empty string, the default style
* is returned.
* @param {!string} styleName
* @return {?Element}
*/
function getParagraphStyleElement(styleName) {
return (styleName === "")
? formatting.getDefaultStyleElement('paragraph')
: formatting.getStyleElement(styleName, 'paragraph');
}
this.getParagraphStyleElement = getParagraphStyleElement;
/**
* Returns if the style is used anywhere in the document
* @param {!Element} styleElement
* @return {boolean}
*/
this.isStyleUsed = function (styleElement) {
return formatting.isStyleUsed(styleElement);
};
/**
* Returns the attributes of a given paragraph style name
* (with inheritance). If the name is an empty string,
* the attributes of the default style are returned.
* @param {!string} styleName
* @return {?odf.Formatting.StyleData}
*/
this.getParagraphStyleAttributes = function (styleName) {
var styleNode = getParagraphStyleElement(styleName),
includeSystemDefault = styleName === "";
if (styleNode) {
return formatting.getInheritedStyleAttributes(styleNode, includeSystemDefault);
}
return null;
};
/**
* Creates and enqueues a paragraph-style cloning operation.
* Returns the created id for the new style.
* @param {!string} styleName id of the style to update
* @param {!{paragraphProperties,textProperties}} setProperties properties which are set
* @param {!{paragraphPropertyNames,textPropertyNames}=} removedProperties properties which are removed
* @return {undefined}
*/
this.updateParagraphStyle = function (styleName, setProperties, removedProperties) {
var op;
op = new ops.OpUpdateParagraphStyle();
op.init({
memberid: localMemberId,
styleName: styleName,
setProperties: setProperties,
removedProperties: (!removedProperties) ? {} : removedProperties
});
session.enqueue([op]);
};
/**
* Creates and enqueues a paragraph-style cloning operation.
* Returns the created id for the new style.
* @param {!string} styleName id of the style to clone
* @param {!string} newStyleDisplayName display name of the new style
* @return {!string}
*/
this.cloneParagraphStyle = function (styleName, newStyleDisplayName) {
var newStyleName = uniqueParagraphStyleNCName(newStyleDisplayName),
styleNode = getParagraphStyleElement(styleName),
op, setProperties, attributes, i;
setProperties = formatting.getStyleAttributes(styleNode);
// copy any attributes directly on the style
attributes = styleNode.attributes;
for (i = 0; i < attributes.length; i += 1) {
// skip...
// * style:display-name -> not copied, set to new string below
// * style:name -> not copied, set from op by styleName property
// * style:family -> "paragraph" always, set by op
if (!/^(style:display-name|style:name|style:family)/.test(attributes[i].name)) {
setProperties[attributes[i].name] = attributes[i].value;
}
}
setProperties['style:display-name'] = newStyleDisplayName;
op = new ops.OpAddStyle();
op.init({
memberid: localMemberId,
styleName: newStyleName,
styleFamily: 'paragraph',
setProperties: setProperties
});
session.enqueue([op]);
return newStyleName;
};
this.deleteStyle = function (styleName) {
var op;
op = new ops.OpRemoveStyle();
op.init({
memberid: localMemberId,
styleName: styleName,
styleFamily: 'paragraph'
});
session.enqueue([op]);
};
/**
* Returns an array of the declared fonts in the ODF document,
* with 'duplicates' like Arial1, Arial2, etc removed. The alphabetically
* first font name for any given family is kept.
* The elements of the array are objects containing the font's name and
* the family.
* @return {Array.<!Object>}
*/
this.getDeclaredFonts = function () {
var fontMap = formatting.getFontMap(),
usedFamilies = [],
array = [],
sortedNames,
key,
value,
i;
// Sort all the keys in the font map alphabetically
sortedNames = Object.keys(fontMap);
sortedNames.sort();
for (i = 0; i < sortedNames.length; i += 1) {
key = sortedNames[i];
value = fontMap[key];
// Use the font declaration only if the family is not already used.
// Therefore we are able to discard the alphabetic successors of the first
// font name.
if (usedFamilies.indexOf(value) === -1) {
array.push({
name: key,
family: value
});
if (value) {
usedFamilies.push(value);
}
}
}
return array;
};
this.getSelectedHyperlinks = function () {
var cursor = odtDocument.getCursor(localMemberId);
// no own cursor yet/currently added?
if (!cursor) {
return [];
}
return odfUtils.getHyperlinkElements(cursor.getSelectedRange());
};
this.getSelectedRange = function () {
var cursor = odtDocument.getCursor(localMemberId);
return cursor && cursor.getSelectedRange();
};
function undoStackModified(e) {
self.emit(EditorSession.signalUndoStackChanged, e);
}
this.undo = function () {
self.sessionController.undo();
};
this.redo = function () {
self.sessionController.redo();
};
/**
* @param {!string} memberId
* @return {?ops.Member}
*/
this.getMember = function (memberId) {
return odtDocument.getMember(memberId);
};
/**
* @param {!function(!Object=)} callback passing an error object in case of error
* @return {undefined}
*/
function destroy(callback) {
var head = document.getElementsByTagName('head')[0],
eventManager = self.sessionController.getEventManager();
head.removeChild(fontStyles);
odtDocument.unsubscribe(ops.Document.signalMemberAdded, onMemberAdded);
odtDocument.unsubscribe(ops.Document.signalMemberUpdated, onMemberUpdated);
odtDocument.unsubscribe(ops.Document.signalMemberRemoved, onMemberRemoved);
odtDocument.unsubscribe(ops.Document.signalCursorAdded, onCursorAdded);
odtDocument.unsubscribe(ops.Document.signalCursorRemoved, onCursorRemoved);
odtDocument.unsubscribe(ops.Document.signalCursorMoved, onCursorMoved);
odtDocument.unsubscribe(ops.OdtDocument.signalCommonStyleCreated, onStyleCreated);
odtDocument.unsubscribe(ops.OdtDocument.signalCommonStyleDeleted, onStyleDeleted);
odtDocument.unsubscribe(ops.OdtDocument.signalParagraphStyleModified, onParagraphStyleModified);
odtDocument.unsubscribe(ops.OdtDocument.signalParagraphChanged, trackCurrentParagraph);
odtDocument.unsubscribe(ops.OdtDocument.signalUndoStackChanged, undoStackModified);
eventManager.unsubscribe("mousemove", hyperlinkTooltipView.showTooltip);
eventManager.unsubscribe("mouseout", hyperlinkTooltipView.hideTooltip);
delete self.sessionView;
delete self.sessionController;
callback();
}
/**
* @param {!function(!Error=)} callback passing an error object in case of error
* @return {undefined}
*/
this.destroy = function(callback) {
var cleanup = [
self.sessionView.destroy,
caretManager.destroy,
selectionViewManager.destroy,
self.sessionController.destroy,
hyperlinkTooltipView.destroy,
odfFieldView.destroy,
destroy
];
core.Async.destroyAll(cleanup, callback);
};
function init() {
var head = document.getElementsByTagName('head')[0],
odfCanvas = session.getOdtDocument().getOdfCanvas(),
eventManager;
// TODO: fonts.css should be rather done by odfCanvas, or?
fontStyles.type = 'text/css';
fontStyles.media = 'screen, print, handheld, projection';
fontStyles.appendChild(document.createTextNode(fontsCSS));
head.appendChild(fontStyles);
odfFieldView = new gui.OdfFieldView(odfCanvas);
odfFieldView.showFieldHighlight();
self.sessionController = new gui.SessionController(session, localMemberId, shadowCursor, {
annotationsEnabled: config.annotationsEnabled,
directTextStylingEnabled: config.directTextStylingEnabled,
directParagraphStylingEnabled: config.directParagraphStylingEnabled
});
sessionConstraints = self.sessionController.getSessionConstraints();
eventManager = self.sessionController.getEventManager();
hyperlinkTooltipView = new gui.HyperlinkTooltipView(odfCanvas,
self.sessionController.getHyperlinkClickHandler().getModifier);
eventManager.subscribe("mousemove", hyperlinkTooltipView.showTooltip);
eventManager.subscribe("mouseout", hyperlinkTooltipView.hideTooltip);
caretManager = new gui.CaretManager(self.sessionController, odfCanvas.getViewport());
selectionViewManager = new gui.SelectionViewManager(gui.SvgSelectionView);
self.sessionView = new gui.SessionView(config.viewOptions, localMemberId, session, sessionConstraints, caretManager, selectionViewManager);
self.availableFonts = getAvailableFonts();
selectionViewManager.registerCursor(shadowCursor, true);
// Session Constraints can be applied once the controllers are instantiated.
if (config.reviewModeEnabled) {
// Disallow deleting other authors' annotations.
sessionConstraints.setState(gui.CommonConstraints.EDIT.ANNOTATIONS.ONLY_DELETE_OWN, true);
sessionConstraints.setState(gui.CommonConstraints.EDIT.REVIEW_MODE, true);
}
// Custom signals, that make sense in the Editor context. We do not want to expose webodf's ops signals to random bits of the editor UI.
odtDocument.subscribe(ops.Document.signalMemberAdded, onMemberAdded);
odtDocument.subscribe(ops.Document.signalMemberUpdated, onMemberUpdated);
odtDocument.subscribe(ops.Document.signalMemberRemoved, onMemberRemoved);
odtDocument.subscribe(ops.Document.signalCursorAdded, onCursorAdded);
odtDocument.subscribe(ops.Document.signalCursorRemoved, onCursorRemoved);
odtDocument.subscribe(ops.Document.signalCursorMoved, onCursorMoved);
odtDocument.subscribe(ops.OdtDocument.signalCommonStyleCreated, onStyleCreated);
odtDocument.subscribe(ops.OdtDocument.signalCommonStyleDeleted, onStyleDeleted);
odtDocument.subscribe(ops.OdtDocument.signalParagraphStyleModified, onParagraphStyleModified);
odtDocument.subscribe(ops.OdtDocument.signalParagraphChanged, trackCurrentParagraph);
odtDocument.subscribe(ops.OdtDocument.signalUndoStackChanged, undoStackModified);
}
init();
};
/**@const*/EditorSession.signalMemberAdded = "memberAdded";
/**@const*/EditorSession.signalMemberUpdated = "memberUpdated";
/**@const*/EditorSession.signalMemberRemoved = "memberRemoved";
/**@const*/EditorSession.signalCursorAdded = "cursorAdded";
/**@const*/EditorSession.signalCursorRemoved = "cursorRemoved";
/**@const*/EditorSession.signalCursorMoved = "cursorMoved";
/**@const*/EditorSession.signalParagraphChanged = "paragraphChanged";
/**@const*/EditorSession.signalCommonStyleCreated = "styleCreated";
/**@const*/EditorSession.signalCommonStyleDeleted = "styleDeleted";
/**@const*/EditorSession.signalParagraphStyleModified = "paragraphStyleModified";
/**@const*/EditorSession.signalUndoStackChanged = "signalUndoStackChanged";
return EditorSession;
});