Qt / PyQt / PySide：重新实现QLineEdit子类的撤销框架时遇到麻烦

Question

I have created a custom line edit widget so that I can incorporate undo/redo commands on it into my application's general undo stack (rather than use the built-in undo/redo facilities that come with QLineEdit widgets). The undo/redo logic is fairly straightforward: when the line edit widget receives focus, its content is immediately assigned to an instance variable (self.init_text); and when the line edit widget loses focus, if the text content differs from that stored in self.init_text, then a new QUndoCommand object is created. The undo() method will re-set the content to whatever is in self.init_text, while the redo() method will re-set the content to whatever was captured when the line edit widget lost focus. (In either method, the line edit will again receive focus so that it will be obvious to the user what the undo or redo command actually affected.)

It seems to work just fine with one exception: if the user very quickly cycles through undo or redo commands through the QPushButtons, then the framework just breaks. I can't describe it much better than that because I'm not sure what's going on under the Qt hood, but, for example, the count() of the QUndoStack may be changed completely. The app continues to run with no errors reported on the terminal, but it is nonetheless a broken undo stack.

I have created a little QDialog app so you can try to re-create the issue. (Using Python 2.7.3/PySide 1.2.1 ... if you have a recent PyQt binding installed, I don't think you should need to replace anything except the first two import statements.) For example, in the first tab's QLineEdit, if you type 'hello', then tab out, then click back in and type 'world', then tab out again, try very swiftly clicking the undo button (down to and beyond the bottom of the undo stack) and redo button (up to and beyond the top of the undo stack). For me, that was enough to break it.

#!/usr/bin/python
#coding=utf-8
from PySide.QtCore import *
from PySide.QtGui import *
import sys

class CustomRightClick(QObject):

    customRightClicked = Signal()

    def __init__(self, parent=None):
        QObject.__init__(self, parent)

    def eventFilter(self, obj, event):
        if event.type() == QEvent.ContextMenu:
            # emit signal so that your widgets can connect a slot to that signal
            self.customRightClicked.emit()
            return True
        else:
            # standard event processing
            return QObject.eventFilter(self, obj, event)

class CommandLineEdit(QUndoCommand):

    def __init__(self, line_edit, init_text, tab_widget, tab_index, description):
        QUndoCommand.__init__(self, description)
        self._line_edit = line_edit
        self._current_text = line_edit.text()
        self._init_text = init_text
        self._tab_widget = tab_widget
        self._tab_index = tab_index

    def undo(self):
        self._line_edit.setText(self._init_text)
        self._tab_widget.setCurrentIndex(self._tab_index)
        self._line_edit.setFocus(Qt.OtherFocusReason)

    def redo(self):
        self._line_edit.setText(self._current_text)
        self._tab_widget.setCurrentIndex(self._tab_index)
        self._line_edit.setFocus(Qt.OtherFocusReason)

class CustomLineEdit(QLineEdit):

    def __init__(self, parent, tab_widget, tab_index):
        super(CustomLineEdit, self).__init__(parent)
        self.parent = parent
        self.tab_widget = tab_widget
        self.tab_index = tab_index
        self.init_text = self.text()
        self.setContextMenuPolicy(Qt.CustomContextMenu)

        undoAction=QAction("Undo", self)
        undoAction.triggered.connect(self.parent.undo_stack.undo)

        self.customContextMenu = QMenu()
        self.customContextMenu.addAction(undoAction)

        custom_clicker = CustomRightClick(self)
        self.installEventFilter(custom_clicker)
        self.right_clicked = False
        custom_clicker.customRightClicked.connect(self.menuShow)

    def menuShow(self):
        self.right_clicked = True   # set self.right_clicked to True so that the focusOutEvent won't push anything to the undo stack as a consequence of right-clicking
        self.customContextMenu.popup(QCursor.pos())
        self.right_clicked = False

    # re-implement focusInEvent() so that it captures as an instance variable the current value of the text *at the time of the focusInEvent(). This will be utilized for the undo stack command push below
    def focusInEvent(self, event):
        self.init_text = self.text()
        QLineEdit.focusInEvent(self, event)

    # re-implement focusOutEvent() so that it pushes the current text to the undo stack.... but only if there was a change!
    def focusOutEvent(self, event):
        if self.text() != self.init_text and not self.right_clicked:
            print "Focus out event. (self.text is %s and init_text is %s). Pushing onto undo stack. (Event reason is %s)" % (self.text(), self.init_text, event.reason())
            command = CommandLineEdit(self, self.init_text, self.tab_widget, self.tab_index, "editing a text box")
            self.parent.undo_stack.push(command)
        QLineEdit.focusOutEvent(self, event)

    def keyPressEvent(self, event):
        if event.key() == Qt.Key_Z:
            if event.modifiers() & Qt.ControlModifier:
                self.parent.undo_stack.undo()
            else:
                QLineEdit.keyPressEvent(self, event)
        elif event.key() == Qt.Key_Y:
            if event.modifiers() & Qt.ControlModifier:
                self.parent.undo_stack.redo()
            else:
                QLineEdit.keyPressEvent(self, event)
        else:
            QLineEdit.keyPressEvent(self, event)

class Form(QDialog):

    def __init__(self, parent=None):
        super(Form, self).__init__(parent)

        self.undo_stack = QUndoStack()

        self.tab_widget = QTabWidget()

        self.line_edit1 = CustomLineEdit(self, self.tab_widget, 0)
        self.line_edit2 = CustomLineEdit(self, self.tab_widget, 1)
        self.undo_counter = QLineEdit()

        tab1widget = QWidget()
        tab1layout = QHBoxLayout()
        tab1layout.addWidget(self.line_edit1)
        tab1widget.setLayout(tab1layout)

        tab2widget = QWidget()
        tab2layout = QHBoxLayout()
        tab2layout.addWidget(self.line_edit2)
        tab2widget.setLayout(tab2layout)

        self.tab_widget.addTab(tab1widget, "Tab 1")
        self.tab_widget.addTab(tab2widget, "Tab 2")

        self.undo_button = QPushButton("Undo")
        self.redo_button = QPushButton("Redo")
        layout = QGridLayout()
        layout.addWidget(self.tab_widget, 0, 0, 1, 2)
        layout.addWidget(self.undo_button, 1, 0)
        layout.addWidget(self.redo_button, 1, 1)
        layout.addWidget(QLabel("Undo Stack Counter"), 2, 0)
        layout.addWidget(self.undo_counter)
        self.setLayout(layout)

        self.undo_button.clicked.connect(self.undo_stack.undo)
        self.redo_button.clicked.connect(self.undo_stack.redo)
        self.undo_stack.indexChanged.connect(self.changeUndoCount)

    def changeUndoCount(self, index):
        self.undo_counter.setText("%s / %s" % (index, self.undo_stack.count()))

app = QApplication(sys.argv)
form = Form()
form.show()
app.exec_()

Is this a Qt bug? A PySide bug? Or is there a problem in my re-implementation? Any help is appreciated!

(It just occurred to me when reviewing my code that I might as well re-implement the contextMenuEvent rather than install the event filter, but I suppose that has no bearing on the issue.)

Answer 1

The issue is arising because you are setting the focus of the QLineEdit during undo/redo. The documentation indicates that redo is called when the command is pushed to the QUndoStack , so as soon as you remove focus from the QLineEdit (say when clicking undo), focus is immediately restored by the automatic call to redo . After this, the undo command runs (triggered by the button click I just mentioned). As the widget already has focus , the focusInEvent method of the line edit does not run when _line_edit.setFocus() is called from undo , so the _line_edit.init_text is not updated appropriately. This means when you click the redo button, the line-edit loses focus, and a new command is queued up because the comparison in the if statement of focusOutEvent is broken as init_text has the incorrect value stored. A new command is then added to the undo stack which overwrites the one you were trying to restore!

Does that make sense?

An easy solution is to add the following line to the undo/redo methods in CommandLineEdit after you set the text of the _line_edit .

def undo(self):
    self._line_edit.setText(self._init_text)
    self._line_edit.init_text = self._line_edit.text()
    self._tab_widget.setCurrentIndex(self._tab_index)
    self._line_edit.setFocus(Qt.OtherFocusReason)

def redo(self):
    self._line_edit.setText(self._current_text)
    self._line_edit.init_text = self._line_edit.text()
    self._tab_widget.setCurrentIndex(self._tab_index)
    self._line_edit.setFocus(Qt.OtherFocusReason)

you can then remove your re-implementation of focusInEvent .

Once you've wrapped your head around the problem, it might be worth starting the architecture of your undo framework from scratch rather than trying to implement my "hacky" solution as there is probably a cleaner way of fixing it!