comparison widgets/CommandHistory.cpp @ 1266:a34a2a25907c

Untabify

     connect(m_undoMenuAction, SIGNAL(triggered()), this, SLOT(undo()));
     
     m_undoMenu = new QMenu(tr("&Undo"));
     m_undoMenuAction->setMenu(m_undoMenu);
     connect(m_undoMenu, SIGNAL(triggered(QAction *)),
-	    this, SLOT(undoActivated(QAction*)));
+            this, SLOT(undoActivated(QAction*)));
 
     m_redoAction = new QAction(redoIcon, tr("Re&do"), this);
     m_redoAction->setShortcut(tr("Ctrl+Shift+Z"));
     m_redoAction->setStatusTip(tr("Redo the last operation that was undone"));
     connect(m_redoAction, SIGNAL(triggered()), this, SLOT(redo()));

     connect(m_redoMenuAction, SIGNAL(triggered()), this, SLOT(redo()));
 
     m_redoMenu = new QMenu(tr("Re&do"));
     m_redoMenuAction->setMenu(m_redoMenu);
     connect(m_redoMenu, SIGNAL(triggered(QAction *)),
-	    this, SLOT(redoActivated(QAction*)));
+            this, SLOT(redoActivated(QAction*)));
 }
 
 CommandHistory::~CommandHistory()
 {
     m_savedAt = -1;

 CommandHistory::addCommand(Command *command)
 {
     if (!command) return;
 
     if (m_currentCompound) {
-	addToCompound(command, m_executeCompound);
-	return;
+        addToCompound(command, m_executeCompound);
+        return;
     }
 
     addCommand(command, true);
 }
 

 #ifdef DEBUG_COMMAND_HISTORY
     cerr << "CommandHistory::addCommand: " << command->getName() << " of type " << typeid(*command).name() << " at " << command << ": execute = " << execute << ", bundle = " << bundle << " (m_currentCompound = " << m_currentCompound << ", m_currentBundle = " << m_currentBundle << ")" << endl;
 #endif
 
     if (m_currentCompound) {
-	addToCompound(command, execute);
-	return;
+        addToCompound(command, execute);
+        return;
     }
 
     if (bundle) {
-	addToBundle(command, execute);
-	return;
+        addToBundle(command, execute);
+        return;
     } else if (m_currentBundle) {
-	closeBundle();
+        closeBundle();
     }
 
 #ifdef DEBUG_COMMAND_HISTORY
     if (!m_redoStack.empty()) {
         cerr << "CommandHistory::clearing redo stack" << endl;

 
     m_undoStack.push(command);
     clipCommands();
     
     if (execute) {
-	command->execute();
+        command->execute();
     }
 
     // Emit even if we aren't executing the command, because
     // someone must have executed it for this to make any sense
     emit commandExecuted();

 
 void
 CommandHistory::addToBundle(Command *command, bool execute)
 {
     if (m_currentBundle) {
-	if (!command || (command->getName() != m_currentBundleName)) {
+        if (!command || (command->getName() != m_currentBundleName)) {
 #ifdef DEBUG_COMMAND_HISTORY
             cerr << "CommandHistory::addToBundle: " << command->getName()
                  << ": closing current bundle" << endl;
 #endif
-	    closeBundle();
-	}
+            closeBundle();
+        }
     }
 
     if (!command) return;
 
     if (!m_currentBundle) {

 #ifdef DEBUG_COMMAND_HISTORY
         cerr << "CommandHistory::addToBundle: " << command->getName()
              << ": creating new bundle" << endl;
 #endif
 
-	// need to addCommand before setting m_currentBundle, as addCommand
-	// with bundle false will reset m_currentBundle to 0
-	MacroCommand *mc = new BundleCommand(command->getName());
+        // need to addCommand before setting m_currentBundle, as addCommand
+        // with bundle false will reset m_currentBundle to 0
+        MacroCommand *mc = new BundleCommand(command->getName());
         m_bundling = true;
-	addCommand(mc, false);
+        addCommand(mc, false);
         m_bundling = false;
-	m_currentBundle = mc;
-	m_currentBundleName = command->getName();
+        m_currentBundle = mc;
+        m_currentBundleName = command->getName();
     }
 
 #ifdef DEBUG_COMMAND_HISTORY
     cerr << "CommandHistory::addToBundle: " << command->getName()
          << ": adding to bundle" << endl;

 
 void
 CommandHistory::addToCompound(Command *command, bool execute)
 {
     if (!m_currentCompound) {
-	cerr << "CommandHistory::addToCompound: ERROR: no compound operation in progress!" << endl;
+        cerr << "CommandHistory::addToCompound: ERROR: no compound operation in progress!" << endl;
         return;
     }
 
 #ifdef DEBUG_COMMAND_HISTORY
     cerr << "CommandHistory::addToCompound[" << m_currentCompound->getName() << "]: " << command->getName() << " (exec: " << execute << ")" << endl;

 
 void
 CommandHistory::startCompoundOperation(QString name, bool execute)
 {
     if (m_currentCompound) {
-	cerr << "CommandHistory::startCompoundOperation: ERROR: compound operation already in progress!" << endl;
-	cerr << "(name is " << m_currentCompound->getName() << ")" << endl;
+        cerr << "CommandHistory::startCompoundOperation: ERROR: compound operation already in progress!" << endl;
+        cerr << "(name is " << m_currentCompound->getName() << ")" << endl;
         return;
     }
  
 #ifdef DEBUG_COMMAND_HISTORY
     cerr << "CommandHistory::startCompoundOperation: " << name << " (exec: " << execute << ")" << endl;

 
 void
 CommandHistory::endCompoundOperation()
 {
     if (!m_currentCompound) {
-	cerr << "CommandHistory::endCompoundOperation: ERROR: no compound operation in progress!" << endl;
+        cerr << "CommandHistory::endCompoundOperation: ERROR: no compound operation in progress!" << endl;
         return;
     }
  
 #ifdef DEBUG_COMMAND_HISTORY
     cerr << "CommandHistory::endCompoundOperation: " << m_currentCompound->getName() << endl;

 
 void
 CommandHistory::clipCommands()
 {
     if (int(m_undoStack.size()) > m_undoLimit) {
-	m_savedAt -= (int(m_undoStack.size()) - m_undoLimit);
+        m_savedAt -= (int(m_undoStack.size()) - m_undoLimit);
     }
 
     clipStack(m_undoStack, m_undoLimit);
     clipStack(m_redoStack, m_redoLimit);
 }

 {
     int i;
 
     if ((int)stack.size() > limit) {
 
-	CommandStack tempStack;
-
-	for (i = 0; i < limit; ++i) {
-#ifdef DEBUG_COMMAND_HISTORY
-	    Command *command = stack.top();
-	    cerr << "CommandHistory::clipStack: Saving recent command: " << command->getName() << " at " << command << endl;
-#endif
-	    tempStack.push(stack.top());
-	    stack.pop();
-	}
-
-	clearStack(stack);
-
-	for (i = 0; i < m_undoLimit; ++i) {
-	    stack.push(tempStack.top());
-	    tempStack.pop();
-	}
+        CommandStack tempStack;
+
+        for (i = 0; i < limit; ++i) {
+#ifdef DEBUG_COMMAND_HISTORY
+            Command *command = stack.top();
+            cerr << "CommandHistory::clipStack: Saving recent command: " << command->getName() << " at " << command << endl;
+#endif
+            tempStack.push(stack.top());
+            stack.pop();
+        }
+
+        clearStack(stack);
+
+        for (i = 0; i < m_undoLimit; ++i) {
+            stack.push(tempStack.top());
+            tempStack.pop();
+        }
     }
 }
 
 void
 CommandHistory::clearStack(CommandStack &stack)
 {
     while (!stack.empty()) {
-	Command *command = stack.top();
-	// Not safe to call getName() on a command about to be deleted
-#ifdef DEBUG_COMMAND_HISTORY
-	cerr << "CommandHistory::clearStack: About to delete command " << command << endl;
-#endif
-	delete command;
-	stack.pop();
+        Command *command = stack.top();
+        // Not safe to call getName() on a command about to be deleted
+#ifdef DEBUG_COMMAND_HISTORY
+        cerr << "CommandHistory::clearStack: About to delete command " << command << endl;
+#endif
+        delete command;
+        stack.pop();
     }
 }
 
 void
 CommandHistory::undoActivated(QAction *action)
 {
     int pos = m_actionCounts[action];
     for (int i = 0; i <= pos; ++i) {
-	undo();
+        undo();
     }
 }
 
 void
 CommandHistory::redoActivated(QAction *action)
 {
     int pos = m_actionCounts[action];
     for (int i = 0; i <= pos; ++i) {
-	redo();
+        redo();
     }
 }
 
 void
 CommandHistory::updateActions()
 {
     m_actionCounts.clear();
 
     for (int undo = 0; undo <= 1; ++undo) {
 
-	QAction *action(undo ? m_undoAction : m_redoAction);
-	QAction *menuAction(undo ? m_undoMenuAction : m_redoMenuAction);
-	QMenu *menu(undo ? m_undoMenu : m_redoMenu);
-	CommandStack &stack(undo ? m_undoStack : m_redoStack);
-
-	if (stack.empty()) {
-
-	    QString text(undo ? tr("Nothing to undo") : tr("Nothing to redo"));
-
-	    action->setEnabled(false);
-	    action->setText(text);
-
-	    menuAction->setEnabled(false);
-	    menuAction->setText(text);
-
-	} else {
-
-	    action->setEnabled(true);
-	    menuAction->setEnabled(true);
-
-	    QString commandName = stack.top()->getName();
-	    commandName.replace(QRegExp("&"), "");
-
-	    QString text = (undo ? tr("&Undo %1") : tr("Re&do %1"))
-		.arg(commandName);
-
-	    action->setText(text);
-	    menuAction->setText(text);
-	}
-
-	menu->clear();
-
-	CommandStack tempStack;
-	int j = 0;
-
-	while (j < m_menuLimit && !stack.empty()) {
-
-	    Command *command = stack.top();
-	    tempStack.push(command);
-	    stack.pop();
-
-	    QString commandName = command->getName();
-	    commandName.replace(QRegExp("&"), "");
-
-	    QString text;
-	    if (undo) text = tr("&Undo %1").arg(commandName);
-	    else      text = tr("Re&do %1").arg(commandName);
-	    
-	    QAction *action = menu->addAction(text);
-	    m_actionCounts[action] = j++;
-	}
-
-	while (!tempStack.empty()) {
-	    stack.push(tempStack.top());
-	    tempStack.pop();
-	}
-    }
-}
-
+        QAction *action(undo ? m_undoAction : m_redoAction);
+        QAction *menuAction(undo ? m_undoMenuAction : m_redoMenuAction);
+        QMenu *menu(undo ? m_undoMenu : m_redoMenu);
+        CommandStack &stack(undo ? m_undoStack : m_redoStack);
+
+        if (stack.empty()) {
+
+            QString text(undo ? tr("Nothing to undo") : tr("Nothing to redo"));
+
+            action->setEnabled(false);
+            action->setText(text);
+
+            menuAction->setEnabled(false);
+            menuAction->setText(text);
+
+        } else {
+
+            action->setEnabled(true);
+            menuAction->setEnabled(true);
+
+            QString commandName = stack.top()->getName();
+            commandName.replace(QRegExp("&"), "");
+
+            QString text = (undo ? tr("&Undo %1") : tr("Re&do %1"))
+                .arg(commandName);
+
+            action->setText(text);
+            menuAction->setText(text);
+        }
+
+        menu->clear();
+
+        CommandStack tempStack;
+        int j = 0;
+
+        while (j < m_menuLimit && !stack.empty()) {
+
+            Command *command = stack.top();
+            tempStack.push(command);
+            stack.pop();
+
+            QString commandName = command->getName();
+            commandName.replace(QRegExp("&"), "");
+
+            QString text;
+            if (undo) text = tr("&Undo %1").arg(commandName);
+            else      text = tr("Re&do %1").arg(commandName);
+            
+            QAction *action = menu->addAction(text);
+            m_actionCounts[action] = j++;
+        }
+
+        while (!tempStack.empty()) {
+            stack.push(tempStack.top());
+            tempStack.pop();
+        }
+    }
+}
+