diff options
Diffstat (limited to 'infrastructure/ace/www/undomodule.js')
| -rw-r--r-- | infrastructure/ace/www/undomodule.js | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/infrastructure/ace/www/undomodule.js b/infrastructure/ace/www/undomodule.js new file mode 100644 index 0000000..b8a56f9 --- /dev/null +++ b/infrastructure/ace/www/undomodule.js @@ -0,0 +1,258 @@ +/** + * Copyright 2009 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS-IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +undoModule = (function() { + var stack = (function() { + var stackElements = []; + // two types of stackElements: + // 1) { elementType: UNDOABLE_EVENT, eventType: "anything", [backset: <changeset>,] + // [selStart: <char number>, selEnd: <char number>, selFocusAtStart: <boolean>] } + // 2) { elementType: EXTERNAL_CHANGE, changeset: <changeset> } + // invariant: no two consecutive EXTERNAL_CHANGEs + var numUndoableEvents = 0; + + var UNDOABLE_EVENT = "undoableEvent"; + var EXTERNAL_CHANGE = "externalChange"; + + function clearStack() { + stackElements.length = 0; + stackElements.push({ elementType: UNDOABLE_EVENT, eventType: "bottom" }); + numUndoableEvents = 1; + } + clearStack(); + + function pushEvent(event) { + var e = extend({}, event); + e.elementType = UNDOABLE_EVENT; + stackElements.push(e); + numUndoableEvents++; + //dmesg("pushEvent backset: "+event.backset); + } + + function pushExternalChange(cs) { + var idx = stackElements.length-1; + if (stackElements[idx].elementType == EXTERNAL_CHANGE) { + stackElements[idx].changeset = Changeset.compose(stackElements[idx].changeset, cs, getAPool()); + } + else { + stackElements.push({elementType: EXTERNAL_CHANGE, changeset: cs}); + } + } + + function _exposeEvent(nthFromTop) { + // precond: 0 <= nthFromTop < numUndoableEvents + var targetIndex = stackElements.length - 1 - nthFromTop; + var idx = stackElements.length - 1; + while (idx > targetIndex || stackElements[idx].elementType == EXTERNAL_CHANGE) { + if (stackElements[idx].elementType == EXTERNAL_CHANGE) { + var ex = stackElements[idx]; + var un = stackElements[idx-1]; + if (un.backset) { + var excs = ex.changeset; + var unbs = un.backset; + un.backset = Changeset.follow(excs, un.backset, false, getAPool()); + ex.changeset = Changeset.follow(unbs, ex.changeset, true, getAPool()); + if ((typeof un.selStart) == "number") { + var newSel = Changeset.characterRangeFollow(excs, un.selStart, un.selEnd); + un.selStart = newSel[0]; + un.selEnd = newSel[1]; + if (un.selStart == un.selEnd) { + un.selFocusAtStart = false; + } + } + } + stackElements[idx-1] = ex; + stackElements[idx] = un; + if (idx >= 2 && stackElements[idx-2].elementType == EXTERNAL_CHANGE) { + ex.changeset = Changeset.compose(stackElements[idx-2].changeset, + ex.changeset, getAPool()); + stackElements.splice(idx-2, 1); + idx--; + } + } + else { + idx--; + } + } + } + + function getNthFromTop(n) { + // precond: 0 <= n < numEvents() + _exposeEvent(n); + return stackElements[stackElements.length - 1 - n]; + } + + function numEvents() { + return numUndoableEvents; + } + + function popEvent() { + // precond: numEvents() > 0 + _exposeEvent(0); + numUndoableEvents--; + return stackElements.pop(); + } + + return {numEvents:numEvents, popEvent:popEvent, pushEvent: pushEvent, + pushExternalChange: pushExternalChange, clearStack: clearStack, + getNthFromTop:getNthFromTop}; + })(); + + // invariant: stack always has at least one undoable event + + var undoPtr = 0; // zero-index from top of stack, 0 == top + + function clearHistory() { + stack.clearStack(); + undoPtr = 0; + } + + function _charOccurrences(str, c) { + var i = 0; + var count = 0; + while (i >= 0 && i < str.length) { + i = str.indexOf(c, i); + if (i >= 0) { + count++; + i++; + } + } + return count; + } + + function _opcodeOccurrences(cs, opcode) { + return _charOccurrences(Changeset.unpack(cs).ops, opcode); + } + + function _mergeChangesets(cs1, cs2) { + if (! cs1) return cs2; + if (! cs2) return cs1; + + // Rough heuristic for whether changesets should be considered one action: + // each does exactly one insertion, no dels, and the composition does also; or + // each does exactly one deletion, no ins, and the composition does also. + // A little weird in that it won't merge "make bold" with "insert char" + // but will merge "make bold and insert char" with "insert char", + // though that isn't expected to come up. + var plusCount1 = _opcodeOccurrences(cs1, '+'); + var plusCount2 = _opcodeOccurrences(cs2, '+'); + var minusCount1 = _opcodeOccurrences(cs1, '-'); + var minusCount2 = _opcodeOccurrences(cs2, '-'); + if (plusCount1 == 1 && plusCount2 == 1 && minusCount1 == 0 && minusCount2 == 0) { + var merge = Changeset.compose(cs1, cs2, getAPool()); + var plusCount3 = _opcodeOccurrences(merge, '+'); + var minusCount3 = _opcodeOccurrences(merge, '-'); + if (plusCount3 == 1 && minusCount3 == 0) { + return merge; + } + } + else if (plusCount1 == 0 && plusCount2 == 0 && minusCount1 == 1 && minusCount2 == 1) { + var merge = Changeset.compose(cs1, cs2, getAPool()); + var plusCount3 = _opcodeOccurrences(merge, '+'); + var minusCount3 = _opcodeOccurrences(merge, '-'); + if (plusCount3 == 0 && minusCount3 == 1) { + return merge; + } + } + return null; + } + + function reportEvent(event) { + var topEvent = stack.getNthFromTop(0); + + function applySelectionToTop() { + if ((typeof event.selStart) == "number") { + topEvent.selStart = event.selStart; + topEvent.selEnd = event.selEnd; + topEvent.selFocusAtStart = event.selFocusAtStart; + } + } + + if ((! event.backset) || Changeset.isIdentity(event.backset)) { + applySelectionToTop(); + } + else { + var merged = false; + if (topEvent.eventType == event.eventType) { + var merge = _mergeChangesets(event.backset, topEvent.backset); + if (merge) { + topEvent.backset = merge; + //dmesg("reportEvent merge: "+merge); + applySelectionToTop(); + merged = true; + } + } + if (! merged) { + stack.pushEvent(event); + } + undoPtr = 0; + } + + } + + function reportExternalChange(changeset) { + if (changeset && ! Changeset.isIdentity(changeset)) { + stack.pushExternalChange(changeset); + } + } + + function _getSelectionInfo(event) { + if ((typeof event.selStart) != "number") { + return null; + } + else { + return {selStart: event.selStart, selEnd: event.selEnd, + selFocusAtStart: event.selFocusAtStart}; + } + } + + // For "undo" and "redo", the change event must be returned + // by eventFunc and NOT reported through the normal mechanism. + // "eventFunc" should take a changeset and an optional selection info object, + // or can be called with no arguments to mean that no undo is possible. + // "eventFunc" will be called exactly once. + + function performUndo(eventFunc) { + if (undoPtr < stack.numEvents()-1) { + var backsetEvent = stack.getNthFromTop(undoPtr); + var selectionEvent = stack.getNthFromTop(undoPtr+1); + var undoEvent = eventFunc(backsetEvent.backset, _getSelectionInfo(selectionEvent)); + stack.pushEvent(undoEvent); + undoPtr += 2; + } + else eventFunc(); + } + + function performRedo(eventFunc) { + if (undoPtr >= 2) { + var backsetEvent = stack.getNthFromTop(0); + var selectionEvent = stack.getNthFromTop(1); + eventFunc(backsetEvent.backset, _getSelectionInfo(selectionEvent)); + stack.popEvent(); + undoPtr -= 2; + } + else eventFunc(); + } + + function getAPool() { + return undoModule.apool; + } + + return {clearHistory:clearHistory, reportEvent:reportEvent, reportExternalChange:reportExternalChange, + performUndo:performUndo, performRedo:performRedo, enabled: true, + apool: null}; // apool is filled in by caller +})();
\ No newline at end of file |