void ActionStack::undo() {
	assert(canUndo());
	if (!canUndo()) return;
	Action* action = undo_actions.back();
	action->perform(true);
	tellListeners(*action, true);
	// move to redo stack
	undo_actions.pop_back();
	redo_actions.push_back(action);
	last_was_add = false;
}

void UndoStack::undo() throw (Exception)
{
    if ((!canUndo()) || (mCommandActive)) // if a command is active, undo() is not allowed
        return;

    mCommands[mCurrentIndex-1]->undo(); // throws an exception on error
    mCurrentIndex--;

    // emit signals
    emit undoTextChanged(getUndoText());
    emit redoTextChanged(getRedoText());
    emit canUndoChanged(canUndo());
    emit canRedoChanged(canRedo());
    emit cleanChanged(isClean());
}

void ShaderEditor::onGUIMenu()
{
	if(ImGui::BeginMenuBar())
	{
		if(ImGui::BeginMenu("File"))
		{
			if (ImGui::MenuItem("New")) newGraph();
			if (ImGui::MenuItem("Open")) load();
			if (ImGui::MenuItem("Save", nullptr, false, m_path.isValid())) save(m_path.c_str());
			if (ImGui::MenuItem("Save as"))
			{
				getSavePath();
				if (m_path.isValid()) save(m_path.c_str());
			}
			ImGui::EndMenu();
		}
		if (ImGui::BeginMenu("Edit"))
		{
			if (ImGui::MenuItem("Undo", nullptr, false, canUndo())) undo();
			if (ImGui::MenuItem("Redo", nullptr, false, canRedo())) redo();
			ImGui::EndMenu();
		}
		if (ImGui::MenuItem("Generate", nullptr, false, m_path.isValid()))
		{
			generate(m_path.c_str(), ShaderType::VERTEX);
			generate(m_path.c_str(), ShaderType::FRAGMENT);
			generateMain(m_path.c_str());
		}

		ImGui::EndMenuBar();
	}
}

void EditorClientEfl::undo()
{
    if (canUndo()) {
        RefPtr<WebCore::UndoStep> step = undoStack.takeFirst();
        step->unapply();
    }
}

//-----------------------------------------------------------------------------
// undoAction()
//-----------------------------------------------------------------------------
BOOL LLUndoBuffer::undoAction()
{
	if (!canUndo())
	{
		return FALSE;
	}

	S32 prevAction = (mNextAction + mNumActions - 1) % mNumActions;

	while(mActions[prevAction]->mClusterID == mOperationID)
	{
		// go ahead and decrement action index
		mNextAction = prevAction;

		// undo this action
		mActions[mNextAction]->undo();

		// we're at the first action, so we don't know if we've actually undid everything
		if (mNextAction == mFirstAction)
		{
			mOperationID--;
			return FALSE;
		}

		// do wrap-around of index, but avoid negative numbers for modulo operator
		prevAction = (mNextAction + mNumActions - 1) % mNumActions;
	}

	mOperationID--;

	return TRUE;
}

void Task::undo()
{
  if (canUndo()) {
    (*_currentStep)->undo();
    _currentStep++;
  }
}

long
GNEUndoList::p_onUpdUndo(FXObject* sender, FXSelector, void*) {
    bool enable = canUndo() && !hasCommandGroup();
    sender->handle(this, enable ? FXSEL(SEL_COMMAND, FXWindow::ID_ENABLE) : FXSEL(SEL_COMMAND, FXWindow::ID_DISABLE), 0);
    FXString caption = undoName();
    if (hasCommandGroup()) {
        caption = ("Cannot Undo in the middle of " + myCommandGroups.top()->getDescription()).c_str();
    } else if (!canUndo()) {
        caption = "Undo";
    }
    // only set caption on menu item
    if (dynamic_cast<FXMenuCommand*>(sender)) {
        sender->handle(this, FXSEL(SEL_COMMAND, FXMenuCaption::ID_SETSTRINGVALUE), (void*)&caption);
    }
    return 1;
}

QString UndoStack::getUndoText() const noexcept
{
    if (canUndo())
        return QString(tr("Undo: %1")).arg(mCommands[mCurrentIndex-1]->getText());
    else
        return tr("Undo");
}

void KUndo2QStack::setIndex(int idx, bool clean)
{
    bool was_clean = m_index == m_clean_index;
    if (m_lastMergedIndex <= idx) {
        m_lastMergedSetCount = idx - m_lastMergedIndex;

    } else {
        m_lastMergedSetCount = 1;
        m_lastMergedIndex = idx-1;
    }
    if(idx == 0){
        m_lastMergedSetCount = 0;
        m_lastMergedIndex = 0;
    }
    if (idx != m_index) {
        m_index = idx;
        emit indexChanged(m_index);
        emit canUndoChanged(canUndo());
        emit undoTextChanged(undoText());
        emit canRedoChanged(canRedo());
        emit redoTextChanged(redoText());
    }

    if (clean)
        m_clean_index = m_index;

    bool is_clean = m_index == m_clean_index;
    if (is_clean != was_clean)
        emit cleanChanged(is_clean);
}

void Timeline::undo()
{
  if (canUndo()) {
    (*_currentTask)->undo();
    _currentTask++;
  }
}

String ActionStack::undoName() const {
	if (canUndo()) {
		return _(" ") + capitalize(undo_actions.back()->getName(true));
	} else {
		return wxEmptyString;
	}
}

void GameMovesRegistry::clear()
{
    m_performedCmnds.clear();
    m_undoneCmnds.clear();

    emit countChanged(count());
    emit canRedoChanged(canRedo());
    emit canUndoChanged(canUndo());
}

void GameMovesRegistry::failExecution()
{
    m_performedCmnds.clear();
    m_undoneCmnds.clear();

    emit canRedoChanged(canRedo());
    emit canUndoChanged(canUndo());
    emit executionFailed();
}

void KDocumentTextBuffer::updateUndoRedoActions()
{
    emit canUndo(dynamic_cast<QInfinity::AdoptedSession*>(m_session)->canUndo(
        *dynamic_cast<QInfinity::AdoptedUser*>(m_user.data()))
    );
    emit canRedo(dynamic_cast<QInfinity::AdoptedSession*>(m_session)->canRedo(
        *dynamic_cast<QInfinity::AdoptedUser*>(m_user.data()))
    );
}

void EditorClient::undo()
{
    if (canUndo()) {
        RefPtr<WebCore::EditCommand> command(*(--undoStack.end()));
        undoStack.remove(--undoStack.end());
        // unapply will call us back to push this command onto the redo stack.
        command->unapply();
    }
}

void UndoStack::undo()
{
    if (canUndo()) {
        UndoStepStack::iterator back = --m_undoStack.end();
        RefPtr<UndoStep> step(back->get());
        m_undoStack.remove(back);
        step->unapply();
        // unapply will call us back to push this command onto the redo stack.
    }
}

CommandAdd::~CommandAdd() {
  if (m_node_struct) {
    if (canUndo()) {
      m_node_struct->m_graphic_node = nullptr;
      m_node_struct->m_node = nullptr;
    }

    delete m_node_struct;
  }
}

void EditorClientImpl::undo()
{
    if (canUndo()) {
        EditCommandStack::iterator back = --m_undoStack.end();
        RefPtr<EditCommand> command(*back);
        m_undoStack.remove(back);
        command->unapply();
        // unapply will call us back to push this command onto the redo stack.
    }
}

void AbstractUndoableEdit::undo(void)
{
	if(canUndo())
	{
		_HasBeenDone = false;
	}
	else
	{
		throw CannotUndoException();
	}
}

bool Recorder::redo()
{
    bool couldUndo = canUndo();
    bool couldRedo = canRedo();
    if(canRedo())
    {
        actions_.at(nextUndo_ + 1)->redo(model_);
        ++nextUndo_;
        if(couldUndo != canUndo())
        {
            emit undoChanged(canUndo());
        }
        if(couldRedo != canRedo())
        {
            emit redoChanged(canRedo());
        }
        return true;
    }
    return false;
}