gecko/browser/devtools/shared/Undo.jsm

208 lines
4.9 KiB
JavaScript
Raw Normal View History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
const Cu = Components.utils;
this.EXPORTED_SYMBOLS = ["UndoStack"];
/**
* A simple undo stack manager.
*
* Actions are added along with the necessary code to
* reverse the action.
*
* @param function aChange Called whenever the size or position
* of the undo stack changes, to use for updating undo-related
* UI.
* @param integer aMaxUndo Maximum number of undo steps.
* defaults to 50.
*/
this.UndoStack = function UndoStack(aMaxUndo)
{
this.maxUndo = aMaxUndo || 50;
this._stack = [];
}
UndoStack.prototype = {
// Current index into the undo stack. Is positioned after the last
// currently-applied change.
_index: 0,
// The current batch depth (see startBatch() for details)
_batchDepth: 0,
destroy: function Undo_destroy()
{
this.uninstallController();
delete this._stack;
},
/**
* Start a collection of related changes. Changes will be batched
* together into one undo/redo item until endBatch() is called.
*
* Batches can be nested, in which case the outer batch will contain
* all items from the inner batches. This allows larger user
* actions made up of a collection of smaller actions to be
* undone as a single action.
*/
startBatch: function Undo_startBatch()
{
if (this._batchDepth++ === 0) {
this._batch = [];
}
},
/**
* End a batch of related changes, performing its action and adding
* it to the undo stack.
*/
endBatch: function Undo_endBatch()
{
if (--this._batchDepth > 0) {
return;
}
// Cut off the end of the undo stack at the current index,
// and the beginning to prevent a stack larger than maxUndo.
let start = Math.max((this._index + 1) - this.maxUndo, 0);
this._stack = this._stack.slice(start, this._index);
let batch = this._batch;
delete this._batch;
let entry = {
do: function() {
for (let item of batch) {
item.do();
}
},
undo: function() {
for (let i = batch.length - 1; i >= 0; i--) {
batch[i].undo();
}
}
};
this._stack.push(entry);
this._index = this._stack.length;
entry.do();
this._change();
},
/**
* Perform an action, adding it to the undo stack.
*
* @param function aDo Called to perform the action.
* @param function aUndo Called to reverse the action.
*/
do: function Undo_do(aDo, aUndo) {
this.startBatch();
this._batch.push({ do: aDo, undo: aUndo });
this.endBatch();
},
/*
* Returns true if undo() will do anything.
*/
canUndo: function Undo_canUndo()
{
return this._index > 0;
},
/**
* Undo the top of the undo stack.
*
* @return true if an action was undone.
*/
undo: function Undo_canUndo()
{
if (!this.canUndo()) {
return false;
}
this._stack[--this._index].undo();
this._change();
return true;
},
/**
* Returns true if redo() will do anything.
*/
canRedo: function Undo_canRedo()
{
return this._stack.length > this._index;
},
/**
* Redo the most recently undone action.
*
* @return true if an action was redone.
*/
redo: function Undo_canRedo()
{
if (!this.canRedo()) {
return false;
}
this._stack[this._index++].do();
this._change();
return true;
},
_change: function Undo__change()
{
if (this._controllerWindow) {
this._controllerWindow.goUpdateCommand("cmd_undo");
this._controllerWindow.goUpdateCommand("cmd_redo");
}
},
/**
* ViewController implementation for undo/redo.
*/
/**
* Install this object as a command controller.
*/
installController: function Undo_installController(aControllerWindow)
{
this._controllerWindow = aControllerWindow;
aControllerWindow.controllers.appendController(this);
},
/**
* Uninstall this object from the command controller.
*/
uninstallController: function Undo_uninstallController()
{
if (!this._controllerWindow) {
return;
}
this._controllerWindow.controllers.removeController(this);
},
supportsCommand: function Undo_supportsCommand(aCommand)
{
return (aCommand == "cmd_undo" ||
aCommand == "cmd_redo");
},
isCommandEnabled: function Undo_isCommandEnabled(aCommand)
{
switch(aCommand) {
case "cmd_undo": return this.canUndo();
case "cmd_redo": return this.canRedo();
};
return false;
},
doCommand: function Undo_doCommand(aCommand)
{
switch(aCommand) {
case "cmd_undo": return this.undo();
case "cmd_redo": return this.redo();
}
},
onEvent: function Undo_onEvent(aEvent) {},
}