| 1 |
// Copyright 2005 The Closure Library Authors. All Rights Reserved. |
| 2 |
// |
| 3 |
// Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 |
// you may not use this file except in compliance with the License. |
| 5 |
// You may obtain a copy of the License at |
| 6 |
// |
| 7 |
// http://www.apache.org/licenses/LICENSE-2.0 |
| 8 |
// |
| 9 |
// Unless required by applicable law or agreed to in writing, software |
| 10 |
// distributed under the License is distributed on an "AS-IS" BASIS, |
| 11 |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 |
// See the License for the specific language governing permissions and |
| 13 |
// limitations under the License. |
| 14 |
|
| 15 |
|
| 16 |
/** |
| 17 |
* @fileoverview Code for handling edit history (undo/redo). |
| 18 |
* |
| 19 |
*/ |
| 20 |
|
| 21 |
|
| 22 |
goog.provide('goog.editor.plugins.UndoRedo'); |
| 23 |
|
| 24 |
goog.require('goog.dom'); |
| 25 |
goog.require('goog.dom.NodeOffset'); |
| 26 |
goog.require('goog.dom.Range'); |
| 27 |
goog.require('goog.editor.BrowserFeature'); |
| 28 |
goog.require('goog.editor.Command'); |
| 29 |
goog.require('goog.editor.Field'); |
| 30 |
goog.require('goog.editor.Plugin'); |
| 31 |
goog.require('goog.editor.node'); |
| 32 |
goog.require('goog.editor.plugins.UndoRedoManager'); |
| 33 |
goog.require('goog.editor.plugins.UndoRedoState'); |
| 34 |
goog.require('goog.events'); |
| 35 |
goog.require('goog.events.EventHandler'); |
| 36 |
goog.require('goog.log'); |
| 37 |
goog.require('goog.object'); |
| 38 |
|
| 39 |
|
| 40 |
|
| 41 |
/** |
| 42 |
* Encapsulates undo/redo logic using a custom undo stack (i.e. not browser |
| 43 |
* built-in). Browser built-in undo stacks are too flaky (e.g. IE's gets |
| 44 |
* clobbered on DOM modifications). Also, this allows interleaving non-editing |
| 45 |
* commands into the undo stack via the UndoRedoManager. |
| 46 |
* |
| 47 |
* @param {goog.editor.plugins.UndoRedoManager=} opt_manager An undo redo |
| 48 |
* manager to be used by this plugin. If none is provided one is created. |
| 49 |
* @constructor |
| 50 |
* @extends {goog.editor.Plugin} |
| 51 |
*/ |
| 52 |
goog.editor.plugins.UndoRedo = function(opt_manager) { |
| 53 |
goog.editor.Plugin.call(this); |
| 54 |
|
| 55 |
this.setUndoRedoManager( |
| 56 |
opt_manager || new goog.editor.plugins.UndoRedoManager()); |
| 57 |
|
| 58 |
// Map of goog.editor.Field hashcode to goog.events.EventHandler |
| 59 |
this.eventHandlers_ = {}; |
| 60 |
|
| 61 |
this.currentStates_ = {}; |
| 62 |
|
| 63 |
/** |
| 64 |
* @type {?string} |
| 65 |
* @private |
| 66 |
*/ |
| 67 |
this.initialFieldChange_ = null; |
| 68 |
|
| 69 |
/** |
| 70 |
* A copy of {@code goog.editor.plugins.UndoRedo.restoreState} bound to this, |
| 71 |
* used by undo-redo state objects to restore the state of an editable field. |
| 72 |
* @type {Function} |
| 73 |
* @see goog.editor.plugins.UndoRedo#restoreState |
| 74 |
* @private |
| 75 |
*/ |
| 76 |
this.boundRestoreState_ = goog.bind(this.restoreState, this); |
| 77 |
}; |
| 78 |
goog.inherits(goog.editor.plugins.UndoRedo, goog.editor.Plugin); |
| 79 |
|
| 80 |
|
| 81 |
/** |
| 82 |
* The logger for this class. |
| 83 |
* @type {goog.log.Logger} |
| 84 |
* @protected |
| 85 |
* @override |
| 86 |
*/ |
| 87 |
goog.editor.plugins.UndoRedo.prototype.logger = |
| 88 |
goog.log.getLogger('goog.editor.plugins.UndoRedo'); |
| 89 |
|
| 90 |
|
| 91 |
/** |
| 92 |
* The {@code UndoState_} whose change is in progress, null if an undo or redo |
| 93 |
* is not in progress. |
| 94 |
* |
| 95 |
* @type {goog.editor.plugins.UndoRedo.UndoState_?} |
| 96 |
* @private |
| 97 |
*/ |
| 98 |
goog.editor.plugins.UndoRedo.prototype.inProgressUndo_ = null; |
| 99 |
|
| 100 |
|
| 101 |
/** |
| 102 |
* The undo-redo stack manager used by this plugin. |
| 103 |
* @type {goog.editor.plugins.UndoRedoManager} |
| 104 |
* @private |
| 105 |
*/ |
| 106 |
goog.editor.plugins.UndoRedo.prototype.undoManager_; |
| 107 |
|
| 108 |
|
| 109 |
/** |
| 110 |
* The key for the event listener handling state change events from the |
| 111 |
* undo-redo manager. |
| 112 |
* @type {goog.events.Key} |
| 113 |
* @private |
| 114 |
*/ |
| 115 |
goog.editor.plugins.UndoRedo.prototype.managerStateChangeKey_; |
| 116 |
|
| 117 |
|
| 118 |
/** |
| 119 |
* Commands implemented by this plugin. |
| 120 |
* @enum {string} |
| 121 |
*/ |
| 122 |
goog.editor.plugins.UndoRedo.COMMAND = { |
| 123 |
UNDO: '+undo', |
| 124 |
REDO: '+redo' |
| 125 |
}; |
| 126 |
|
| 127 |
|
| 128 |
/** |
| 129 |
* Inverse map of execCommand strings to |
| 130 |
* {@link goog.editor.plugins.UndoRedo.COMMAND} constants. Used to determine |
| 131 |
* whether a string corresponds to a command this plugin handles in O(1) time. |
| 132 |
* @type {Object} |
| 133 |
* @private |
| 134 |
*/ |
| 135 |
goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_ = |
| 136 |
goog.object.transpose(goog.editor.plugins.UndoRedo.COMMAND); |
| 137 |
|
| 138 |
|
| 139 |
/** |
| 140 |
* Set the max undo stack depth (not the real memory usage). |
| 141 |
* @param {number} depth Depth of the stack. |
| 142 |
*/ |
| 143 |
goog.editor.plugins.UndoRedo.prototype.setMaxUndoDepth = function(depth) { |
| 144 |
this.undoManager_.setMaxUndoDepth(depth); |
| 145 |
}; |
| 146 |
|
| 147 |
|
| 148 |
/** |
| 149 |
* Set the undo-redo manager used by this plugin. Any state on a previous |
| 150 |
* undo-redo manager is lost. |
| 151 |
* @param {goog.editor.plugins.UndoRedoManager} manager The undo-redo manager. |
| 152 |
*/ |
| 153 |
goog.editor.plugins.UndoRedo.prototype.setUndoRedoManager = function(manager) { |
| 154 |
if (this.managerStateChangeKey_) { |
| 155 |
goog.events.unlistenByKey(this.managerStateChangeKey_); |
| 156 |
} |
| 157 |
|
| 158 |
this.undoManager_ = manager; |
| 159 |
this.managerStateChangeKey_ = goog.events.listen( |
| 160 |
this.undoManager_, |
| 161 |
goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE, |
| 162 |
this.dispatchCommandValueChange_, false, this); |
| 163 |
}; |
| 164 |
|
| 165 |
|
| 166 |
/** |
| 167 |
* Whether the string corresponds to a command this plugin handles. |
| 168 |
* @param {string} command Command string to check. |
| 169 |
* @return {boolean} Whether the string corresponds to a command |
| 170 |
* this plugin handles. |
| 171 |
* @override |
| 172 |
*/ |
| 173 |
goog.editor.plugins.UndoRedo.prototype.isSupportedCommand = function(command) { |
| 174 |
return command in goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_; |
| 175 |
}; |
| 176 |
|
| 177 |
|
| 178 |
/** |
| 179 |
* Unregisters and disables the fieldObject with this plugin. Thie does *not* |
| 180 |
* clobber the undo stack for the fieldObject though. |
| 181 |
* TODO(user): For the multifield version, we really should add a way to |
| 182 |
* ignore undo actions on field's that have been made uneditable. |
| 183 |
* This is probably as simple as skipping over entries in the undo stack |
| 184 |
* that have a hashcode of an uneditable field. |
| 185 |
* @param {goog.editor.Field} fieldObject The field to register with the plugin. |
| 186 |
* @override |
| 187 |
*/ |
| 188 |
goog.editor.plugins.UndoRedo.prototype.unregisterFieldObject = function( |
| 189 |
fieldObject) { |
| 190 |
this.disable(fieldObject); |
| 191 |
this.setFieldObject(null); |
| 192 |
}; |
| 193 |
|
| 194 |
|
| 195 |
/** |
| 196 |
* This is so subclasses can deal with multifield undo-redo. |
| 197 |
* @return {goog.editor.Field} The active field object for this field. This is |
| 198 |
* the one registered field object for the single-plugin case and the |
| 199 |
* focused field for the multi-field plugin case. |
| 200 |
*/ |
| 201 |
goog.editor.plugins.UndoRedo.prototype.getCurrentFieldObject = function() { |
| 202 |
return this.getFieldObject(); |
| 203 |
}; |
| 204 |
|
| 205 |
|
| 206 |
/** |
| 207 |
* This is so subclasses can deal with multifield undo-redo. |
| 208 |
* @param {string} fieldHashCode The Field's hashcode. |
| 209 |
* @return {goog.editor.Field} The field object with the hashcode. |
| 210 |
*/ |
| 211 |
goog.editor.plugins.UndoRedo.prototype.getFieldObjectForHash = function( |
| 212 |
fieldHashCode) { |
| 213 |
// With single field undoredo, there's only one Field involved. |
| 214 |
return this.getFieldObject(); |
| 215 |
}; |
| 216 |
|
| 217 |
|
| 218 |
/** |
| 219 |
* This is so subclasses can deal with multifield undo-redo. |
| 220 |
* @return {goog.editor.Field} Target for COMMAND_VALUE_CHANGE events. |
| 221 |
*/ |
| 222 |
goog.editor.plugins.UndoRedo.prototype.getCurrentEventTarget = function() { |
| 223 |
return this.getFieldObject(); |
| 224 |
}; |
| 225 |
|
| 226 |
|
| 227 |
/** @override */ |
| 228 |
goog.editor.plugins.UndoRedo.prototype.enable = function(fieldObject) { |
| 229 |
if (this.isEnabled(fieldObject)) { |
| 230 |
return; |
| 231 |
} |
| 232 |
|
| 233 |
// Don't want pending delayed changes from when undo-redo was disabled |
| 234 |
// firing after undo-redo is enabled since they might cause undo-redo stack |
| 235 |
// updates. |
| 236 |
fieldObject.clearDelayedChange(); |
| 237 |
|
| 238 |
var eventHandler = new goog.events.EventHandler(this); |
| 239 |
|
| 240 |
// TODO(user): From ojan during a code review: |
| 241 |
// The beforechange handler is meant to be there so you can grab the cursor |
| 242 |
// position *before* the change is made as that's where you want the cursor to |
| 243 |
// be after an undo. |
| 244 |
// |
| 245 |
// It kinda looks like updateCurrentState_ doesn't do that correctly right |
| 246 |
// now, but it really should be fixed to do so. The cursor position stored in |
| 247 |
// the state should be the cursor position before any changes are made, not |
| 248 |
// the cursor position when the change finishes. |
| 249 |
// |
| 250 |
// It also seems like the if check below is just a bad one. We should do this |
| 251 |
// for browsers that use mutation events as well even though the beforechange |
| 252 |
// happens too late...maybe not. I don't know about this. |
| 253 |
if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) { |
| 254 |
// We don't listen to beforechange in mutation-event browsers because |
| 255 |
// there we fire beforechange, then syncronously file change. The point |
| 256 |
// of before change is to capture before the user has changed anything. |
| 257 |
eventHandler.listen( |
| 258 |
fieldObject, goog.editor.Field.EventType.BEFORECHANGE, |
| 259 |
this.handleBeforeChange_); |
| 260 |
} |
| 261 |
eventHandler.listen( |
| 262 |
fieldObject, goog.editor.Field.EventType.DELAYEDCHANGE, |
| 263 |
this.handleDelayedChange_); |
| 264 |
eventHandler.listen( |
| 265 |
fieldObject, goog.editor.Field.EventType.BLUR, this.handleBlur_); |
| 266 |
|
| 267 |
this.eventHandlers_[fieldObject.getHashCode()] = eventHandler; |
| 268 |
|
| 269 |
// We want to capture the initial state of a Trogedit field before any |
| 270 |
// editing has happened. This is necessary so that we can undo the first |
| 271 |
// change to a field, even if we don't handle beforeChange. |
| 272 |
this.updateCurrentState_(fieldObject); |
| 273 |
}; |
| 274 |
|
| 275 |
|
| 276 |
/** @override */ |
| 277 |
goog.editor.plugins.UndoRedo.prototype.disable = function(fieldObject) { |
| 278 |
// Process any pending changes so we don't lose any undo-redo states that we |
| 279 |
// want prior to disabling undo-redo. |
| 280 |
fieldObject.clearDelayedChange(); |
| 281 |
|
| 282 |
var eventHandler = this.eventHandlers_[fieldObject.getHashCode()]; |
| 283 |
if (eventHandler) { |
| 284 |
eventHandler.dispose(); |
| 285 |
delete this.eventHandlers_[fieldObject.getHashCode()]; |
| 286 |
} |
| 287 |
|
| 288 |
// We delete the current state of the field on disable. When we re-enable |
| 289 |
// the state will be re-fetched. In most cases the content will be the same, |
| 290 |
// but this allows us to pick up changes while not editable. That way, when |
| 291 |
// undoing after starting an editable session, you can always undo to the |
| 292 |
// state you started in. Given this sequence of events: |
| 293 |
// Make editable |
| 294 |
// Type 'anakin' |
| 295 |
// Make not editable |
| 296 |
// Set HTML to be 'padme' |
| 297 |
// Make editable |
| 298 |
// Type 'dark side' |
| 299 |
// Undo |
| 300 |
// Without re-snapshoting current state on enable, the undo would go from |
| 301 |
// 'dark-side' -> 'anakin', rather than 'dark-side' -> 'padme'. You couldn't |
| 302 |
// undo the field to the state that existed immediately after it was made |
| 303 |
// editable for the second time. |
| 304 |
if (this.currentStates_[fieldObject.getHashCode()]) { |
| 305 |
delete this.currentStates_[fieldObject.getHashCode()]; |
| 306 |
} |
| 307 |
}; |
| 308 |
|
| 309 |
|
| 310 |
/** @override */ |
| 311 |
goog.editor.plugins.UndoRedo.prototype.isEnabled = function(fieldObject) { |
| 312 |
// All enabled plugins have a eventHandler so reuse that map rather than |
| 313 |
// storing additional enabled state. |
| 314 |
return !!this.eventHandlers_[fieldObject.getHashCode()]; |
| 315 |
}; |
| 316 |
|
| 317 |
|
| 318 |
/** @override */ |
| 319 |
goog.editor.plugins.UndoRedo.prototype.disposeInternal = function() { |
| 320 |
goog.editor.plugins.UndoRedo.superClass_.disposeInternal.call(this); |
| 321 |
|
| 322 |
for (var hashcode in this.eventHandlers_) { |
| 323 |
this.eventHandlers_[hashcode].dispose(); |
| 324 |
delete this.eventHandlers_[hashcode]; |
| 325 |
} |
| 326 |
this.setFieldObject(null); |
| 327 |
|
| 328 |
if (this.undoManager_) { |
| 329 |
this.undoManager_.dispose(); |
| 330 |
delete this.undoManager_; |
| 331 |
} |
| 332 |
}; |
| 333 |
|
| 334 |
|
| 335 |
/** @override */ |
| 336 |
goog.editor.plugins.UndoRedo.prototype.getTrogClassId = function() { |
| 337 |
return 'UndoRedo'; |
| 338 |
}; |
| 339 |
|
| 340 |
|
| 341 |
/** @override */ |
| 342 |
goog.editor.plugins.UndoRedo.prototype.execCommand = function( |
| 343 |
command, var_args) { |
| 344 |
if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) { |
| 345 |
this.undoManager_.undo(); |
| 346 |
} else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) { |
| 347 |
this.undoManager_.redo(); |
| 348 |
} |
| 349 |
}; |
| 350 |
|
| 351 |
|
| 352 |
/** @override */ |
| 353 |
goog.editor.plugins.UndoRedo.prototype.queryCommandValue = function(command) { |
| 354 |
var state = null; |
| 355 |
if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) { |
| 356 |
state = this.undoManager_.hasUndoState(); |
| 357 |
} else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) { |
| 358 |
state = this.undoManager_.hasRedoState(); |
| 359 |
} |
| 360 |
return state; |
| 361 |
}; |
| 362 |
|
| 363 |
|
| 364 |
/** |
| 365 |
* Dispatches the COMMAND_VALUE_CHANGE event on the editable field or the field |
| 366 |
* manager, as appropriate. |
| 367 |
* Note: Really, people using multi field mode should be listening directly |
| 368 |
* to the undo-redo manager for events. |
| 369 |
* @private |
| 370 |
*/ |
| 371 |
goog.editor.plugins.UndoRedo.prototype.dispatchCommandValueChange_ = |
| 372 |
function() { |
| 373 |
var eventTarget = this.getCurrentEventTarget(); |
| 374 |
eventTarget.dispatchEvent({ |
| 375 |
type: goog.editor.Field.EventType.COMMAND_VALUE_CHANGE, |
| 376 |
commands: [ |
| 377 |
goog.editor.plugins.UndoRedo.COMMAND.REDO, |
| 378 |
goog.editor.plugins.UndoRedo.COMMAND.UNDO |
| 379 |
] |
| 380 |
}); |
| 381 |
}; |
| 382 |
|
| 383 |
|
| 384 |
/** |
| 385 |
* Restores the state of the editable field. |
| 386 |
* @param {goog.editor.plugins.UndoRedo.UndoState_} state The state initiating |
| 387 |
* the restore. |
| 388 |
* @param {string} content The content to restore. |
| 389 |
* @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition |
| 390 |
* The cursor position within the content. |
| 391 |
*/ |
| 392 |
goog.editor.plugins.UndoRedo.prototype.restoreState = function( |
| 393 |
state, content, cursorPosition) { |
| 394 |
// Fire any pending changes to get the current field state up to date and |
| 395 |
// then stop listening to changes while doing the undo/redo. |
| 396 |
var fieldObj = this.getFieldObjectForHash(state.fieldHashCode); |
| 397 |
if (!fieldObj) { |
| 398 |
return; |
| 399 |
} |
| 400 |
|
| 401 |
// Fires any pending changes, and stops the change events. Still want to |
| 402 |
// dispatch before change, as a change is being made and the change event |
| 403 |
// will be manually dispatched below after the new content has been restored |
| 404 |
// (also restarting change events). |
| 405 |
fieldObj.stopChangeEvents(true, true); |
| 406 |
|
| 407 |
// To prevent the situation where we stop change events and then an exception |
| 408 |
// happens before we can restart change events, the following code must be in |
| 409 |
// a try-finally block. |
| 410 |
try { |
| 411 |
fieldObj.dispatchBeforeChange(); |
| 412 |
|
| 413 |
// Restore the state |
| 414 |
fieldObj.execCommand(goog.editor.Command.CLEAR_LOREM, true); |
| 415 |
|
| 416 |
// We specifically set the raw innerHTML of the field here as that's what |
| 417 |
// we get from the field when we save an undo/redo state. There's |
| 418 |
// no need to clean/unclean the contents in either direction. |
| 419 |
goog.editor.node.replaceInnerHtml(fieldObj.getElement(), content); |
| 420 |
|
| 421 |
if (cursorPosition) { |
| 422 |
cursorPosition.select(); |
| 423 |
} |
| 424 |
|
| 425 |
var previousFieldObject = this.getCurrentFieldObject(); |
| 426 |
fieldObj.focus(); |
| 427 |
|
| 428 |
// Apps that integrate their undo-redo with Trogedit may be |
| 429 |
// in a state where there is no previous field object (no field focused at |
| 430 |
// the time of undo), so check for existence first. |
| 431 |
if (previousFieldObject && |
| 432 |
previousFieldObject.getHashCode() != state.fieldHashCode) { |
| 433 |
previousFieldObject.execCommand(goog.editor.Command.UPDATE_LOREM); |
| 434 |
} |
| 435 |
|
| 436 |
// We need to update currentState_ to reflect the change. |
| 437 |
this.currentStates_[state.fieldHashCode].setUndoState( |
| 438 |
content, cursorPosition); |
| 439 |
} catch (e) { |
| 440 |
goog.log.error(this.logger, 'Error while restoring undo state', e); |
| 441 |
} finally { |
| 442 |
// Clear the delayed change event, set flag so we know not to act on it. |
| 443 |
this.inProgressUndo_ = state; |
| 444 |
// Notify the editor that we've changed (fire autosave). |
| 445 |
// Note that this starts up change events again, so we don't have to |
| 446 |
// manually do so even though we stopped change events above. |
| 447 |
fieldObj.dispatchChange(); |
| 448 |
fieldObj.dispatchSelectionChangeEvent(); |
| 449 |
} |
| 450 |
}; |
| 451 |
|
| 452 |
|
| 453 |
/** |
| 454 |
* @override |
| 455 |
*/ |
| 456 |
goog.editor.plugins.UndoRedo.prototype.handleKeyboardShortcut = function( |
| 457 |
e, key, isModifierPressed) { |
| 458 |
if (isModifierPressed) { |
| 459 |
var command; |
| 460 |
if (key == 'z') { |
| 461 |
command = e.shiftKey ? goog.editor.plugins.UndoRedo.COMMAND.REDO : |
| 462 |
goog.editor.plugins.UndoRedo.COMMAND.UNDO; |
| 463 |
} else if (key == 'y') { |
| 464 |
command = goog.editor.plugins.UndoRedo.COMMAND.REDO; |
| 465 |
} |
| 466 |
|
| 467 |
if (command) { |
| 468 |
// In the case where Trogedit shares its undo redo stack with another |
| 469 |
// application it's possible that an undo or redo will not be for an |
| 470 |
// goog.editor.Field. In this case we don't want to go through the |
| 471 |
// goog.editor.Field execCommand flow which stops and restarts events on |
| 472 |
// the current field. Only Trogedit UndoState's have a fieldHashCode so |
| 473 |
// use that to distinguish between Trogedit and other states. |
| 474 |
var state = command == goog.editor.plugins.UndoRedo.COMMAND.UNDO ? |
| 475 |
this.undoManager_.undoPeek() : |
| 476 |
this.undoManager_.redoPeek(); |
| 477 |
if (state && state.fieldHashCode) { |
| 478 |
this.getCurrentFieldObject().execCommand(command); |
| 479 |
} else { |
| 480 |
this.execCommand(command); |
| 481 |
} |
| 482 |
|
| 483 |
return true; |
| 484 |
} |
| 485 |
} |
| 486 |
|
| 487 |
return false; |
| 488 |
}; |
| 489 |
|
| 490 |
|
| 491 |
/** |
| 492 |
* Clear the undo/redo stack. |
| 493 |
*/ |
| 494 |
goog.editor.plugins.UndoRedo.prototype.clearHistory = function() { |
| 495 |
// Fire all pending change events, so that they don't come back |
| 496 |
// asynchronously to fill the queue. |
| 497 |
this.getFieldObject().stopChangeEvents(true, true); |
| 498 |
this.undoManager_.clearHistory(); |
| 499 |
this.getFieldObject().startChangeEvents(); |
| 500 |
}; |
| 501 |
|
| 502 |
|
| 503 |
/** |
| 504 |
* Refreshes the current state of the editable field as maintained by undo-redo, |
| 505 |
* without adding any undo-redo states to the stack. |
| 506 |
* @param {goog.editor.Field} fieldObject The editable field. |
| 507 |
*/ |
| 508 |
goog.editor.plugins.UndoRedo.prototype.refreshCurrentState = function( |
| 509 |
fieldObject) { |
| 510 |
if (this.isEnabled(fieldObject)) { |
| 511 |
if (this.currentStates_[fieldObject.getHashCode()]) { |
| 512 |
delete this.currentStates_[fieldObject.getHashCode()]; |
| 513 |
} |
| 514 |
this.updateCurrentState_(fieldObject); |
| 515 |
} |
| 516 |
}; |
| 517 |
|
| 518 |
|
| 519 |
/** |
| 520 |
* Before the field changes, we want to save the state. |
| 521 |
* @param {goog.events.Event} e The event. |
| 522 |
* @private |
| 523 |
*/ |
| 524 |
goog.editor.plugins.UndoRedo.prototype.handleBeforeChange_ = function(e) { |
| 525 |
if (this.inProgressUndo_) { |
| 526 |
// We are in between a previous undo and its delayed change event. |
| 527 |
// Continuing here clobbers the redo stack. |
| 528 |
// This does mean that if you are trying to undo/redo really quickly, it |
| 529 |
// will be gated by the speed of delayed change events. |
| 530 |
return; |
| 531 |
} |
| 532 |
|
| 533 |
var fieldObj = /** @type {goog.editor.Field} */ (e.target); |
| 534 |
var fieldHashCode = fieldObj.getHashCode(); |
| 535 |
|
| 536 |
if (this.initialFieldChange_ != fieldHashCode) { |
| 537 |
this.initialFieldChange_ = fieldHashCode; |
| 538 |
this.updateCurrentState_(fieldObj); |
| 539 |
} |
| 540 |
}; |
| 541 |
|
| 542 |
|
| 543 |
/** |
| 544 |
* After some idle time, we want to save the state. |
| 545 |
* @param {goog.events.Event} e The event. |
| 546 |
* @private |
| 547 |
*/ |
| 548 |
goog.editor.plugins.UndoRedo.prototype.handleDelayedChange_ = function(e) { |
| 549 |
// This was undo making a change, don't add it BACK into the history |
| 550 |
if (this.inProgressUndo_) { |
| 551 |
// Must clear this.inProgressUndo_ before dispatching event because the |
| 552 |
// dispatch can cause another, queued undo that should be allowed to go |
| 553 |
// through. |
| 554 |
var state = this.inProgressUndo_; |
| 555 |
this.inProgressUndo_ = null; |
| 556 |
state.dispatchEvent(goog.editor.plugins.UndoRedoState.ACTION_COMPLETED); |
| 557 |
return; |
| 558 |
} |
| 559 |
|
| 560 |
this.updateCurrentState_(/** @type {goog.editor.Field} */ (e.target)); |
| 561 |
}; |
| 562 |
|
| 563 |
|
| 564 |
/** |
| 565 |
* When the user blurs away, we need to save the state on that field. |
| 566 |
* @param {goog.events.Event} e The event. |
| 567 |
* @private |
| 568 |
*/ |
| 569 |
goog.editor.plugins.UndoRedo.prototype.handleBlur_ = function(e) { |
| 570 |
var fieldObj = /** @type {goog.editor.Field} */ (e.target); |
| 571 |
if (fieldObj) { |
| 572 |
fieldObj.clearDelayedChange(); |
| 573 |
} |
| 574 |
}; |
| 575 |
|
| 576 |
|
| 577 |
/** |
| 578 |
* Returns the goog.editor.plugins.UndoRedo.CursorPosition_ for the current |
| 579 |
* selection in the given Field. |
| 580 |
* @param {goog.editor.Field} fieldObj The field object. |
| 581 |
* @return {goog.editor.plugins.UndoRedo.CursorPosition_} The CursorPosition_ or |
| 582 |
* null if there is no valid selection. |
| 583 |
* @private |
| 584 |
*/ |
| 585 |
goog.editor.plugins.UndoRedo.prototype.getCursorPosition_ = function(fieldObj) { |
| 586 |
var cursorPos = new goog.editor.plugins.UndoRedo.CursorPosition_(fieldObj); |
| 587 |
if (!cursorPos.isValid()) { |
| 588 |
return null; |
| 589 |
} |
| 590 |
return cursorPos; |
| 591 |
}; |
| 592 |
|
| 593 |
|
| 594 |
/** |
| 595 |
* Helper method for saving state. |
| 596 |
* @param {goog.editor.Field} fieldObj The field object. |
| 597 |
* @private |
| 598 |
*/ |
| 599 |
goog.editor.plugins.UndoRedo.prototype.updateCurrentState_ = function( |
| 600 |
fieldObj) { |
| 601 |
var fieldHashCode = fieldObj.getHashCode(); |
| 602 |
// We specifically grab the raw innerHTML of the field here as that's what |
| 603 |
// we would set on the field in the case of an undo/redo operation. There's |
| 604 |
// no need to clean/unclean the contents in either direction. In the case of |
| 605 |
// lorem ipsum being used, we want to capture the effective state (empty, no |
| 606 |
// cursor position) rather than capturing the lorem html. |
| 607 |
var content, cursorPos; |
| 608 |
if (fieldObj.queryCommandValue(goog.editor.Command.USING_LOREM)) { |
| 609 |
content = ''; |
| 610 |
cursorPos = null; |
| 611 |
} else { |
| 612 |
content = fieldObj.getElement().innerHTML; |
| 613 |
cursorPos = this.getCursorPosition_(fieldObj); |
| 614 |
} |
| 615 |
|
| 616 |
var currentState = this.currentStates_[fieldHashCode]; |
| 617 |
if (currentState) { |
| 618 |
// Don't create states if the content hasn't changed (spurious |
| 619 |
// delayed change). This can happen when lorem is cleared, for example. |
| 620 |
if (currentState.undoContent_ == content) { |
| 621 |
return; |
| 622 |
} else if (content == '' || currentState.undoContent_ == '') { |
| 623 |
// If lorem ipsum is on we say the contents are the empty string. However, |
| 624 |
// for an empty text shape with focus, the empty contents might not be |
| 625 |
// the same, depending on plugins. We want these two empty states to be |
| 626 |
// considered identical because to the user they are indistinguishable, |
| 627 |
// so we use fieldObj.getInjectableContents to map between them. |
| 628 |
// We cannot use getInjectableContents when first creating the undo |
| 629 |
// content for a field with lorem, because on enable when this is first |
| 630 |
// called we can't guarantee plugin registration order, so the |
| 631 |
// injectableContents at that time might not match the final |
| 632 |
// injectableContents. |
| 633 |
var emptyContents = fieldObj.getInjectableContents('', {}); |
| 634 |
if (content == emptyContents && currentState.undoContent_ == '' || |
| 635 |
currentState.undoContent_ == emptyContents && content == '') { |
| 636 |
return; |
| 637 |
} |
| 638 |
} |
| 639 |
|
| 640 |
currentState.setRedoState(content, cursorPos); |
| 641 |
this.undoManager_.addState(currentState); |
| 642 |
} |
| 643 |
|
| 644 |
this.currentStates_[fieldHashCode] = |
| 645 |
new goog.editor.plugins.UndoRedo.UndoState_( |
| 646 |
fieldHashCode, content, cursorPos, this.boundRestoreState_); |
| 647 |
}; |
| 648 |
|
| 649 |
|
| 650 |
|
| 651 |
/** |
| 652 |
* This object encapsulates the state of an editable field. |
| 653 |
* |
| 654 |
* @param {string} fieldHashCode String the id of the field we're saving the |
| 655 |
* content of. |
| 656 |
* @param {string} content String the actual text we're saving. |
| 657 |
* @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition |
| 658 |
* CursorPosLite object for the cursor position in the field. |
| 659 |
* @param {Function} restore The function used to restore editable field state. |
| 660 |
* @private |
| 661 |
* @constructor |
| 662 |
* @extends {goog.editor.plugins.UndoRedoState} |
| 663 |
*/ |
| 664 |
goog.editor.plugins.UndoRedo.UndoState_ = function( |
| 665 |
fieldHashCode, content, cursorPosition, restore) { |
| 666 |
goog.editor.plugins.UndoRedoState.call(this, true); |
| 667 |
|
| 668 |
/** |
| 669 |
* The hash code for the field whose content is being saved. |
| 670 |
* @type {string} |
| 671 |
*/ |
| 672 |
this.fieldHashCode = fieldHashCode; |
| 673 |
|
| 674 |
/** |
| 675 |
* The bound copy of {@code goog.editor.plugins.UndoRedo.restoreState} used by |
| 676 |
* this state. |
| 677 |
* @type {Function} |
| 678 |
* @private |
| 679 |
*/ |
| 680 |
this.restore_ = restore; |
| 681 |
|
| 682 |
this.setUndoState(content, cursorPosition); |
| 683 |
}; |
| 684 |
goog.inherits( |
| 685 |
goog.editor.plugins.UndoRedo.UndoState_, goog.editor.plugins.UndoRedoState); |
| 686 |
|
| 687 |
|
| 688 |
/** |
| 689 |
* The content to restore on undo. |
| 690 |
* @type {string} |
| 691 |
* @private |
| 692 |
*/ |
| 693 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.undoContent_; |
| 694 |
|
| 695 |
|
| 696 |
/** |
| 697 |
* The cursor position to restore on undo. |
| 698 |
* @type {goog.editor.plugins.UndoRedo.CursorPosition_?} |
| 699 |
* @private |
| 700 |
*/ |
| 701 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.undoCursorPosition_; |
| 702 |
|
| 703 |
|
| 704 |
/** |
| 705 |
* The content to restore on redo, undefined until the state is pushed onto the |
| 706 |
* undo stack. |
| 707 |
* @type {string|undefined} |
| 708 |
* @private |
| 709 |
*/ |
| 710 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.redoContent_; |
| 711 |
|
| 712 |
|
| 713 |
/** |
| 714 |
* The cursor position to restore on redo, undefined until the state is pushed |
| 715 |
* onto the undo stack. |
| 716 |
* @type {goog.editor.plugins.UndoRedo.CursorPosition_|null|undefined} |
| 717 |
* @private |
| 718 |
*/ |
| 719 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.redoCursorPosition_; |
| 720 |
|
| 721 |
|
| 722 |
/** |
| 723 |
* Performs the undo operation represented by this state. |
| 724 |
* @override |
| 725 |
*/ |
| 726 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.undo = function() { |
| 727 |
this.restore_(this, this.undoContent_, this.undoCursorPosition_); |
| 728 |
}; |
| 729 |
|
| 730 |
|
| 731 |
/** |
| 732 |
* Performs the redo operation represented by this state. |
| 733 |
* @override |
| 734 |
*/ |
| 735 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.redo = function() { |
| 736 |
this.restore_(this, this.redoContent_, this.redoCursorPosition_); |
| 737 |
}; |
| 738 |
|
| 739 |
|
| 740 |
/** |
| 741 |
* Updates the undo portion of this state. Should only be used to update the |
| 742 |
* current state of an editable field, which is not yet on the undo stack after |
| 743 |
* an undo or redo operation. You should never be modifying states on the stack! |
| 744 |
* @param {string} content The current content. |
| 745 |
* @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition |
| 746 |
* The current cursor position. |
| 747 |
*/ |
| 748 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.setUndoState = function( |
| 749 |
content, cursorPosition) { |
| 750 |
this.undoContent_ = content; |
| 751 |
this.undoCursorPosition_ = cursorPosition; |
| 752 |
}; |
| 753 |
|
| 754 |
|
| 755 |
/** |
| 756 |
* Adds redo information to this state. This method should be called before the |
| 757 |
* state is added onto the undo stack. |
| 758 |
* |
| 759 |
* @param {string} content The content to restore on a redo. |
| 760 |
* @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition |
| 761 |
* The cursor position to restore on a redo. |
| 762 |
*/ |
| 763 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.setRedoState = function( |
| 764 |
content, cursorPosition) { |
| 765 |
this.redoContent_ = content; |
| 766 |
this.redoCursorPosition_ = cursorPosition; |
| 767 |
}; |
| 768 |
|
| 769 |
|
| 770 |
/** |
| 771 |
* Checks if the *contents* of two |
| 772 |
* {@code goog.editor.plugins.UndoRedo.UndoState_}s are the same. We don't |
| 773 |
* bother checking the cursor position (that's not something we'd want to save |
| 774 |
* anyway). |
| 775 |
* @param {goog.editor.plugins.UndoRedoState} rhs The state to compare. |
| 776 |
* @return {boolean} Whether the contents are the same. |
| 777 |
* @override |
| 778 |
*/ |
| 779 |
goog.editor.plugins.UndoRedo.UndoState_.prototype.equals = function(rhs) { |
| 780 |
return this.fieldHashCode == rhs.fieldHashCode && |
| 781 |
this.undoContent_ == rhs.undoContent_ && |
| 782 |
this.redoContent_ == rhs.redoContent_; |
| 783 |
}; |
| 784 |
|
| 785 |
|
| 786 |
|
| 787 |
/** |
| 788 |
* Stores the state of the selection in a way the survives DOM modifications |
| 789 |
* that don't modify the user-interactable content (e.g. making something bold |
| 790 |
* vs. typing a character). |
| 791 |
* |
| 792 |
* TODO(user): Completely get rid of this and use goog.dom.SavedCaretRange. |
| 793 |
* |
| 794 |
* @param {goog.editor.Field} field The field the selection is in. |
| 795 |
* @private |
| 796 |
* @constructor |
| 797 |
*/ |
| 798 |
goog.editor.plugins.UndoRedo.CursorPosition_ = function(field) { |
| 799 |
this.field_ = field; |
| 800 |
|
| 801 |
var win = field.getEditableDomHelper().getWindow(); |
| 802 |
var range = field.getRange(); |
| 803 |
var isValidRange = |
| 804 |
!!range && range.isRangeInDocument() && range.getWindow() == win; |
| 805 |
range = isValidRange ? range : null; |
| 806 |
|
| 807 |
if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { |
| 808 |
this.initW3C_(range); |
| 809 |
} else if (goog.editor.BrowserFeature.HAS_IE_RANGES) { |
| 810 |
this.initIE_(range); |
| 811 |
} |
| 812 |
}; |
| 813 |
|
| 814 |
|
| 815 |
/** |
| 816 |
* The standards compliant version keeps a list of childNode offsets. |
| 817 |
* @param {goog.dom.AbstractRange?} range The range to save. |
| 818 |
* @private |
| 819 |
*/ |
| 820 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initW3C_ = function( |
| 821 |
range) { |
| 822 |
this.isValid_ = false; |
| 823 |
|
| 824 |
// TODO: Check if the range is in the field before trying to save it |
| 825 |
// for FF 3 contentEditable. |
| 826 |
if (!range) { |
| 827 |
return; |
| 828 |
} |
| 829 |
|
| 830 |
var anchorNode = range.getAnchorNode(); |
| 831 |
var focusNode = range.getFocusNode(); |
| 832 |
if (!anchorNode || !focusNode) { |
| 833 |
return; |
| 834 |
} |
| 835 |
|
| 836 |
var anchorOffset = range.getAnchorOffset(); |
| 837 |
var anchor = new goog.dom.NodeOffset(anchorNode, this.field_.getElement()); |
| 838 |
|
| 839 |
var focusOffset = range.getFocusOffset(); |
| 840 |
var focus = new goog.dom.NodeOffset(focusNode, this.field_.getElement()); |
| 841 |
|
| 842 |
// Test range direction. |
| 843 |
if (range.isReversed()) { |
| 844 |
this.startOffset_ = focus; |
| 845 |
this.startChildOffset_ = focusOffset; |
| 846 |
this.endOffset_ = anchor; |
| 847 |
this.endChildOffset_ = anchorOffset; |
| 848 |
} else { |
| 849 |
this.startOffset_ = anchor; |
| 850 |
this.startChildOffset_ = anchorOffset; |
| 851 |
this.endOffset_ = focus; |
| 852 |
this.endChildOffset_ = focusOffset; |
| 853 |
} |
| 854 |
|
| 855 |
this.isValid_ = true; |
| 856 |
}; |
| 857 |
|
| 858 |
|
| 859 |
/** |
| 860 |
* In IE, we just keep track of the text offset (number of characters). |
| 861 |
* @param {goog.dom.AbstractRange?} range The range to save. |
| 862 |
* @private |
| 863 |
*/ |
| 864 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initIE_ = function( |
| 865 |
range) { |
| 866 |
this.isValid_ = false; |
| 867 |
|
| 868 |
if (!range) { |
| 869 |
return; |
| 870 |
} |
| 871 |
|
| 872 |
var ieRange = range.getTextRange(0).getBrowserRangeObject(); |
| 873 |
|
| 874 |
if (!goog.dom.contains(this.field_.getElement(), ieRange.parentElement())) { |
| 875 |
return; |
| 876 |
} |
| 877 |
|
| 878 |
// Create a range that encompasses the contentEditable region to serve |
| 879 |
// as a reference to form ranges below. |
| 880 |
var contentEditableRange = |
| 881 |
this.field_.getEditableDomHelper().getDocument().body.createTextRange(); |
| 882 |
contentEditableRange.moveToElementText(this.field_.getElement()); |
| 883 |
|
| 884 |
// startMarker is a range from the start of the contentEditable node to the |
| 885 |
// start of the current selection. |
| 886 |
var startMarker = ieRange.duplicate(); |
| 887 |
startMarker.collapse(true); |
| 888 |
startMarker.setEndPoint('StartToStart', contentEditableRange); |
| 889 |
this.startOffset_ = |
| 890 |
goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_( |
| 891 |
startMarker); |
| 892 |
|
| 893 |
// endMarker is a range from the start of the contentEditable node to the |
| 894 |
// end of the current selection. |
| 895 |
var endMarker = ieRange.duplicate(); |
| 896 |
endMarker.setEndPoint('StartToStart', contentEditableRange); |
| 897 |
this.endOffset_ = |
| 898 |
goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_( |
| 899 |
endMarker); |
| 900 |
|
| 901 |
this.isValid_ = true; |
| 902 |
}; |
| 903 |
|
| 904 |
|
| 905 |
/** |
| 906 |
* @return {boolean} Whether this object is valid. |
| 907 |
*/ |
| 908 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.isValid = function() { |
| 909 |
return this.isValid_; |
| 910 |
}; |
| 911 |
|
| 912 |
|
| 913 |
/** |
| 914 |
* @return {string} A string representation of this object. |
| 915 |
* @override |
| 916 |
*/ |
| 917 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.toString = function() { |
| 918 |
if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { |
| 919 |
return 'W3C:' + this.startOffset_.toString() + '\n' + |
| 920 |
this.startChildOffset_ + ':' + this.endOffset_.toString() + '\n' + |
| 921 |
this.endChildOffset_; |
| 922 |
} |
| 923 |
return 'IE:' + this.startOffset_ + ',' + this.endOffset_; |
| 924 |
}; |
| 925 |
|
| 926 |
|
| 927 |
/** |
| 928 |
* Makes the browser's selection match the cursor position. |
| 929 |
*/ |
| 930 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.select = function() { |
| 931 |
var range = this.getRange_(this.field_.getElement()); |
| 932 |
if (range) { |
| 933 |
if (goog.editor.BrowserFeature.HAS_IE_RANGES) { |
| 934 |
this.field_.getElement().focus(); |
| 935 |
} |
| 936 |
goog.dom.Range.createFromBrowserRange(range).select(); |
| 937 |
} |
| 938 |
}; |
| 939 |
|
| 940 |
|
| 941 |
/** |
| 942 |
* Get the range that encompases the the cursor position relative to a given |
| 943 |
* base node. |
| 944 |
* @param {Element} baseNode The node to get the cursor position relative to. |
| 945 |
* @return {Range|TextRange|null} The browser range for this position. |
| 946 |
* @private |
| 947 |
*/ |
| 948 |
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.getRange_ = function( |
| 949 |
baseNode) { |
| 950 |
if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { |
| 951 |
var startNode = this.startOffset_.findTargetNode(baseNode); |
| 952 |
var endNode = this.endOffset_.findTargetNode(baseNode); |
| 953 |
if (!startNode || !endNode) { |
| 954 |
return null; |
| 955 |
} |
| 956 |
|
| 957 |
// Create range. |
| 958 |
return /** @type {Range} */ ( |
| 959 |
goog.dom.Range |
| 960 |
.createFromNodes( |
| 961 |
startNode, this.startChildOffset_, endNode, |
| 962 |
this.endChildOffset_) |
| 963 |
.getBrowserRangeObject()); |
| 964 |
} |
| 965 |
|
| 966 |
// Create a collapsed selection at the start of the contentEditable region, |
| 967 |
// which the offsets were calculated relative to before. Note that we force |
| 968 |
// a text range here so we can use moveToElementText. |
| 969 |
var sel = baseNode.ownerDocument.body.createTextRange(); |
| 970 |
sel.moveToElementText(baseNode); |
| 971 |
sel.collapse(true); |
| 972 |
sel.moveEnd('character', this.endOffset_); |
| 973 |
sel.moveStart('character', this.startOffset_); |
| 974 |
return sel; |
| 975 |
}; |
| 976 |
|
| 977 |
|
| 978 |
/** |
| 979 |
* Compute the number of characters to the end of the range in IE. |
| 980 |
* @param {TextRange} range The range to compute an offset for. |
| 981 |
* @return {number} The number of characters to the end of the range. |
| 982 |
* @private |
| 983 |
*/ |
| 984 |
goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_ = function( |
| 985 |
range) { |
| 986 |
var testRange = range.duplicate(); |
| 987 |
|
| 988 |
// The number of offset characters is a little off depending on |
| 989 |
// what type of block elements happen to be between the start of the |
| 990 |
// textedit and the cursor position. We fudge the offset until the |
| 991 |
// two ranges match. |
| 992 |
var text = range.text; |
| 993 |
var guess = text.length; |
| 994 |
|
| 995 |
testRange.collapse(true); |
| 996 |
testRange.moveEnd('character', guess); |
| 997 |
|
| 998 |
// Adjust the range until the end points match. This doesn't quite |
| 999 |
// work if we're at the end of the field so we give up after a few |
| 1000 |
// iterations. |
| 1001 |
var diff; |
| 1002 |
var numTries = 10; |
| 1003 |
while (diff = testRange.compareEndPoints('EndToEnd', range)) { |
| 1004 |
guess -= diff; |
| 1005 |
testRange.moveEnd('character', -diff); |
| 1006 |
--numTries; |
| 1007 |
if (0 == numTries) { |
| 1008 |
break; |
| 1009 |
} |
| 1010 |
} |
| 1011 |
// When we set innerHTML, blank lines become a single space, causing |
| 1012 |
// the cursor position to be off by one. So we accommodate for blank |
| 1013 |
// lines. |
| 1014 |
var offset = 0; |
| 1015 |
var pos = text.indexOf('\n\r'); |
| 1016 |
while (pos != -1) { |
| 1017 |
++offset; |
| 1018 |
pos = text.indexOf('\n\r', pos + 1); |
| 1019 |
} |
| 1020 |
return guess + offset; |
| 1021 |
}; |