skrueger/swing/CancellableDialogAdapter.java

package skrueger.swing;

import java.awt.Component;
import java.awt.Dialog;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JOptionPane;
import javax.swing.JRootPane;
import javax.swing.KeyStroke;

import schmitzm.swing.SwingUtil;

/**
 * An abstract {@link JDialog} that implements a basic structure of how
 * cancellable {@link JDialog}s work. The {@link JDialog} is designed to work on
 * the real object and restore it's state when the user cancels the
 * {@link JDialog}.
 * 
 * Pressing ESC or clicking the "Close X" results in asking the user whether to Save/Cancel/Abort .  
 */
public abstract class CancellableDialogAdapter extends JDialog implements
                CancellableDialog {

        protected boolean cancelled = false;

        @Override
        public boolean isCancelled() {
                return cancelled;
        }

        public CancellableDialogAdapter(final Component parentWindow, String title) {
                super(SwingUtil.getParentWindow(parentWindow), title);
                initDialog();
        }

        public CancellableDialogAdapter(final Component parentWindow) {
                this(parentWindow, null);
        }

        private void initDialog() {

                setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);

                addWindowListener(new WindowAdapter() {

                        @Override
                        public void windowClosing(WindowEvent e) {
                                close();
                        }

                });
        }

        /**
         * Allows to close the {@link JDialog} from "outside". The user will be
         * asked and she may cancel the close process.
         */
        public boolean close() {
                int showConfirmDialog = JOptionPane.showConfirmDialog(
                                CancellableDialogAdapter.this, "Speichern?",
                                "Änderungen speichern?", JOptionPane.YES_NO_CANCEL_OPTION); // i8n

                if (showConfirmDialog == JOptionPane.YES_OPTION) {
                        return okClose();
                }
                else if (showConfirmDialog == JOptionPane.NO_OPTION) {
                        cancelClose();
                        return true;
                }
                
                return false;
        }
        

        /**
         * This method can be called from "outside" to force a close of this
         * {@link Dialog}. The user can't cancel the process. He may only decide to
         * save possible changes.
         */
        public void forceClose() {

                int res = JOptionPane.showConfirmDialog(
                                CancellableDialogAdapter.this, "Speichern?",
                                "Der Dialog muss nu gesclossen werden. Änderungen speichern?", JOptionPane.YES_NO_OPTION); // i8n
                
                if (res == JOptionPane.YES_OPTION) {
                        okClose();
                } else {
                        cancelClose();
                }
        }
        

        /**
         * Default implementation that calls {@link #cancel()} and
         * {@link #dispose()}.
         */
        @Override
        public void cancelClose() {
                cancel();
                dispose();
        }

        @Override
        public abstract void cancel();

        /**
         * This method is called when the dialog is closed and not canceled. Can be
         * overwritten to do anything when the dialog has been accepted. For example
         * checking for any {@link Checkable} components. <br/>
         * 
         * @Return <code>false</code>, if the ok has been vetoed.
         */
        public boolean okClose() {
                dispose();
                return true;
        }
        

        /**
         * Since the registerKeyboardAction() method is part of the JComponent class
         * definition, you must define the Escape keystroke and register the
         * keyboard action with a JComponent, not with a JDialog. The JRootPane for
         * the JDialog serves as an excellent choice to associate the registration,
         * as this will always be visible. If you override the protected
         * createRootPane() method of JDialog, you can return your custom JRootPane
         * with the keystroke enabled:
         */
        @Override
        protected JRootPane createRootPane() {
                final KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
                final JRootPane rootPane = new JRootPane();
                rootPane.registerKeyboardAction(new ActionListener() {

                        public void actionPerformed(final ActionEvent e) {
                                close();
                        }

                }, stroke, JComponent.WHEN_IN_FOCUSED_WINDOW);

                return rootPane;
        }


}
1	alfonx	420	package skrueger.swing;
2
3	alfonx	422	import java.awt.Component;
4			import java.awt.Dialog;
5	alfonx	433	import java.awt.event.ActionEvent;
6			import java.awt.event.ActionListener;
7			import java.awt.event.KeyEvent;
8	alfonx	420	import java.awt.event.WindowAdapter;
9			import java.awt.event.WindowEvent;
10
11	alfonx	433	import javax.swing.JComponent;
12	alfonx	420	import javax.swing.JDialog;
13			import javax.swing.JOptionPane;
14	alfonx	433	import javax.swing.JRootPane;
15			import javax.swing.KeyStroke;
16	alfonx	420
17	alfonx	422	import schmitzm.swing.SwingUtil;
18
19			/**
20			* An abstract {@link JDialog} that implements a basic structure of how
21			* cancellable {@link JDialog}s work. The {@link JDialog} is designed to work on
22			* the real object and restore it's state when the user cancels the
23			* {@link JDialog}.
24	alfonx	433	*
25			* Pressing ESC or clicking the "Close X" results in asking the user whether to Save/Cancel/Abort .
26	alfonx	422	*/
27	alfonx	420	public abstract class CancellableDialogAdapter extends JDialog implements
28			CancellableDialog {
29
30			protected boolean cancelled = false;
31
32			@Override
33			public boolean isCancelled() {
34			return cancelled;
35			}
36
37	alfonx	422	public CancellableDialogAdapter(final Component parentWindow, String title) {
38			super(SwingUtil.getParentWindow(parentWindow), title);
39	alfonx	420	initDialog();
40			}
41
42	alfonx	422	public CancellableDialogAdapter(final Component parentWindow) {
43			this(parentWindow, null);
44			}
45
46	alfonx	420	private void initDialog() {
47
48			setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
49
50			addWindowListener(new WindowAdapter() {
51
52			@Override
53			public void windowClosing(WindowEvent e) {
54	alfonx	422	close();
55	alfonx	420	}
56
57			});
58			}
59
60	alfonx	422	/**
61			* Allows to close the {@link JDialog} from "outside". The user will be
62			* asked and she may cancel the close process.
63			*/
64			public boolean close() {
65			int showConfirmDialog = JOptionPane.showConfirmDialog(
66			CancellableDialogAdapter.this, "Speichern?",
67			"Änderungen speichern?", JOptionPane.YES_NO_CANCEL_OPTION); // i8n
68
69			if (showConfirmDialog == JOptionPane.YES_OPTION) {
70			return okClose();
71			}
72			else if (showConfirmDialog == JOptionPane.NO_OPTION) {
73			cancelClose();
74			return true;
75			}
76
77			return false;
78	alfonx	420	}
79	alfonx	422
80	alfonx	420
81	alfonx	422	/**
82			* This method can be called from "outside" to force a close of this
83			* {@link Dialog}. The user can't cancel the process. He may only decide to
84			* save possible changes.
85			*/
86			public void forceClose() {
87
88			int res = JOptionPane.showConfirmDialog(
89			CancellableDialogAdapter.this, "Speichern?",
90			"Der Dialog muss nu gesclossen werden. Änderungen speichern?", JOptionPane.YES_NO_OPTION); // i8n
91
92			if (res == JOptionPane.YES_OPTION) {
93			okClose();
94			} else {
95			cancelClose();
96			}
97			}
98
99
100			/**
101			* Default implementation that calls {@link #cancel()} and
102			* {@link #dispose()}.
103			*/
104	alfonx	420	@Override
105			public void cancelClose() {
106			cancel();
107			dispose();
108			}
109
110			@Override
111			public abstract void cancel();
112
113			/**
114			* This method is called when the dialog is closed and not canceled. Can be
115			* overwritten to do anything when the dialog has been accepted. For example
116	alfonx	422	* checking for any {@link Checkable} components. <br/>
117			*
118			* @Return <code>false</code>, if the ok has been vetoed.
119	alfonx	420	*/
120	alfonx	422	public boolean okClose() {
121			dispose();
122			return true;
123			}
124	alfonx	433
125	alfonx	420
126	alfonx	433	/**
127			* Since the registerKeyboardAction() method is part of the JComponent class
128			* definition, you must define the Escape keystroke and register the
129			* keyboard action with a JComponent, not with a JDialog. The JRootPane for
130			* the JDialog serves as an excellent choice to associate the registration,
131			* as this will always be visible. If you override the protected
132			* createRootPane() method of JDialog, you can return your custom JRootPane
133			* with the keystroke enabled:
134			*/
135			@Override
136			protected JRootPane createRootPane() {
137			final KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
138			final JRootPane rootPane = new JRootPane();
139			rootPane.registerKeyboardAction(new ActionListener() {
140
141			public void actionPerformed(final ActionEvent e) {
142			close();
143			}
144
145			}, stroke, JComponent.WHEN_IN_FOCUSED_WINDOW);
146
147			return rootPane;
148			}
149
150
151	alfonx	420	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain