Undo the last change in the stack.

@return {Boolean} returns true if a change was un-done.

@see orion.editor.UndoStack#redo
@see orion.editor.UndoStack#canUndo
554631
function() {
			this._commitUndo();
			var change, result = false;
			this._ignoreUndo = true;
			do {
				if (this.index <= 0) {
					break;
				}
				change = this.stack[--this.index];
			} while (!(result = change.undo(this.view, true)));
			this._ignoreUndo = false;
			return result;
		}
44804
function() {
    // Make sure pending changes have been committed.
    this.commit();

    if (this.history.length) {
      // Take the top diff from the history, apply it, and store its
      // shadow in the redo history.
      var item = this.history.pop();
      this.redoHistory.push(this.updateTo(item, "applyChain"));
      this.notifyEnvironment();
      return this.chainNode(item);
    }
  }
628673
public Command undoLast() {
        Command lastCommand = undoStack.pop();
        redoStack.push(lastCommand);
        lastCommand.undo();
        return lastCommand;
    }
284511
function(){
		if(!this.enableUndo){ return false;}
		var opes = this.history[this.position-1];
		this.reqReset = this.checkReqReset(opes);
		this.preproc();
		this.undoCore();
		this.postproc();
		return this.enableUndo;
	}
924429
def can_revert(self):
        

        if self.can_publish:
            with self.published_context():
                return self.count(Q._uid == self._uid) > 0

        return False
85086
def undo(self):
        '''  '''
        if self.canundo():
            undoable = self._undos.pop()
            with self._pausereceiver():
                try:
                    undoable.undo()
                except:
                    self.clear()
                    raise
                else:
                    self._redos.append(undoable)
            self.undocallback()
673361
function(enable, d) {
      if (!!enable) {
        isExpired = false;
        startMutation(d);
      } else {
        isExpired = true;
        stopMutation(d);
      }
      isEnabled = !!enable;
    }
1293396
function () {
          var level;

          if (self.typing) {
            self.add();
            self.typing = false;
            setTyping(false);
          }

          if (index > 0) {
            level = data[--index];
            Levels.applyToEditor(editor, level, true);
            setDirty(true);
            editor.fire('undo', { level: level });
          }

          return level;
        }
494231
function undoIOSfix() {
  if (hasClass(document.body, swalClasses.iosfix)) {
    var offset = parseInt(document.body.style.top, 10);
    removeClass(document.body, swalClasses.iosfix);
    document.body.style.top = '';
    document.body.scrollTop = offset * -1;
  }
}
574246
function() {
    this.commit();
    if (this.redoHistory.length) {
      // The inverse of undo, basically.
      var item = this.redoHistory.pop();
      this.addUndoLevel(this.updateTo(item, "applyChain"));
      this.notifyEnvironment();
      return this.chainNode(item);
    }
  }
620536
function () {
        if (!this.finished && this._canceller) {
            var error = this._canceller();
            if (!(error instanceof Error)) {
                error = new Error(error);
            }
            return this.emitError(error);
        }
        return false;
    }
632573
function()
		{
			if ( this.undoable() )
			{
				this.save( true );

				var image = this.getNextImage( true );
				if ( image )
					return this.restoreImage( image ), true;
			}

			return false;
		}
1047673
public synchronized boolean remove(Layer layer, boolean redraw) {
        checkIsNull(layer);
        if (this.layersList.remove(layer)) {
            layer.unassign();
            if (redraw) {
                this.redrawer.redrawLayers();
            }
            return true;
        }
        return false;
    }
609443
function UndoManager (maxItems) {
    this.maxItems  = maxItems || 50;
    this.state = NORMAL_STATE;
    this.dontCompose = false;
    this.undoStack = [];
    this.redoStack = [];
  }
1021877
public void redo() {

        if (!m_redo.isEmpty()) {
            m_undo.push(m_current);
            m_current = m_redo.pop();
            changeEntityContentValues(
                m_current.getEntityData(),
                m_current.getEntityId(),
                m_current.getAttributeName(),
                m_current.getValueIndex(),
                m_current.getType());
            fireStateChange();
        }
    }
1195651
function clearOldChoices () {
  const oldChoices = choiceDiv.querySelector('.choices.current');
  return new Promise(resolve => {
    oldChoices.addEventListener('transitionend', () => {
      oldChoices.remove();
      resolve();
    });
    oldChoices.className = "choices old";
  })
}
506006
def redo(self):
        
        self.undo_manager.redo()
        self.notify_observers()
        logging.debug('undo_manager redo stack={}'.format(self.undo_manager._redo_stack))