closure 1.2.701 → 1.3.0

data/closure-library/closure/goog/editor/plugins/undoredo.js

@@ -1,1014 +0,0 @@
-// Copyright 2005 The Closure Library Authors. All Rights Reserved.
-//
-// 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.
-
-
-/**
- * @fileoverview Code for handling edit history (undo/redo).
- *
- */
-
-
-goog.provide('goog.editor.plugins.UndoRedo');
-
-goog.require('goog.debug.Logger');
-goog.require('goog.dom');
-goog.require('goog.dom.NodeOffset');
-goog.require('goog.dom.Range');
-goog.require('goog.editor.BrowserFeature');
-goog.require('goog.editor.Command');
-goog.require('goog.editor.Field.EventType');
-goog.require('goog.editor.Plugin');
-goog.require('goog.editor.plugins.UndoRedoManager');
-goog.require('goog.editor.plugins.UndoRedoState');
-goog.require('goog.events');
-goog.require('goog.events.EventHandler');
-
-
-
-/**
- * Encapsulates undo/redo logic using a custom undo stack (i.e. not browser
- * built-in). Browser built-in undo stacks are too flaky (e.g. IE's gets
- * clobbered on DOM modifications). Also, this allows interleaving non-editing
- * commands into the undo stack via the UndoRedoManager.
- *
- * @param {goog.editor.plugins.UndoRedoManager=} opt_manager An undo redo
- *    manager to be used by this plugin. If none is provided one is created.
- * @constructor
- * @extends {goog.editor.Plugin}
- */
-goog.editor.plugins.UndoRedo = function(opt_manager) {
-  goog.editor.Plugin.call(this);
-
-  this.setUndoRedoManager(opt_manager ||
-      new goog.editor.plugins.UndoRedoManager());
-
-  // Map of goog.editor.Field hashcode to goog.events.EventHandler
-  this.eventHandlers_ = {};
-
-  this.currentStates_ = {};
-
-  /**
-   * @type {?string}
-   * @private
-   */
-  this.initialFieldChange_ = null;
-
-  /**
-   * A copy of {@code goog.editor.plugins.UndoRedo.restoreState} bound to this,
-   * used by undo-redo state objects to restore the state of an editable field.
-   * @type {Function}
-   * @see goog.editor.plugins.UndoRedo#restoreState
-   * @private
-   */
-  this.boundRestoreState_ = goog.bind(this.restoreState, this);
-};
-goog.inherits(goog.editor.plugins.UndoRedo, goog.editor.Plugin);
-
-
-/**
- * The logger for this class.
- * @type {goog.debug.Logger}
- * @protected
- */
-goog.editor.plugins.UndoRedo.prototype.logger =
-    goog.debug.Logger.getLogger('goog.editor.plugins.UndoRedo');
-
-
-/**
- * The {@code UndoState_} whose change is in progress, null if an undo or redo
- * is not in progress.
- *
- * @type {goog.editor.plugins.UndoRedo.UndoState_?}
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.inProgressUndo_ = null;
-
-
-/**
- * The undo-redo stack manager used by this plugin.
- * @type {goog.editor.plugins.UndoRedoManager}
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.undoManager_;
-
-
-/**
- * The key for the event listener handling state change events from the
- * undo-redo manager.
- * @type {number}
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.managerStateChangeKey_;
-
-
-/**
- * Commands implemented by this plugin.
- * @enum {string}
- */
-goog.editor.plugins.UndoRedo.COMMAND = {
-  UNDO: '+undo',
-  REDO: '+redo'
-};
-
-
-/**
- * Inverse map of execCommand strings to
- * {@link goog.editor.plugins.UndoRedo.COMMAND} constants. Used to determine
- * whether a string corresponds to a command this plugin handles in O(1) time.
- * @type {Object}
- * @private
- */
-goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_ =
-    goog.object.transpose(goog.editor.plugins.UndoRedo.COMMAND);
-
-
-/**
- * Set the max undo stack depth (not the real memory usage).
- * @param {number} depth Depth of the stack.
- */
-goog.editor.plugins.UndoRedo.prototype.setMaxUndoDepth = function(depth) {
-  this.undoManager_.setMaxUndoDepth(depth);
-};
-
-
-/**
- * Set the undo-redo manager used by this plugin. Any state on a previous
- * undo-redo manager is lost.
- * @param {goog.editor.plugins.UndoRedoManager} manager The undo-redo manager.
- */
-goog.editor.plugins.UndoRedo.prototype.setUndoRedoManager = function(manager) {
-  if (this.managerStateChangeKey_) {
-    goog.events.unlistenByKey(this.managerStateChangeKey_);
-  }
-
-  this.undoManager_ = manager;
-  this.managerStateChangeKey_ = /** @type {number} */ (
-      goog.events.listen(this.undoManager_,
-          goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE,
-          this.dispatchCommandValueChange_,
-          false,
-          this));
-};
-
-
-/**
- * Whether the string corresponds to a command this plugin handles.
- * @param {string} command Command string to check.
- * @return {boolean} Whether the string corresponds to a command
- *     this plugin handles.
- */
-goog.editor.plugins.UndoRedo.prototype.isSupportedCommand = function(command) {
-  return command in goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_;
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.registerFieldObject = function(
-    fieldObject) {
-  this.fieldObject = fieldObject;
-};
-
-
-/**
- * Unregisters and disables the fieldObject with this plugin. Thie does *not*
- * clobber the undo stack for the fieldObject though.
- * TODO(user): For the multifield version, we really should add a way to
- * ignore undo actions on field's that have been made uneditable.
- * This is probably as simple as skipping over entries in the undo stack
- * that have a hashcode of an uneditable field.
- * @param {goog.editor.Field} fieldObject The field to register with the plugin.
- */
-goog.editor.plugins.UndoRedo.prototype.unregisterFieldObject = function(
-    fieldObject) {
-  this.disable(fieldObject);
-  this.fieldObject = null;
-};
-
-
-/**
- * This is so subclasses can deal with multifield undo-redo.
- * @return {goog.editor.Field} The active field object for this field. This is
- *     the one registered field object for the single-plugin case and the
- *     focused field for the multi-field plugin case.
- */
-goog.editor.plugins.UndoRedo.prototype.getCurrentFieldObject = function() {
-  return this.fieldObject;
-};
-
-
-/**
- * This is so subclasses can deal with multifield undo-redo.
- * @param {string} fieldHashCode The Field's hashcode.
- * @return {goog.editor.Field} The field object with the hashcode.
- */
-goog.editor.plugins.UndoRedo.prototype.getFieldObject = function(
-    fieldHashCode) {
-  // With single field undoredo, there's only one Field involved.
-  return this.fieldObject;
-};
-
-
-/**
- * This is so subclasses can deal with multifield undo-redo.
- * @return {goog.editor.Field} Target for COMMAND_VALUE_CHANGE events.
- */
-goog.editor.plugins.UndoRedo.prototype.getCurrentEventTarget = function() {
-  return this.fieldObject;
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.enable = function(fieldObject) {
-  if (this.isEnabled(fieldObject)) {
-    return;
-  }
-
-  // Don't want pending delayed changes from when undo-redo was disabled
-  // firing after undo-redo is enabled since they might cause undo-redo stack
-  // updates.
-  fieldObject.clearDelayedChange();
-
-  var eventHandler = new goog.events.EventHandler(this);
-
-  // TODO(user): From ojan during a code review:
-  // The beforechange handler is meant to be there so you can grab the cursor
-  // position *before* the change is made as that's where you want the cursor to
-  // be after an undo.
-  //
-  // It kinda looks like updateCurrentState_ doesn't do that correctly right
-  // now, but it really should be fixed to do so. The cursor position stored in
-  // the state should be the cursor position before any changes are made, not
-  // the cursor position when the change finishes.
-  //
-  // It also seems like the if check below is just a bad one. We should do this
-  // for browsers that use mutation events as well even though the beforechange
-  // happens too late...maybe not. I don't know about this.
-  if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
-    // We don't listen to beforechange in mutation-event browsers because
-    // there we fire beforechange, then syncronously file change. The point
-    // of before change is to capture before the user has changed anything.
-    eventHandler.listen(fieldObject,
-        goog.editor.Field.EventType.BEFORECHANGE, this.handleBeforeChange_);
-  }
-  eventHandler.listen(fieldObject,
-      goog.editor.Field.EventType.DELAYEDCHANGE, this.handleDelayedChange_);
-  eventHandler.listen(fieldObject, goog.editor.Field.EventType.BLUR,
-      this.handleBlur_);
-
-  this.eventHandlers_[fieldObject.getHashCode()] = eventHandler;
-
-  // We want to capture the initial state of a Trogedit field before any
-  // editing has happened. This is necessary so that we can undo the first
-  // change to a field, even if we don't handle beforeChange.
-  this.updateCurrentState_(fieldObject);
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.disable = function(fieldObject) {
-  // Process any pending changes so we don't lose any undo-redo states that we
-  // want prior to disabling undo-redo.
-  fieldObject.clearDelayedChange();
-
-  var eventHandler = this.eventHandlers_[fieldObject.getHashCode()];
-  if (eventHandler) {
-    eventHandler.dispose();
-    delete this.eventHandlers_[fieldObject.getHashCode()];
-  }
-
-  // We delete the current state of the field on disable. When we re-enable
-  // the state will be re-fetched. In most cases the content will be the same,
-  // but this allows us to pick up changes while not editable. That way, when
-  // undoing after starting an editable session, you can always undo to the
-  // state you started in. Given this sequence of events:
-  // Make editable
-  // Type 'anakin'
-  // Make not editable
-  // Set HTML to be 'padme'
-  // Make editable
-  // Type 'dark side'
-  // Undo
-  // Without re-snapshoting current state on enable, the undo would go from
-  // 'dark-side' -> 'anakin', rather than 'dark-side' -> 'padme'. You couldn't
-  // undo the field to the state that existed immediately after it was made
-  // editable for the second time.
-  if (this.currentStates_[fieldObject.getHashCode()]) {
-    delete this.currentStates_[fieldObject.getHashCode()];
-  }
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.isEnabled = function(fieldObject) {
-  // All enabled plugins have a eventHandler so reuse that map rather than
-  // storing additional enabled state.
-  return !!this.eventHandlers_[fieldObject.getHashCode()];
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.disposeInternal = function() {
-  goog.editor.plugins.UndoRedo.superClass_.disposeInternal.call(this);
-
-  for (var hashcode in this.eventHandlers_) {
-    this.eventHandlers_[hashcode].dispose();
-    delete this.eventHandlers_[hashcode];
-  }
-  this.fieldObject = null;
-
-  if (this.undoManager_) {
-    this.undoManager_.dispose();
-    delete this.undoManager_;
-  }
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.getTrogClassId = function() {
-  return 'UndoRedo';
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.execCommand = function(command,
-    var_args) {
-  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
-    this.undoManager_.undo();
-  } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
-    this.undoManager_.redo();
-  }
-};
-
-
-/** @inheritDoc */
-goog.editor.plugins.UndoRedo.prototype.queryCommandValue = function(command) {
-  var state = null;
-  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
-    state = this.undoManager_.hasUndoState();
-  } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
-    state = this.undoManager_.hasRedoState();
-  }
-  return state;
-};
-
-
-/**
- * Dispatches the COMMAND_VALUE_CHANGE event on the editable field or the field
- * manager, as appropriate.
- * Note: Really, people using multi field mode should be listening directly
- * to the undo-redo manager for events.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.dispatchCommandValueChange_ =
-    function() {
-  var eventTarget = this.getCurrentEventTarget();
-  eventTarget.dispatchEvent({
-    type: goog.editor.Field.EventType.COMMAND_VALUE_CHANGE,
-    commands: [goog.editor.plugins.UndoRedo.COMMAND.REDO,
-      goog.editor.plugins.UndoRedo.COMMAND.UNDO]});
-};
-
-
-/**
- * Restores the state of the editable field.
- * @param {goog.editor.plugins.UndoRedo.UndoState_} state The state initiating
- *    the restore.
- * @param {string} content The content to restore.
- * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
- *     The cursor position within the content.
- */
-goog.editor.plugins.UndoRedo.prototype.restoreState = function(
-    state, content, cursorPosition) {
-  // Fire any pending changes to get the current field state up to date and
-  // then stop listening to changes while doing the undo/redo.
-  var fieldObj = this.getFieldObject(state.fieldHashCode);
-  if (!fieldObj) {
-    return;
-  }
-
-  // Fires any pending changes, and stops the change events. Still want to
-  // dispatch before change, as a change is being made and the change event
-  // will be manually dispatched below after the new content has been restored
-  // (also restarting change events).
-  fieldObj.stopChangeEvents(true, true);
-
-  // To prevent the situation where we stop change events and then an exception
-  // happens before we can restart change events, the following code must be in
-  // a try-finally block.
-  try {
-    fieldObj.dispatchBeforeChange();
-
-    // Restore the state
-    fieldObj.execCommand(goog.editor.Command.CLEAR_LOREM, true);
-
-    // We specifically set the raw innerHTML of the field here as that's what
-    // we get from the field when we save an undo/redo state. There's
-    // no need to clean/unclean the contents in either direction.
-    fieldObj.getElement().innerHTML = content;
-
-    if (cursorPosition) {
-      cursorPosition.select();
-    }
-
-    var previousFieldObject = this.getCurrentFieldObject();
-    fieldObj.focus();
-
-    // Apps that integrate their undo-redo with Trogedit may be
-    // in a state where there is no previous field object (no field focused at
-    // the time of undo), so check for existence first.
-    if (previousFieldObject &&
-        previousFieldObject.getHashCode() != state.fieldHashCode) {
-      previousFieldObject.execCommand(goog.editor.Command.UPDATE_LOREM);
-    }
-
-    // We need to update currentState_ to reflect the change.
-    this.currentStates_[state.fieldHashCode].setUndoState(
-        content, cursorPosition);
-  } catch (e) {
-    this.logger.severe('Error while restoring undo state', e);
-  } finally {
-    // Clear the delayed change event, set flag so we know not to act on it.
-    this.inProgressUndo_ = state;
-    // Notify the editor that we've changed (fire autosave).
-    // Note that this starts up change events again, so we don't have to
-    // manually do so even though we stopped change events above.
-    fieldObj.dispatchChange();
-    fieldObj.dispatchSelectionChangeEvent();
-  }
-};
-
-
-/**
- * @inheritDoc
- */
-goog.editor.plugins.UndoRedo.prototype.handleKeyboardShortcut = function(e, key,
-    isModifierPressed) {
-  if (isModifierPressed) {
-    var command;
-    if (key == 'z') {
-      command = e.shiftKey ? goog.editor.plugins.UndoRedo.COMMAND.REDO :
-          goog.editor.plugins.UndoRedo.COMMAND.UNDO;
-    } else if (key == 'y') {
-      command = goog.editor.plugins.UndoRedo.COMMAND.REDO;
-    }
-
-    if (command) {
-      // In the case where Trogedit shares its undo redo stack with another
-      // application it's possible that an undo or redo will not be for an
-      // goog.editor.Field. In this case we don't want to go through the
-      // goog.editor.Field execCommand flow which stops and restarts events on
-      // the current field. Only Trogedit UndoState's have a fieldHashCode so
-      // use that to distinguish between Trogedit and other states.
-      var state = command == goog.editor.plugins.UndoRedo.COMMAND.UNDO ?
-          this.undoManager_.undoPeek() : this.undoManager_.redoPeek();
-      if (state && state.fieldHashCode) {
-        this.getCurrentFieldObject().execCommand(command);
-      } else {
-        this.execCommand(command);
-      }
-
-      return true;
-    }
-  }
-
-  return false;
-};
-
-
-/**
- * Clear the undo/redo stack.
- */
-goog.editor.plugins.UndoRedo.prototype.clearHistory = function() {
-  // Fire all pending change events, so that they don't come back
-  // asynchronously to fill the queue.
-  this.fieldObject.stopChangeEvents(true, true);
-  this.undoManager_.clearHistory();
-  this.fieldObject.startChangeEvents();
-};
-
-
-/**
- * Refreshes the current state of the editable field as maintained by undo-redo,
- * without adding any undo-redo states to the stack.
- * @param {goog.editor.Field} fieldObject The editable field.
- */
-goog.editor.plugins.UndoRedo.prototype.refreshCurrentState = function(
-    fieldObject) {
-  if (this.isEnabled(fieldObject)) {
-    if (this.currentStates_[fieldObject.getHashCode()]) {
-      delete this.currentStates_[fieldObject.getHashCode()];
-    }
-    this.updateCurrentState_(fieldObject);
-  }
-};
-
-
-/**
- * Before the field changes, we want to save the state.
- * @param {goog.events.Event} e The event.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.handleBeforeChange_ = function(e) {
-  if (this.inProgressUndo_) {
-    // We are in between a previous undo and its delayed change event.
-    // Continuing here clobbers the redo stack.
-    // This does mean that if you are trying to undo/redo really quickly, it
-    // will be gated by the speed of delayed change events.
-    return;
-  }
-
-  var fieldObj = /** @type {goog.editor.Field} */ (e.target);
-  var fieldHashCode = fieldObj.getHashCode();
-
-  if (this.initialFieldChange_ != fieldHashCode) {
-    this.initialFieldChange_ = fieldHashCode;
-    this.updateCurrentState_(fieldObj);
-  }
-};
-
-
-/**
- * After some idle time, we want to save the state.
- * @param {goog.events.Event} e The event.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.handleDelayedChange_ = function(e) {
-  // This was undo making a change, don't add it BACK into the history
-  if (this.inProgressUndo_) {
-    // Must clear this.inProgressUndo_ before dispatching event because the
-    // dispatch can cause another, queued undo that should be allowed to go
-    // through.
-    var state = this.inProgressUndo_;
-    this.inProgressUndo_ = null;
-    state.dispatchEvent(goog.editor.plugins.UndoRedoState.ACTION_COMPLETED);
-    return;
-  }
-
-  this.updateCurrentState_(/** @type {goog.editor.Field} */ (e.target));
-};
-
-
-/**
- * When the user blurs away, we need to save the state on that field.
- * @param {goog.events.Event} e The event.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.handleBlur_ = function(e) {
-  var fieldObj = /** @type {goog.editor.Field} */ (e.target);
-  if (fieldObj) {
-    fieldObj.clearDelayedChange();
-  }
-};
-
-
-/**
- * Returns the goog.editor.plugins.UndoRedo.CursorPosition_ for the current
- * selection in the given Field.
- * @param {goog.editor.Field} fieldObj The field object.
- * @return {goog.editor.plugins.UndoRedo.CursorPosition_} The CursorPosition_ or
- *    null if there is no valid selection.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.getCursorPosition_ = function(fieldObj) {
-  var cursorPos = new goog.editor.plugins.UndoRedo.CursorPosition_(fieldObj);
-  if (!cursorPos.isValid()) {
-    return null;
-  }
-  return cursorPos;
-};
-
-
-/**
- * Helper method for saving state.
- * @param {goog.editor.Field} fieldObj The field object.
- * @private
- */
-goog.editor.plugins.UndoRedo.prototype.updateCurrentState_ = function(
-    fieldObj) {
-  var fieldHashCode = fieldObj.getHashCode();
-  // We specifically grab the raw innerHTML of the field here as that's what
-  // we would set on the field in the case of an undo/redo operation. There's
-  // no need to clean/unclean the contents in either direction. In the case of
-  // lorem ipsum being used, we want to capture the effective state (empty, no
-  // cursor position) rather than capturing the lorem html.
-  var content, cursorPos;
-  if (fieldObj.queryCommandValue(goog.editor.Command.USING_LOREM)) {
-    content = '';
-    cursorPos = null;
-  } else {
-    content = fieldObj.getElement().innerHTML;
-    cursorPos = this.getCursorPosition_(fieldObj);
-  }
-
-  var currentState = this.currentStates_[fieldHashCode];
-  if (currentState) {
-    // Don't create states if the content hasn't changed (spurious
-    // delayed change). This can happen when lorem is cleared, for example.
-    if (currentState.undoContent_ == content) {
-      return;
-    } else if (content == '' || currentState.undoContent_ == '') {
-      // If lorem ipsum is on we say the contents are the empty string. However,
-      // for an empty text shape with focus, the empty contents might not be
-      // the same, depending on plugins. We want these two empty states to be
-      // considered identical because to the user they are indistinguishable,
-      // so we use fieldObj.getInjectableContents to map between them.
-      // We cannot use getInjectableContents when first creating the undo
-      // content for a field with lorem, because on enable when this is first
-      // called we can't guarantee plugin registration order, so the
-      // injectableContents at that time might not match the final
-      // injectableContents.
-      var emptyContents = fieldObj.getInjectableContents('', {});
-      if (content == emptyContents && currentState.undoContent_ == '' ||
-          currentState.undoContent_ == emptyContents && content == '') {
-        return;
-      }
-    }
-
-    currentState.setRedoState(content, cursorPos);
-    this.undoManager_.addState(currentState);
-  }
-
-  this.currentStates_[fieldHashCode] =
-      new goog.editor.plugins.UndoRedo.UndoState_(fieldHashCode, content,
-          cursorPos, this.boundRestoreState_);
-};
-
-
-
-/**
- * This object encapsulates the state of an editable field.
- *
- * @param {string} fieldHashCode String the id of the field we're saving the
- *     content of.
- * @param {string} content String the actual text we're saving.
- * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
- *     CursorPosLite object for the cursor position in the field.
- * @param {Function} restore The function used to restore editable field state.
- * @private
- * @constructor
- * @extends {goog.editor.plugins.UndoRedoState}
- */
-goog.editor.plugins.UndoRedo.UndoState_ = function(fieldHashCode, content,
-    cursorPosition, restore) {
-  goog.editor.plugins.UndoRedoState.call(this, true);
-
-  /**
-   * The hash code for the field whose content is being saved.
-   * @type {string}
-   */
-  this.fieldHashCode = fieldHashCode;
-
-  /**
-   * The bound copy of {@code goog.editor.plugins.UndoRedo.restoreState} used by
-   * this state.
-   * @type {Function}
-   * @private
-   */
-  this.restore_ = restore;
-
-  this.setUndoState(content, cursorPosition);
-};
-goog.inherits(goog.editor.plugins.UndoRedo.UndoState_,
-    goog.editor.plugins.UndoRedoState);
-
-
-/**
- * The content to restore on undo.
- * @type {string}
- * @private
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.undoContent_;
-
-
-/**
- * The cursor position to restore on undo.
- * @type {goog.editor.plugins.UndoRedo.CursorPosition_?}
- * @private
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.undoCursorPosition_;
-
-
-/**
- * The content to restore on redo, undefined until the state is pushed onto the
- * undo stack.
- * @type {string|undefined}
- * @private
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.redoContent_;
-
-
-/**
- * The cursor position to restore on redo, undefined until the state is pushed
- * onto the undo stack.
- * @type {goog.editor.plugins.UndoRedo.CursorPosition_|null|undefined}
- * @private
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.redoCursorPosition_;
-
-
-/**
- * Performs the undo operation represented by this state.
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.undo = function() {
-  this.restore_(this, this.undoContent_,
-      this.undoCursorPosition_);
-};
-
-
-/**
- * Performs the redo operation represented by this state.
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.redo = function() {
-  this.restore_(this, this.redoContent_,
-      this.redoCursorPosition_);
-};
-
-
-/**
- * Updates the undo portion of this state. Should only be used to update the
- * current state of an editable field, which is not yet on the undo stack after
- * an undo or redo operation. You should never be modifying states on the stack!
- * @param {string} content The current content.
- * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
- *     The current cursor position.
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.setUndoState = function(
-    content, cursorPosition) {
-  this.undoContent_ = content;
-  this.undoCursorPosition_ = cursorPosition;
-};
-
-
-/**
- * Adds redo information to this state. This method should be called before the
- * state is added onto the undo stack.
- *
- * @param {string} content The content to restore on a redo.
- * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
- *     The cursor position to restore on a redo.
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.setRedoState = function(
-    content, cursorPosition) {
-  this.redoContent_ = content;
-  this.redoCursorPosition_ = cursorPosition;
-};
-
-
-/**
- * Checks if the *contents* of two
- * {@code goog.editor.plugins.UndoRedo.UndoState_}s are the same.  We don't
- * bother checking the cursor position (that's not something we'd want to save
- * anyway).
- * @param {goog.editor.plugins.UndoRedo.UndoState_} rhs The state to compare.
- * @return {boolean} Whether the contents are the same.
- */
-goog.editor.plugins.UndoRedo.UndoState_.prototype.equals = function(rhs) {
-  return this.fieldHashCode == rhs.fieldHashCode &&
-      this.undoContent_ == rhs.undoContent_ &&
-      this.redoContent_ == rhs.redoContent_;
-};
-
-
-
-/**
- * Stores the state of the selection in a way the survives DOM modifications
- * that don't modify the user-interactable content (e.g. making something bold
- * vs. typing a character).
- *
- * TODO(user): Completely get rid of this and use goog.dom.SavedCaretRange.
- *
- * @param {goog.editor.Field} field The field the selection is in.
- * @private
- * @constructor
- */
-goog.editor.plugins.UndoRedo.CursorPosition_ = function(field) {
-  this.field_ = field;
-
-  var win = field.getEditableDomHelper().getWindow();
-  var range = field.getRange();
-  var isValidRange = !!range && range.isRangeInDocument() &&
-      range.getWindow() == win;
-  range = isValidRange ? range : null;
-
-  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
-    this.initW3C_(range);
-  } else if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
-    this.initIE_(range);
-  }
-};
-
-
-/**
- * The standards compliant version keeps a list of childNode offsets.
- * @param {goog.dom.AbstractRange?} range The range to save.
- * @private
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initW3C_ = function(
-    range) {
-  this.isValid_ = false;
-
-  // TODO: Check if the range is in the field before trying to save it
-  // for FF 3 contentEditable.
-  if (!range) {
-    return;
-  }
-
-  var anchorNode = range.getAnchorNode();
-  var focusNode = range.getFocusNode();
-  if (!anchorNode || !focusNode) {
-    return;
-  }
-
-  var anchorOffset = range.getAnchorOffset();
-  var anchor = new goog.dom.NodeOffset(anchorNode, this.field_.getElement());
-
-  var focusOffset = range.getFocusOffset();
-  var focus = new goog.dom.NodeOffset(focusNode, this.field_.getElement());
-
-  // Test range direction.
-  if (range.isReversed()) {
-    this.startOffset_ = focus;
-    this.startChildOffset_ = focusOffset;
-    this.endOffset_ = anchor;
-    this.endChildOffset_ = anchorOffset;
-  } else {
-    this.startOffset_ = anchor;
-    this.startChildOffset_ = anchorOffset;
-    this.endOffset_ = focus;
-    this.endChildOffset_ = focusOffset;
-  }
-
-  this.isValid_ = true;
-};
-
-
-/**
- * In IE, we just keep track of the text offset (number of characters).
- * @param {goog.dom.AbstractRange?} range The range to save.
- * @private
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initIE_ = function(
-    range) {
-  this.isValid_ = false;
-
-  if (!range) {
-    return;
-  }
-
-  var ieRange = range.getTextRange(0).getBrowserRangeObject();
-
-  if (!goog.dom.contains(this.field_.getElement(), ieRange.parentElement())) {
-    return;
-  }
-
-  // Create a range that encompasses the contentEditable region to serve
-  // as a reference to form ranges below.
-  var contentEditableRange =
-      this.field_.getEditableDomHelper().getDocument().body.createTextRange();
-  contentEditableRange.moveToElementText(this.field_.getElement());
-
-  // startMarker is a range from the start of the contentEditable node to the
-  // start of the current selection.
-  var startMarker = ieRange.duplicate();
-  startMarker.collapse(true);
-  startMarker.setEndPoint('StartToStart', contentEditableRange);
-  this.startOffset_ =
-      goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(
-          startMarker);
-
-  // endMarker is a range from the start of teh contentEditable node to the
-  // end of the current selection.
-  var endMarker = ieRange.duplicate();
-  endMarker.setEndPoint('StartToStart', contentEditableRange);
-  this.endOffset_ =
-      goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(
-          endMarker);
-
-  this.isValid_ = true;
-};
-
-
-/**
- * @return {boolean} Whether this object is valid.
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.isValid = function() {
-  return this.isValid_;
-};
-
-
-/**
- * @return {string} A string representation of this object.
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.toString = function() {
-  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
-    return 'W3C:' + this.startOffset_.toString() + '\n' +
-        this.startChildOffset_ + ':' + this.endOffset_.toString() + '\n' +
-        this.endChildOffset_;
-  }
-  return 'IE:' + this.startOffset_ + ',' + this.endOffset_;
-};
-
-
-/**
- * Makes the browser's selection match the cursor position.
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.select = function() {
-  var range = this.getRange_(this.field_.getElement());
-  if (range) {
-    if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
-      this.field_.getElement().focus();
-    }
-    goog.dom.Range.createFromBrowserRange(range).select();
-  }
-};
-
-
-/**
- * Get the range that encompases the the cursor position relative to a given
- * base node.
- * @param {Element} baseNode The node to get the cursor position relative to.
- * @return {Range|TextRange|null} The browser range for this position.
- * @private
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.prototype.getRange_ =
-    function(baseNode) {
-  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
-    var startNode = this.startOffset_.findTargetNode(baseNode);
-    var endNode = this.endOffset_.findTargetNode(baseNode);
-    if (!startNode || !endNode) {
-      return null;
-    }
-
-    // Create range.
-    return /** @type {Range} */ (
-        goog.dom.Range.createFromNodes(startNode, this.startChildOffset_,
-            endNode, this.endChildOffset_).getBrowserRangeObject());
-  }
-
-  // Create a collapsed selection at the start of the contentEditable region,
-  // which the offsets were calculated relative to before.  Note that we force
-  // a text range here so we can use moveToElementText.
-  var sel = baseNode.ownerDocument.body.createTextRange();
-  sel.moveToElementText(baseNode);
-  sel.collapse(true);
-  sel.moveEnd('character', this.endOffset_);
-  sel.moveStart('character', this.startOffset_);
-  return sel;
-};
-
-
-/**
- * Compute the number of characters to the end of the range in IE.
- * @param {TextRange} range The range to compute an offset for.
- * @return {number} The number of characters to the end of the range.
- * @private
- */
-goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_ =
-    function(range) {
-  var testRange = range.duplicate();
-
-  // The number of offset characters is a little off depending on
-  // what type of block elements happen to be between the start of the
-  // textedit and the cursor position.  We fudge the offset until the
-  // two ranges match.
-  var text = range.text;
-  var guess = text.length;
-
-  testRange.collapse(true);
-  testRange.moveEnd('character', guess);
-
-  // Adjust the range until the end points match.  This doesn't quite
-  // work if we're at the end of the field so we give up after a few
-  // iterations.
-  var diff;
-  var numTries = 10;
-  while (diff = testRange.compareEndPoints('EndToEnd', range)) {
-    guess -= diff;
-    testRange.moveEnd('character', -diff);
-    --numTries;
-    if (0 == numTries) {
-      break;
-    }
-  }
-  // When we set innerHTML, blank lines become a single space, causing
-  // the cursor position to be off by one.  So we accommodate for blank
-  // lines.
-  var offset = 0;
-  var pos = text.indexOf('\n\r');
-  while (pos != -1) {
-    ++offset;
-    pos = text.indexOf('\n\r', pos + 1);
-  }
-  return guess + offset;
-};