PythonQt.Qt.QUndoCommand
QUndoCommand
PythonQtInstanceWrapper object
Native bases: PythonQtInstanceWrapper
Supplemental documentation: Qt 5 reference:
Detailed Description
For an overview of Qt's Undo Framework, see the overview document.
A QUndoCommand represents a single editing action on a document; for example, inserting or deleting a block of text in a text editor. QUndoCommand can apply a change to the document with redo() and undo the change with undo(). The implementations for these functions must be provided in a derived class.
class AppendText : public QUndoCommand
{
public:
AppendText(QString *doc, const QString &text)
: m_document(doc), m_text(text) { setText("append text"); }
void undo() override
{ m_document->chop(m_text.length()); }
void redo() override
{ m_document->append(m_text); }
private:
QString *m_document;
QString m_text;
};
A QUndoCommand has an associated text(). This is a short string describing what the command does. It is used to update the text properties of the stack's undo and redo actions; see QUndoStack::createUndoAction() and QUndoStack::createRedoAction().
QUndoCommand objects are owned by the stack they were pushed on. QUndoStack deletes a command if it has been undone and a new command is pushed. For example:
MyCommand *command1 = new MyCommand();
stack->push(command1);
MyCommand *command2 = new MyCommand();
stack->push(command2);
stack->undo();
MyCommand *command3 = new MyCommand();
stack->push(command3); // command2 gets deleted
In effect, when a command is pushed, it becomes the top-most command on the stack.
To support command compression, QUndoCommand has an id() and the virtual function mergeWith(). These functions are used by QUndoStack::push().
To support command macros, a QUndoCommand object can have any number of child commands. Undoing or redoing the parent command will cause the child commands to be undone or redone. A command can be assigned to a parent explicitly in the constructor. In this case, the command will be owned by the parent.
The parent in this case is usually an empty command, in that it doesn't provide its own implementation of undo() and redo(). Instead, it uses the base implementations of these functions, which simply call undo() or redo() on all its children. The parent should, however, have a meaningful text().
QUndoCommand *insertRed = new QUndoCommand(); // an empty command
insertRed->setText("insert red text");
new InsertText(document, idx, text, insertRed); // becomes child of insertRed
new SetColor(document, idx, text.length(), Qt::red, insertRed);
stack.push(insertRed);
Another way to create macros is to use the convenience functions QUndoStack::beginMacro() and QUndoStack::endMacro().
Source: https://doc.qt.io/archives/qt-5.15/qundocommand.html
Complete member index
Every captured member retains its own identity. Identical captured declaration text is linked once; this does not establish native inheritance or interchangeable objects.
| Member | Kind | Signature | Summary |
|---|---|---|---|
__init__ |
function | (self, *args: Any, **kwargs: Any) -> None |
Native constructor; consult class documentation for supported overloads. (shared captured text) |
actionText |
function | (self) -> str |
X.actionText() -> str (shared captured text) |
child |
function | (self, index: int) -> Any |
X.child(index) -> PythonQt.QtGui.QUndoCommand (shared captured text) |
childCount |
function | (self) -> int |
X.childCount() -> int (shared captured text) |
className |
function | (self, *args: Any, **kwargs: Any) -> Any |
Return the classname of the object (shared captured text) |
delete |
function | (self, *args: Any, **kwargs: Any) -> Any |
Deletes the C++ object (at your own risk, my friend!) (shared captured text) |
help |
function | (self, *args: Any, **kwargs: Any) -> Any |
Shows the help of available methods for this class (shared captured text) |
id |
function | (self) -> int |
X.id() -> int (shared captured text) |
inherits |
function | (self, *args: Any, **kwargs: Any) -> Any |
Returns if the class inherits or is of given type name (shared captured text) |
mergeWith |
function | (self, other: Any) -> bool |
X.mergeWith(other) -> bool (shared captured text) |
redo |
function | (self) -> None |
Applies a change to the document. (shared captured text) |
setText |
function | (self, text: str) -> None |
Sets the command's text to be the text specified. (shared captured text) |
text |
function | (self) -> str |
X.text() -> str (shared captured text) |
undo |
function | (self) -> None |
Reverts a change to the document. (shared captured text) |