Block change action on controls

I'm actually looking for a way to know about the action on the controls, but with the option to stop the modification (something like a notification listener where we need to return true or false to confirm the modification).

Note: thanks to @mKorbel's comment / feedback below I fully understood your problem.

Let's start with JSpinner . As suggested, you can use PropertyChangeListener and / or PropertyChangeSupport to listen for changes to value properties. Actually I would say that the simplest / best approach actually attaches PropertyChangeListener

to a text field that is part of the spinner editor, just because that component can be updated either by clicking the up / down buttons or manually entering the value, and updated (by contract ) by model change events.

That being said, please consider this snippet:

final JSpinner spinner = new JSpinner(new SpinnerNumberModel(1, 1, 4, 1));
JSpinner.NumberEditor editor = (JSpinner.NumberEditor) spinner.getEditor();
JFormattedTextField textField = editor.getTextField();
textField.addPropertyChangeListener("value", new PropertyChangeListener() {...});

      

        
        
        
      

    

Now you need a mechanism to store the last valid rollback value if the user regrets the issue (i.e. a simple fallback variable with enough scope to be accessed from propertyChange (PropertyChangeEvent evt) ). In addition, you have old and new values ​​available through the PropertyChangeEvent API to check and check if the new value is exactly the same value that was stored in the fallback variable. See the example below for a better understanding.

Now focus on the JToggleButton . In this case, I replaced the ActionListener with an ItemListener to count with the new button state (selected / deselected ) directly from the ItemEvent . Something like that:

final JToggleButton button = new JToggleButton("Toggle");
button.addItemListener(new ItemListener() {...});

      

        
        
        
      

    

Once again, you will need a mechanism to keep the last valid value of this toggle button and be able to rollback user changes if they think they are inappropriate. Beware of element changes being triggered twice: the first time to notify the old state and the second time to notify the new state. Therefore, you will have to ignore the first call just because it is the most current state. See the example below for a better understanding.

Example

Try this complete example. I think it suits your requirements.

import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JToggleButton;
import javax.swing.SpinnerNumberModel;
import javax.swing.SwingUtilities;

/**
 * @author dic19
 */
public class Demo {

    private Object backupSpinnerValue;
    private Boolean backupButtonState;

    public void createAndShowGUI() {

        final JSpinner spinner = new JSpinner(new SpinnerNumberModel(1, 1, 4, 1));
        JSpinner.NumberEditor editor = (JSpinner.NumberEditor) spinner.getEditor();
        JFormattedTextField textField = editor.getTextField();
        textField.addPropertyChangeListener("value", new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                Object oldValue = evt.getOldValue();
                Object newValue = evt.getNewValue();
                if (!evt.getNewValue().equals(backupSpinnerValue)) { // Just ignore if they're the same
                    if (Demo.this.confirmChanges(oldValue, newValue)) {
                        backupSpinnerValue = newValue;
                    } else {
                        spinner.setValue(backupSpinnerValue);
                    }
                }
            }
        });

        final JToggleButton button = new JToggleButton("Toggle");
        button.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {
                Boolean isSelected = e.getStateChange() == ItemEvent.SELECTED;
                if (!isSelected.equals(backupButtonState)) { // Just ignore if they're the same
                    if (Demo.this.confirmChanges(backupButtonState, isSelected)) {
                        backupButtonState = isSelected;
                    }
                    button.setSelected(backupButtonState);
                }
            }
        });

        backupSpinnerValue = spinner.getValue();
        backupButtonState = button.isSelected();

        JPanel content = new JPanel();
        content.add(spinner);
        content.add(button);

        JFrame frame = new JFrame("Demo");
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(content);
        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    private boolean confirmChanges(Object oldValue, Object newValue) {
        String message = String.format("Do you want to confirm changes from value '%1s' to '%2s'?", oldValue, newValue);
        int option = JOptionPane.showConfirmDialog(null, message, "Confirm changes", JOptionPane.OK_CANCEL_OPTION);
        return option == JOptionPane.OK_OPTION;
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new Demo().createAndShowGUI();
            }
        });
    }
}

      

        
        
        
      

    

Other comments

1) In these lines:

tf = new JTextField(20);
tf.addKeyListener(new KeyListener(){...});

      

        
        
        
      

    

Please note that KeyListener is not the right choice if you want to listen for a change in a text box. You have to use DocumentListener . See How to write a document listener

2) Swing components are intended to be used "as is", therefore composition is preferred over inheritance. Therefore, you should consider removing extends JFrame

in the class declaration and instead add all your components to the local frame. See also this thread: Extends a JFrame and creates it inside a program

3) Always include the default close operation in top level containers (windows):

public class SwingTest extends JFrame {
   ...
   private void initComponents() {
       ...
       setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
   }
}

      

        
        
        
      

    

4) If you are interested in a more elegant / complex approach than simple variables to get states to look at the Memento pattern . This template allows you to save not only one previous state, but the entire state changes history.