Ejemplo del marco de trabajo «Undo»
Este ejemplo muestra cómo implementar la funcionalidad de deshacer/rehacer con el marco de trabajo de deshacer de Qt.

En el marco de trabajo «undo» de Qt, todas las acciones que realiza el usuario se implementan en clases que heredan de ` QUndoCommand`. Una clase de comando «undo» sabe tanto cómo « redo()» —o simplemente «do» la primera vez— como « undo()» una acción. Por cada acción que realiza el usuario, se coloca un comando en una pila de comandos de deshacer ( QUndoStack). Dado que la pila contiene todos los comandos ejecutados (apilados en orden cronológico) en el documento, puede hacer avanzar o retroceder el estado del documento deshaciendo y rehaciendo sus comandos. Consulte el documento de descripción general para obtener una introducción de alto nivel al marco de trabajo de deshacer.
El ejemplo de deshacer implementa una sencilla aplicación de diagramas. Es posible añadir y eliminar elementos, que pueden tener forma de cuadro o de rectángulo, y moverlos arrastrándolos con el ratón. La pila de deshacer se muestra en un QUndoView, que es una lista en la que los comandos aparecen como elementos de la lista. Las opciones de deshacer y rehacer están disponibles en el menú de edición. El usuario también puede seleccionar un comando desde la vista de deshacer.
Utilizamos el marco de trabajo de vista gráfica para implementar el diagrama. Solo trataremos brevemente el código relacionado, ya que el marco de trabajo cuenta con ejemplos propios (p. ej., el ejemplo «Diagram Scene»).
El ejemplo consta de las siguientes clases:
MainWindowes la ventana principal y organiza los widgets del ejemplo. Crea los comandos en función de la entrada del usuario y los mantiene en la pila de comandos.AddCommandAñade un elemento a la escena.DeleteCommandelimina un elemento de la escena.MoveCommandCuando se mueve un elemento, MoveCommand registra las posiciones inicial y final del movimiento, y mueve el elemento según estas cuando se invocanredo()yundo().DiagramSceneHered QGraphicsScene y emite señales paraMoveComandscuando se mueve un elemento.DiagramItemHeredan de QGraphicsPolygonItem y representan un elemento en el diagrama.
Definición de la clase MainWindow
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow();
public slots:
void itemMoved(DiagramItem *movedDiagram, const QPointF &moveStartPosition);
private slots:
void deleteItem();
void addBox();
void addTriangle();
void about();
void updateActions();
private:
void createActions();
void createMenus();
void createToolBars();
void createUndoView();
QAction *deleteAction = nullptr;
QAction *addBoxAction = nullptr;
QAction *addTriangleAction = nullptr;
QAction *undoAction = nullptr;
QAction *redoAction = nullptr;
QAction *exitAction = nullptr;
QAction *aboutAction = nullptr;
QMenu *fileMenu = nullptr;
QMenu *editMenu = nullptr;
QMenu *itemMenu = nullptr;
QMenu *helpMenu = nullptr;
DiagramScene *diagramScene = nullptr;
QUndoStack *undoStack = nullptr;
QUndoView *undoView = nullptr;
};La clase « MainWindow » gestiona la pila de deshacer, es decir, crea objetos « QUndoCommand» y los inserta y extrae de la pila cuando recibe la señal « triggered() » de « undoAction » y « redoAction ».
Implementación de la clase MainWindow
Empezaremos echando un vistazo al constructor:
MainWindow::MainWindow()
{
undoStack = new QUndoStack(this);
diagramScene = new DiagramScene();
const QBrush pixmapBrush(QPixmap(":/icons/cross.png").scaled(30, 30));
diagramScene->setBackgroundBrush(pixmapBrush);
diagramScene->setSceneRect(QRect(0, 0, 500, 500));
createActions();
createMenus();
createToolBars();
createUndoView();
connect(diagramScene, &DiagramScene::itemMoved,
this, &MainWindow::itemMoved);
connect(diagramScene, &DiagramScene::selectionChanged,
this, &MainWindow::updateActions);
setWindowTitle("Undo Framework");
QGraphicsView *view = new QGraphicsView(diagramScene);
setCentralWidget(view);
adjustSize();
}En el constructor, configuramos DiagramScene y QGraphicsView. Solo queremos que deleteAction esté habilitado cuando hayamos seleccionado un elemento, por lo que conectamos la señal selectionChanged() de la escena a la ranura updateActions().
Esta es la función « createUndoView() »:
void MainWindow::createUndoView()
{
QDockWidget *undoDockWidget = new QDockWidget;
undoDockWidget->setWindowTitle(tr("Command List"));
undoDockWidget->setWidget(new QUndoView(undoStack));
addDockWidget(Qt::RightDockWidgetArea, undoDockWidget);
}El QUndoView es un widget que muestra, en una lista, el texto —establecido mediante la función setText()— correspondiente a cada QUndoCommand de la pila de deshacer. Lo colocamos en un widget acoplable.
Esta es la función ` createActions() `:
void MainWindow::createActions()
{
deleteAction = new QAction(QIcon(":/icons/remove.png"), tr("&Delete Item"), this);
deleteAction->setShortcut(tr("Del"));
connect(deleteAction, &QAction::triggered, this, &MainWindow::deleteItem);
...
undoAction = undoStack->createUndoAction(this, tr("&Undo"));
undoAction->setIcon(QIcon(":/icons/undo.png"));
undoAction->setShortcuts(QKeySequence::Undo);
redoAction = undoStack->createRedoAction(this, tr("&Redo"));
redoAction->setIcon(QIcon(":/icons/redo.png"));
redoAction->setShortcuts(QKeySequence::Redo);La función ` createActions() ` configura todas las acciones de los ejemplos tal y como se muestra más arriba. Los métodos ` createUndoAction()` y ` createRedoAction()` nos ayudan a crear acciones que se desactivan y activan en función del estado de la pila. Además, el texto de la acción se actualizará automáticamente en función del valor de ` text()` de los comandos de deshacer. Para el resto de acciones, hemos implementado ranuras en la clase ` MainWindow `.
...
updateActions();
}
void MainWindow::updateActions()
{
deleteAction->setEnabled(!diagramScene->selectedItems().isEmpty());
}Una vez creadas todas las acciones, actualizamos su estado llamando a la misma función que está conectada a la señal selectionChanged de la escena.
Las funciones createMenus() y createToolBars() añaden las acciones a los menús y las barras de herramientas:
void MainWindow::createMenus()
{
fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(exitAction);
editMenu = menuBar()->addMenu(tr("&Edit"));
editMenu->addAction(undoAction);
editMenu->addAction(redoAction);
editMenu->addSeparator();
editMenu->addAction(deleteAction);
...
helpMenu = menuBar()->addMenu(tr("&About"));
helpMenu->addAction(aboutAction);
}
void MainWindow::createToolBars()
{
QToolBar *editToolBar = new QToolBar;
editToolBar->addAction(undoAction);
editToolBar->addAction(redoAction);
editToolBar->addSeparator();
editToolBar->addAction(deleteAction);
...
addToolBar(editToolBar);
addToolBar(itemToolBar);
}Aquí está la ranura « itemMoved() »:
void MainWindow::itemMoved(DiagramItem *movedItem,
const QPointF &oldPosition)
{
undoStack->push(new MoveCommand(movedItem, oldPosition));
}Simplemente insertamos un MoveCommand en la pila, lo que hace que se llame a redo() sobre él.
Aquí está la ranura deleteItem():
void MainWindow::deleteItem()
{
if (diagramScene->selectedItems().isEmpty())
return;
QUndoCommand *deleteCommand = new DeleteCommand(diagramScene);
undoStack->push(deleteCommand);
}Para poder eliminar un elemento, este debe estar seleccionado. Tenemos que comprobar si está seleccionado, ya que la función ` deleteAction ` puede estar habilitada incluso si no hay ningún elemento seleccionado. Esto puede ocurrir porque no capturamos ninguna señal ni evento cuando se selecciona un elemento.
Aquí está el slot « addBox() »:
void MainWindow::addBox()
{
QUndoCommand *addCommand = new AddCommand(DiagramItem::Box, diagramScene);
undoStack->push(addCommand);
}La función « addBox() » crea un «AddCommand» y lo añade a la pila de deshacer.
Aquí está el slot « addTriangle() »:
void MainWindow::addTriangle()
{
QUndoCommand *addCommand = new AddCommand(DiagramItem::Triangle,
diagramScene);
undoStack->push(addCommand);
}La función « addTriangle() » crea un «AddCommand» y lo añade a la pila de deshacer.
Esta es la implementación de ` about()`:
void MainWindow::about()
{
QMessageBox::about(this, tr("About Undo"),
tr("The <b>Undo</b> example demonstrates how to "
"use Qt's undo framework."));
}El slot «about» se activa mediante « aboutAction » y muestra un cuadro de información sobre el ejemplo.
Definición de la clase AddCommand
class AddCommand : public QUndoCommand
{
public:
AddCommand(DiagramItem::DiagramType addType, QGraphicsScene *graphicsScene,
QUndoCommand *parent = nullptr);
~AddCommand();
void undo() override;
void redo() override;
private:
DiagramItem *myDiagramItem;
QGraphicsScene *myGraphicsScene;
QPointF initialPosition;
};La clase ` AddCommand ` añade elementos gráficos `DiagramItem` a la `DiagramScene`.
Implementación de la clase `AddCommand`
Empezamos por el constructor:
AddCommand::AddCommand(DiagramItem::DiagramType addType,
QGraphicsScene *scene, QUndoCommand *parent)
: QUndoCommand(parent), myGraphicsScene(scene)
{
static int itemCount = 0;
myDiagramItem = new DiagramItem(addType);
initialPosition = QPointF((itemCount * 15) % int(scene->width()),
(itemCount * 15) % int(scene->height()));
scene->update();
++itemCount;
setText(QObject::tr("Add %1")
.arg(createCommandString(myDiagramItem, initialPosition)));
}En primer lugar, creamos el DiagramItem que se va a añadir a DiagramScene. La función setText() nos permite establecer un QString que describe el comando. Lo utilizamos para mostrar mensajes personalizados en QUndoView y en el menú de la ventana principal.
void AddCommand::undo()
{
myGraphicsScene->removeItem(myDiagramItem);
myGraphicsScene->update();
}undo() elimina el elemento de la escena.
void AddCommand::redo()
{
myGraphicsScene->addItem(myDiagramItem);
myDiagramItem->setPos(initialPosition);
myGraphicsScene->clearSelection();
myGraphicsScene->update();
}Establecemos la posición del elemento, ya que no lo hacemos en el constructor.
Definición de la clase DeleteCommand
class DeleteCommand : public QUndoCommand
{
public:
explicit DeleteCommand(QGraphicsScene *graphicsScene, QUndoCommand *parent = nullptr);
void undo() override;
void redo() override;
private:
DiagramItem *myDiagramItem;
QGraphicsScene *myGraphicsScene;
};La clase `DeleteCommand` implementa la funcionalidad para eliminar un elemento de la escena.
Implementación de la clase DeleteCommand
DeleteCommand::DeleteCommand(QGraphicsScene *scene, QUndoCommand *parent)
: QUndoCommand(parent), myGraphicsScene(scene)
{
QList<QGraphicsItem *> list = myGraphicsScene->selectedItems();
list.first()->setSelected(false);
myDiagramItem = static_cast<DiagramItem *>(list.first());
setText(QObject::tr("Delete %1")
.arg(createCommandString(myDiagramItem, myDiagramItem->pos())));
}Sabemos que debe haber un elemento seleccionado, ya que no es posible crear un DeleteCommand a menos que se haya seleccionado el elemento que se va a eliminar y que solo se puede seleccionar un elemento a la vez. El elemento debe deseleccionarse si se vuelve a insertar en la escena.
void DeleteCommand::undo()
{
myGraphicsScene->addItem(myDiagramItem);
myGraphicsScene->update();
}El elemento simplemente se vuelve a insertar en la escena.
void DeleteCommand::redo()
{
myGraphicsScene->removeItem(myDiagramItem);
}El elemento se elimina de la escena.
Definición de la clase MoveCommand
class MoveCommand : public QUndoCommand
{
public:
enum { Id = 1234 };
MoveCommand(DiagramItem *diagramItem, const QPointF &oldPos,
QUndoCommand *parent = nullptr);
void undo() override;
void redo() override;
bool mergeWith(const QUndoCommand *command) override;
int id() const override { return Id; }
private:
DiagramItem *myDiagramItem;
QPointF myOldPos;
QPointF newPos;
};Se ha reimplementado el método ` mergeWith()` para que los movimientos consecutivos de un elemento se consideren un único `MoveCommand`; es decir, el elemento volverá a la posición inicial del primer movimiento.
Implementación de la clase MoveCommand
El constructor de MoveCommand tiene el siguiente aspecto:
MoveCommand::MoveCommand(DiagramItem *diagramItem, const QPointF &oldPos,
QUndoCommand *parent)
: QUndoCommand(parent), myDiagramItem(diagramItem)
, myOldPos(oldPos), newPos(diagramItem->pos())
{
}Guardamos tanto la posición anterior como la nueva para deshacer y rehacer, respectivamente.
void MoveCommand::undo()
{
myDiagramItem->setPos(myOldPos);
myDiagramItem->scene()->update();
setText(QObject::tr("Move %1")
.arg(createCommandString(myDiagramItem, newPos)));
}Simplemente establecemos la posición anterior del elemento y actualizamos la escena.
void MoveCommand::redo()
{
myDiagramItem->setPos(newPos);
setText(QObject::tr("Move %1")
.arg(createCommandString(myDiagramItem, newPos)));
}Colocamos el elemento en su nueva posición.
bool MoveCommand::mergeWith(const QUndoCommand *command)
{
const MoveCommand *moveCommand = static_cast<const MoveCommand *>(command);
DiagramItem *item = moveCommand->myDiagramItem;
if (myDiagramItem != item)
return false;
newPos = item->pos();
setText(QObject::tr("Move %1")
.arg(createCommandString(myDiagramItem, newPos)));
return true;
}Cada vez que se crea un `MoveCommand`, se llama a esta función para comprobar si debe fusionarse con el comando anterior. Es el objeto del comando anterior el que se mantiene en la pila. La función devuelve `true` si el comando se fusiona; en caso contrario, devuelve `false`.
Primero comprobamos si se trata del mismo elemento que se ha movido dos veces; en ese caso, fusionamos los comandos. Actualizamos la posición del elemento para que, al deshacer la acción, ocupe la última posición en la secuencia de movimientos.
Definición de la clase `DiagramScene`
class DiagramScene : public QGraphicsScene
{
Q_OBJECT
public:
DiagramScene(QObject *parent = nullptr);
signals:
void itemMoved(DiagramItem *movedItem, const QPointF &movedFromPosition);
protected:
void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
private:
QGraphicsItem *movingItem = nullptr;
QPointF oldPos;
};La clase `DiagramScene` implementa la funcionalidad para mover un `DiagramItem` con el ratón. Emite una señal cuando se completa un movimiento. Esta señal es captada por el ` MainWindow`, que crea los `MoveCommands`. No examinamos la implementación de `DiagramScene`, ya que solo se ocupa de cuestiones relacionadas con el marco gráfico.
La función « main() »
La función ` main() ` del programa tiene este aspecto:
int main(int argv, char *args[])
{
QApplication app(argv, args);
MainWindow mainWindow;
mainWindow.show();
return app.exec();
}Dibujamos una cuadrícula en el fondo de DiagramScene, por lo que utilizamos un archivo de recursos. El resto de la función crea MainWindow y la muestra como una ventana de nivel superior.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.