CODEWITHSUNDEEP
c++qtqdialogqpushbutton
cppguy
cppguy

Reputation: 3713

How do I prevent the enter key from closing my QDialog (Qt 4.8.1)

I have a QDialog with a QDialogButtonBox. The OK and Cancel buttons are active. Occasionally I disable or hide the OK button based on the state of my dialog. It seems, no matter what I do, the Enter key always activates the OK button. I really DON'T want this to happen. I have tried:

And with all combinations of those things above, the Enter key still accepts the dialog. Does anyone have any clue how to block this? It seems like I should be able to block something as simple as this?

Upvotes: 23

Views: 24758

Answers (10)

Thalia
Thalia

Reputation: 14615

The answers above did not work for me for a variety of reasons.

I ended up adding an invisible button and setting it as default.

Maybe this simple cheesy idea will help someone.

Upvotes: 0

Pascal Laferrière
Pascal Laferrière

Reputation: 109

One option is to override your dialog's show event so as to allow the QDialogButtonBox to be shown, after which it will have set a default button with an AcceptRole, and to then set all buttons to not be defaults.

void MyDialog::showEvent(QShowEvent* event)
{
    // When a QDialogButtonBox is shown, it will set a default button if none are found so we need to disable the
    // default buttons after the button box has been shown.
    QDialog::showEvent(event);

    // For example, with a dialog which has two buttons, Save and Cancel, we remove all defaults
    // It might be good enough to remove the default on just the buttons with have the AcceptRole, but
    // I didn't test extensively enough to see what would happen if any buttons had "autoDefault" set or
    // verify this behavior on all platforms.
    ui->buttonBox->button(QDialogButtonBox::Save)->setDefault(false);
    ui->buttonBox->button(QDialogButtonBox::Cancel)->setDefault(false);
}

Attempting to remove defaults before the QDialogButtonBox is shown, such as in the constructor of your dialog, will just be overriden by the code in the QDialogButtonBox::showEvent().

Upvotes: 4

kblst
kblst

Reputation: 519

The key is to set your own buttons, all with NoRole, and neither accept or reject signals from the buttonbox. This will allow you to set your own behavior for the default button.

class Dialog(QDialog):
    def __init__():
        super(Dialog, self).__init__()
        self.buttonBox = QDialogButtonBox()

        self.btn_save = self.buttonBox.addButton('Save', QDialogButtonBox.NoRole)
        self.btn_cancel = self.buttonBox.addButton('Cancel', QDialogButtonBox.NoRole)
        self.btn_save.clicked.connect(self.onAccept)
        self.btn_save.setMouseTracking(True)
        self.btn_cancel.clicked.connect(self.onReject)

        #  STATUS BAR
        self.status = QStatusBar()
        self.status.addPermanentWidget(self.buttonBox)

    def onAccept(self):
        if not self.btn_save.underMouse():
            return
        self.submitChanges(self.model)
        self.accept()

    def onReject(self):
        self.reject()

Upvotes: 0

魔大农
魔大农

Reputation: 136

In your dialog's accept() method, check the Ok-button for focus:

void accept() override
{ if (!dialogButtonBox->button(QDialogButtonBox::Ok)->hasFocus())
  return;

...

  QDialog::accept();
}

Upvotes: 1

Mohammad Kanan
Mohammad Kanan

Reputation: 4602

To avoid "OK" button or "Enter" key from closing dialog: in the ui xml file, remove the connect/slot for accept/reject. Then, in your code , emmit accept() when and as needed;

example from ui file which connects accept() slot:

 <connections>  
  <connection>  

   <sender>products_ButtonBox</sender>

    <signal>accepted()</signal>  

     <receiver>Products_Dialog</receiver>
      <slot>accept()</slot>
       <hints>
        <hint type="sourcelabel">
         <x>248</x>
         <y>254</y>
        </hint>
        <hint type="destinationlabel">
         <x>157</x>
         <y>274</y>
        </hint>e
       </hints>
      </connection>

Upvotes: 2

Pete
Pete

Reputation: 4812

If you have normal QPushButtons on the dialog then if the buttons have the autoDefault and/or default properties set on them then you get a default button - which is what the enter key triggers. In that case, get rid of autoDefault on the buttons and pressing enter in another widget no longer closes the dialog.

In the case of a QDialogButtonBox you can probably iterate over the buttons to turn this stuff off in the ctor of your dialog. Not tested here but ought to work. If not then you'll need to also see if there is a default button that gets set on the QDialog itself too.

Upvotes: 7

coyotte508
coyotte508

Reputation: 9725

The problem is the event filter shouldn't be installed on the OK button.

If your OK button is disabled, then it's not going to receive the enter event. Whichever widget has the focus will. And if they don't accept the enter event, then QDialog is going to accept() itself.

Two ways to solve the problem:

1) Override QDialog::accept(), and call QDialog's accept method in the new accept function only if OK is enabled

void MyDialog::accept() {
    if (okEnabled) {
        QDialog::accept();
    }
}

2) Install an event filter on every widget in the dialog that doesn't accept the enter key (line edits, ...).

The event filter would be like so:

class KeyPressEater : public QObject
{
    Q_OBJECT

protected:
    bool eventFilter(QObject *obj, QEvent *event);
};

bool KeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        bool res = QObject::eventFilter(obj, event);

        if (keyEvent->key() == Qt::Key_Return) {
            return true; /* Always accept return */
        } else {
            return res;
        }
    } else {
        // standard event processing
        return QObject::eventFilter(obj, event);
    }
}

And in your code, for each widget in the dialog:

myWidget->installEventFilter(myKeyPressEater);

Upvotes: 2

The Doctor
The Doctor

Reputation: 404

In PySide (and I imagine PyQt) I was able to redefine the accept and reject functions of the QDialog.

def custom_accept ():
    # perform custom actions when you hit open
    pass

def custom_reject ():
    # perform custom actions when you hit cancel
    pass

file_dialog = QtGui.QFileDialog(directory=".")
file_dialog.accept = custom_accept
file_dialog.reject = custom_reject

This kept the file dialog from closing and gave me access to the data when the 'ok' (accept) or 'cancel' (reject) functions were triggered (either with enter or by clicking the buttons)

Upvotes: -1

Md. Minhazul Haque
Md. Minhazul Haque

Reputation: 638

QDialog has a private slot called accept(). Whenever QDialogButtonBox emits accepted() (by pressing return key or clicking Ok), that private slot is called. So try disconnecting them.

disconnect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept()));

This worked for me.

Upvotes: 1

alexisdm
alexisdm

Reputation: 29896

The key press event filtering should be done on the dialog itself, because the code handling the forwarding of the Return and Enter keys to the default button is in QDialog::keyPressEvent.

void Dialog::keyPressEvent(QKeyEvent *evt)
{
    if(evt->key() == Qt::Key_Enter || evt->key() == Qt::Key_Return)
        return;
    QDialog::keyPressEvent(evt);
}

Or 

theDialog−>installEventFilter(anotherClassObject);

bool AnotherClass::eventFilter(QObject *obj, QEvent *evt)
{
    if(evt->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(evt);
        if(keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return )
            return true; // mark the event as handled
    }
    return false;
}

Upvotes: 21

Related Questions