void KUndo2QStack::purgeRedoState()
{
bool macro = !m_macro_stack.isEmpty();
if (macro) return;
bool redoStateChanged = false;
bool cleanStateChanged = false;
while (m_index < m_command_list.size()) {
delete m_command_list.takeLast();
redoStateChanged = true;
}
if (m_clean_index > m_index) {
m_clean_index = -1; // we've deleted the clean state
cleanStateChanged = true;
}
if (redoStateChanged) {
emit canRedoChanged(canRedo());
emit redoTextChanged(redoText());
}
if (cleanStateChanged) {
emit cleanChanged(isClean());
}
}
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);
}
QAction *KUndo2QStack::createRedoAction(QObject *parent) const
{
KUndo2Action *result = new KUndo2Action(i18n("Redo %1"), i18nc("Default text for redo action", "Redo"), parent);
result->setEnabled(canRedo());
result->setPrefixedText(redoText());
connect(this, SIGNAL(canRedoChanged(bool)),
result, SLOT(setEnabled(bool)));
connect(this, SIGNAL(redoTextChanged(QString)),
result, SLOT(setPrefixedText(QString)));
connect(result, SIGNAL(triggered()), this, SLOT(redo()));
return result;
}
QAction *QUndoStack::createRedoAction(QObject *parent, const QString &prefix) const
{
QString pref = prefix.isEmpty() ? tr("Redo") : prefix;
QUndoAction *result = new QUndoAction(pref, parent);
result->setEnabled(canRedo());
result->setPrefixedText(redoText());
connect(this, SIGNAL(canRedoChanged(bool)),
result, SLOT(setEnabled(bool)));
connect(this, SIGNAL(redoTextChanged(QString)),
result, SLOT(setPrefixedText(QString)));
connect(result, SIGNAL(triggered()), this, SLOT(redo()));
return result;
}
QAction *QUndoStack::createRedoAction(QObject *parent, const QString &prefix) const
{
QUndoAction *result = new QUndoAction(prefix, parent);
if (prefix.isEmpty())
result->setTextFormat(tr("Redo %1"), tr("Redo", "Default text for redo action"));
result->setEnabled(canRedo());
result->setPrefixedText(redoText());
connect(this, SIGNAL(canRedoChanged(bool)),
result, SLOT(setEnabled(bool)));
connect(this, SIGNAL(redoTextChanged(QString)),
result, SLOT(setPrefixedText(QString)));
connect(result, SIGNAL(triggered()), this, SLOT(redo()));
return result;
}
void QUndoStack::push(QUndoCommand *cmd)
{
Q_D(QUndoStack);
cmd->redo();
bool macro = !d->macro_stack.isEmpty();
QUndoCommand *cur = 0;
if (macro) {
QUndoCommand *macro_cmd = d->macro_stack.last();
if (!macro_cmd->d->child_list.isEmpty())
cur = macro_cmd->d->child_list.last();
} else {
if (d->index > 0)
cur = d->command_list.at(d->index - 1);
while (d->index < d->command_list.size())
delete d->command_list.takeLast();
if (d->clean_index > d->index)
d->clean_index = -1; // we've deleted the clean state
}
bool try_merge = cur != 0
&& cur->id() != -1
&& cur->id() == cmd->id()
&& (macro || d->index != d->clean_index);
if (try_merge && cur->mergeWith(cmd)) {
delete cmd;
if (!macro) {
emit indexChanged(d->index);
emit canUndoChanged(canUndo());
emit undoTextChanged(undoText());
emit canRedoChanged(canRedo());
emit redoTextChanged(redoText());
}
} else {
if (macro) {
d->macro_stack.last()->d->child_list.append(cmd);
} else {
d->command_list.append(cmd);
d->checkUndoLimit();
d->setIndex(d->index + 1, false);
}
}
}
void KUndo2QStack::push(KUndo2Command *cmd)
{
cmd->redo();
bool macro = !m_macro_stack.isEmpty();
KUndo2Command *cur = 0;
if (macro) {
KUndo2Command *macro_cmd = m_macro_stack.last();
if (!macro_cmd->d->child_list.isEmpty())
cur = macro_cmd->d->child_list.last();
} else {
if (m_index > 0)
cur = m_command_list.at(m_index - 1);
while (m_index < m_command_list.size())
delete m_command_list.takeLast();
if (m_clean_index > m_index)
m_clean_index = -1; // we've deleted the clean state
}
bool try_merge = cur != 0
&& cur->id() != -1
&& cur->id() == cmd->id()
&& (macro || m_index != m_clean_index);
if (try_merge && cur->mergeWith(cmd)) {
delete cmd;
if (!macro) {
emit indexChanged(m_index);
emit canUndoChanged(canUndo());
emit undoTextChanged(undoText());
emit canRedoChanged(canRedo());
emit redoTextChanged(redoText());
}
} else {
if (macro) {
m_macro_stack.last()->d->child_list.append(cmd);
} else {
m_command_list.append(cmd);
checkUndoLimit();
setIndex(m_index + 1, false);
}
}
}
KAction* Editor::createRedoAction(KActionCollection *actionCollection)
{
UndoAction *action = new UndoAction(i18n("Redo"), actionCollection);
action->setEnabled(canRedo());
action->setPrefixedText(redoText());
connect(this, SIGNAL(canRedoChanged(bool)), action, SLOT(setEnabled(bool)));
connect(this, SIGNAL(redoTextChanged(QString)), action, SLOT(setPrefixedText(QString)));
connect(action, SIGNAL(triggered()), this, SLOT(redo()));
action->setIcon(KIcon("edit-redo"));
action->setIconText(i18n("Redo"));
action->setShortcuts(KStandardShortcut::redo());
actionCollection->addAction(KStandardAction::name(KStandardAction::Redo), action);
return action;
}
void KUndo2QStack::setIndex(int idx, bool clean)
{
bool was_clean = m_index == m_clean_index;
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);
}
bool KUndo2QStack::push(KUndo2Command *cmd)
{
cmd->redoMergedCommands();
cmd->setEndTime();
bool macro = !m_macro_stack.isEmpty();
KUndo2Command *cur = 0;
if (macro) {
KUndo2Command *macro_cmd = m_macro_stack.last();
if (!macro_cmd->d->child_list.isEmpty())
cur = macro_cmd->d->child_list.last();
} else {
if (m_index > 0)
cur = m_command_list.at(m_index - 1);
while (m_index < m_command_list.size())
delete m_command_list.takeLast();
if (m_clean_index > m_index)
m_clean_index = -1; // we've deleted the clean state
}
bool try_merge = cur != 0
&& cur->id() != -1
&& cur->id() == cmd->id()
&& (macro || m_index != m_clean_index);
/*!
*Here we are going to try to merge several commands together using the QVector field in the commands using
*3 parameters. N : Number of commands that should remain individual at the top of the stack. T1 : Time lapsed between current command and previously merged command -- signal to
*merge throughout the stack. T2 : Time lapsed between two commands signalling both commands belong to the same set
*Whenever a KUndo2Command is initialized -- it consists of a start-time and when it is pushed --an end time.
*Every time a command is pushed -- it checks whether the command pushed was pushed after T1 seconds of the last merged command
*Then the merging begins with each group depending on the time in between each command (T2).
*
*@TODO : Currently it is not able to merge two merged commands together.
*/
if (!macro && m_command_list.size() > 1 && cmd->timedId() != -1 && m_useCumulativeUndoRedo) {
KUndo2Command* lastcmd = m_command_list.last();
if (qAbs(cmd->time().msecsTo(lastcmd->endTime())) < m_timeT2 * 1000) {
m_lastMergedSetCount++;
} else {
m_lastMergedSetCount = 0;
m_lastMergedIndex = m_index-1;
}
if (lastcmd->timedId() == -1){
m_lastMergedSetCount = 0;
m_lastMergedIndex = m_index;
}
if (m_lastMergedSetCount > m_strokesN) {
KUndo2Command* toMerge = m_command_list.at(m_lastMergedIndex);
if (toMerge && m_command_list.size() >= m_lastMergedIndex + 1 && m_command_list.at(m_lastMergedIndex + 1)) {
if(toMerge->timedMergeWith(m_command_list.at(m_lastMergedIndex + 1))){
m_command_list.removeAt(m_lastMergedIndex + 1);
}
m_lastMergedSetCount--;
m_lastMergedIndex = m_command_list.indexOf(toMerge);
}
}
m_index = m_command_list.size();
if(m_lastMergedIndex<m_index){
if (cmd->time().msecsTo(m_command_list.at(m_lastMergedIndex)->endTime()) < -m_timeT1 * 1000) { //T1 time elapsed
QListIterator<KUndo2Command*> it(m_command_list);
it.toBack();
m_lastMergedSetCount = 1;
while (it.hasPrevious()) {
KUndo2Command* curr = it.previous();
KUndo2Command* lastCmdInCurrent = curr;
if (!lastcmd->mergeCommandsVector().isEmpty()) {
if (qAbs(lastcmd->mergeCommandsVector().last()->time().msecsTo(lastCmdInCurrent->endTime())) < int(m_timeT2 * 1000) && lastcmd != lastCmdInCurrent && lastcmd != curr) {
if(lastcmd->timedMergeWith(curr)){
if (m_command_list.contains(curr)) {
m_command_list.removeOne(curr);
}
}
} else {
lastcmd = curr; //end of a merge set
}
} else {
if (qAbs(lastcmd->time().msecsTo(lastCmdInCurrent->endTime())) < int(m_timeT2 * 1000) && lastcmd != lastCmdInCurrent &&lastcmd!=curr) {
if(lastcmd->timedMergeWith(curr)){
if (m_command_list.contains(curr)){
m_command_list.removeOne(curr);
}
}
} else {
lastcmd = curr; //end of a merge set
}
}
}
m_lastMergedIndex = m_command_list.size()-1;
}
}
m_index = m_command_list.size();
}
if (try_merge && cur->mergeWith(cmd)) {
delete cmd;
cmd = 0;
if (!macro) {
emit indexChanged(m_index);
emit canUndoChanged(canUndo());
emit undoTextChanged(undoText());
emit canRedoChanged(canRedo());
emit redoTextChanged(redoText());
}
} else {
if (macro) {
m_macro_stack.last()->d->child_list.append(cmd);
} else {
m_command_list.append(cmd);
if(checkUndoLimit())
{
m_lastMergedIndex = m_index - m_strokesN;
}
setIndex(m_index + 1, false);
}
}
return cmd;
}
