I need to perform an action after the JFrame is closed and I have this part of code for it, but this doesn't work.
Could anyone please advise what should be change here?
private void changeDefaults(){
Thread changeDefaultsThread = new Thread(new Runnable(){
public void run(){
Change ch = new Change();
ch.setVisible(true);
ch.setListeners();
ch.defaultInput();
while(ch.isActive()){
System.out.println("active");
}
updateDefaults();
}
});
changeDefaultsThread.start();
}
Change is the JFrame I am opening for another action.
You can add listener to your JFrame
frame.addWindowListener (new java.awt.event.WindowAdapter)
and override the windowClosing
#Override
public void windowClosing
frame.addWindowListener(new java.awt.event.WindowAdapter() {
#Override
public void windowClosing(java.awt.event.WindowEvent windowEvent) {
//do something
}
});
I'm surprised no one has mentioned the simplest solution: don't use a JFrame. The best tool for this behavior -- displaying a child window and doing something immediately after it has closed -- is to use a modal dialog window such as a JDialog or JOptionPane. The JDialog set up code is very similar to that of the JFrame, with an exception being that it uses different constructors, and should have the parent window passed into it, and it uses a subset of the default close operations.
If you use a modal dialog, then program flow is halted in the calling code immediately after the dialog has been displayed (think of how a JOptionPane operates), and then immediately resumes from the spot after calling setVisible(true) on the dialog once the dialog has been closed.
The only bugaboo is that if you don't want modal behavior -- if you don't want the parent/calling window to be disabled while the child window is displayed -- then you'll have to use a non-modal JDialog window with a WindowListener.
If you want to perform an action when closing a JFrame, you just need to attach a WindowListener (extending WindowAdapter so that you do not need to implement all WindowListener methods):
import javax.swing.*;
public class AfterJFrameClose {
public static void main(String[] args) {
JFrame frame = new JFrame("My frame");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
frame.setAlwaysOnTop(true);
frame.addWindowListener(new java.awt.event.WindowAdapter() {
#Override
public void windowClosing(java.awt.event.WindowEvent windowEvent) {
System.out.println("Frame closing");
}
});
}
}
Instead of the System.out.println, just write the code you want to have executed.
Update: If you want to access another frame, you either should pass it as a parameter as suggested above or you can also iterate through active frames using something like this:
Frame[] frames = Frame.getFrames();
for (Frame frame: frames) {
System.out.println(frame.getTitle());
}
I have a JDialog in my java code, I want to get the indication when the user closes the JDialog, Is there any way in java to get indication when user closes the JDialog???
Simply add a WindowListener to it and override the windowClosing() or windowClosed() methods.
WindowListener.windowClosing() is called when the user attempts to close the window, WindowListener.windowClosed() is called when the window has been closed.
Example:
dialog.addWindowListener(new WindowAdapter() {
#Override
public void windowClosing(WindowEvent e) {
System.out.println("User attempted to close the dialog!");
}
});
For a modal dialog, then the code after the call that shows the dialog will not continue until the dialog is closed. I.e.,
JDialog dialog = new JDialog((Frame)null, true); // true = modal
System.out.println("before");
dialog.setVisible();
System.out.println("after"); // <-- won't happen until the dialog is closed
For a non-modal dialog, call dialog.addWindowListener as you would with any other window, with a WindowListener (or WindowAdapter) and override either windowClosing or windowClosed, depending on whether you need to prevent closure or merely detect it.
For best control this I suggest to You to create your own class of dialog that extends Jdialog and then to overwrite the functions setVisible(boolen value) and dispose() . By default when user click close button dialog goes to funciton setVisible(false) but you can change this using setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE). Here is a simple code.
public class MyDialog extends JDialog {
public MyDialog(){
super();
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setSize(new Dimension(200,200));
setVisible(true);
}
public void dispose(){
System.out.println("dialog disposed");
// put your code here
super.dispose();
}
public void setVisible(boolean value) {
System.out.println("dialog set visible : " + value);
// or put your code here
super.setVisible(value);
}
}
I'm integrating an applet and I need to hack one of the dialog and change its modality.
My problem is I don't know Swing, and my attempts have no effect in practice.
Current implementation:
dialog.setModalExclusionType(ModalExclusionType.TOOLKIT_EXCLUDE);
dialog.repaint();
also tried
dialog.setModal(false);
So there is my question. How can I dynamically change the modality of an existing JDialog ?
don't know what you try to do ...
but maybe you can get something from here
public class Mainz extends JFrame implements ActionListener{
JButton showDialog = new JButton("show dialog");
public Mainz() {
setLayout(new FlowLayout());
showDialog.addActionListener(this);
add(showDialog);
setSize(200, 300);
setVisible(true);
}
#Override
public void actionPerformed(ActionEvent e) {
new Dialogz(this, false);
setEnabled(false);
}
public static void main(String[]args){
new Mainz();
}
}
class Dialogz extends JDialog{
JButton close = new JButton("close");
public Dialogz(JFrame owner,boolean modal) {
super(owner, modal);
setSize(100, 200);
add(close);
setLocationRelativeTo(owner);
setVisible(true);
close.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae){
closez();
}
});
}
void closez(){
setModalExclusionType(ModalExclusionType.APPLICATION_EXCLUDE);
System.out.println("modal exclusion befor = "+getModalExclusionType());
setModalExclusionType(ModalExclusionType.NO_EXCLUDE);
System.out.println("modal exclusion after = "+getModalExclusionType());
System.out.println("modality before ="+getModalityType());
setModal(true);
System.out.println("modality after ="+getModalityType());
getOwner().setEnabled(true);
Dialogz.this.dispose();
}
}
A hack for a hack:
you can change the modality of an existing dialog by calling the private method:
java.awt.Dialog.hideAndDisposePreHandler();
To call this private method - as an example:
private void executeMethod(final Class<?> clazz, final String methodName, final Object instance)
{
final Method method =
Iterables.getOnlyElement(Iterables.filter(
Arrays.asList(clazz.getDeclaredMethods()), new Predicate<Method>()
{
public boolean apply(final Method method)
{
return method.getName().equals(methodName);
}
}));
method.setAccessible(true);
try
{
method.invoke(instance);
}
catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e)
{
throw Throwables.propagate(e);
}
}
(This code requires Guava)
And finally call it:
final Dialog myDialog = ...;
executeMethod(Dialog.class, "hideAndDisposePreHandler", myDialog);
To change whether your dialog is modal or modeless, use setModalityType method.
When you call setModal(true), modality type is the same as calling setModalityType(Dialog.DEFAULT_MODALITY_TYPE). The default value is ModalityType.APPLICATION_MODAL.
When you call setModal(false), modality type is set to ModalityType.MODELESS.
The dialog should be not visible when you change its modality. Otherwise, it will not take effect until the dialog is hidden and then shown again.
Moreover the dialog itself has to be programmed to support different modality modes.
When you use a modal dialog, interaction with the owner window (and possibly with other application windows) is blocked. So you show the dialog, dialog.setVisible(true) and this method does not return until the dialog is closed. Then you use the data from the dialog.
A typical modal dialog is Open File: the application can't proceed until it knows which file to load.
In case of modeless dialog, the method dialog.setVisible(true) returns immediately (after showing the dialog on the screen). Pressing buttons in the dialog usually has some effect on other windows and dialogs. And you can interact with other windows of the application while the dialog is shown.
For example, a typical Find dialog selects a search string in the main window. You can return to the main window, and change text, then click Find again and so on.
If you need more help, I can show you a working sample with dialog which works in both modes: modal and modeless.
I guess that you haven't acquired the AWTPermission.toolkitModality permission for your applet.
Another problem could be that the exclusion type isn't supported on your platform -- you can check this with Toolkit.isModalExclusionTypeSupported(java.awt.Dialog.ModalExclusionType).
I have two radio buttons in frame1. On click on enable radio button, it will popup another frame called frame2. I want, not to close the frame1 while the frame2 is opened. But it get closed when click on the X. I used "frame1.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);". Still it get closed.
enable.addItemListener(new ItemListener()
{
#Override
public void itemStateChanged(ItemEvent e)
{
// TODO Auto-generated method stub
frame2.setVisible(true);
frame1.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
There are number of methods to get the list of active window instances and verify which frame/window is visible or not.
Window.getOwnedWindows()
Window.getWindows()
Window.getOwnerlessWindows()
Frame.getFrames()
Have a look here:
How can a Swing WindowListener veto JFrame closing
What you will need to do is, in frame1 and frame2 you will need to set setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE). Then in the below code:
frame1.addWindowListener(new WindowAdapter() {
#Override
public void windowClosing(WindowEvent e) {
//check is frame 2 is open.. if it is then return without doing anything, else
// frame1.dispose();
}
});
In case you need to work with the frame2 only, you may try to use dialogs.
A brief googling discovered another solution as well.
What's the correct way to get a JFrame to close, the same as if the user had hit the X close button, or pressed Alt+F4 (on Windows)?
I have my default close operation set the way I want, via:
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
It does exactly what I want with the aforementioned controls. This question isn't about that.
What I really want to do is cause the GUI to behave in the same way as a press of X close button would cause it to behave.
Suppose I were to extend WindowAdaptor and then add an instance of my adaptor as a listener via addWindowListener(). I would like to see the same sequence of calls through windowDeactivated(), windowClosing(), and windowClosed() as would occur with the X close button. Not so much tearing up the window as telling it to tear itself up, so to speak.
If you want the GUI to behave as if you clicked the X close button then you need to dispatch a window closing event to the Window. The ExitAction from Closing An Application allows you to add this functionality to a menu item or any component that uses Actions easily.
frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));
setVisible(false); //you can't see me!
dispose(); //Destroy the JFrame object
Not too tricky.
If by Alt-F4 or X you mean "Exit the Application Immediately Without Regard for What Other Windows or Threads are Running", then System.exit(...) will do exactly what you want in a very abrupt, brute-force, and possibly problematic fashion.
If by Alt-F4 or X you mean hide the window, then frame.setVisible(false) is how you "close" the window. The window will continue to consume resources/memory but can be made visible again very quickly.
If by Alt-F4 or X you mean hide the window and dispose of any resources it is consuming, then frame.dispose() is how you "close" the window. If the frame was the last visible window and there are no other non-daemon threads running, the program will exit. If you show the window again, it will have to reinitialize all of the native resources again (graphics buffer, window handles, etc).
dispose() might be closest to the behavior that you really want. If your app has multiple windows open, do you want Alt-F4 or X to quit the app or just close the active window?
The Java Swing Tutorial on Window Listeners may help clarify things for you.
Stop the program:
System.exit(0);
Close the window:
frame.dispose();
Hide the window:
frame.setVisible(false);
If you have done this to make sure the user can't close the window:
frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
Then you should change your pullThePlug() method to be
public void pullThePlug() {
// this will make sure WindowListener.windowClosing() et al. will be called.
WindowEvent wev = new WindowEvent(this, WindowEvent.WINDOW_CLOSING);
Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(wev);
// this will hide and dispose the frame, so that the application quits by
// itself if there is nothing else around.
setVisible(false);
dispose();
// if you have other similar frames around, you should dispose them, too.
// finally, call this to really exit.
// i/o libraries such as WiiRemoteJ need this.
// also, this is what swing does for JFrame.EXIT_ON_CLOSE
System.exit(0);
}
I found this to be the only way that plays nice with the WindowListener and JFrame.DO_NOTHING_ON_CLOSE.
Exiting from Java running process is very easy, basically you need to do just two simple things:
Call java method System.exit(...) at at application's quit point.
For example, if your application is frame based, you can add listener WindowAdapter and and call System.exit(...) inside its method windowClosing(WindowEvent e).
Note: you must call System.exit(...) otherwise your program is error involved.
Avoiding unexpected java exceptions to make sure the exit method can be called always.
If you add System.exit(...) at right point, but It does not mean that the method can be called always, because unexpected java exceptions may prevent the method from been called.
This is strongly related to your programming skills.
** Following is a simplest sample (JFrame based) which shows you how to call exit method
import java.awt.event.*;
import javax.swing.*;
public class ExitApp extends JFrame
{
public ExitApp()
{
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
System.exit(0); //calling the method is a must
}
});
}
public static void main(String[] args)
{
ExitApp app=new ExitApp();
app.setBounds(133,100,532,400);
app.setVisible(true);
}
}
Not only to close the JFrame but also to trigger WindowListener events, try this:
myFrame.dispatchEvent(new WindowEvent(myFrame, WindowEvent.WINDOW_CLOSING));
Best way to close a Swing frame programmatically is to make it behave like it would when the "X" button is pressed. To do that you will need to implement WindowAdapter that suits your needs and set frame's default close operation to do nothing (DO_NOTHING_ON_CLOSE).
Initialize your frame like this:
private WindowAdapter windowAdapter = null;
private void initFrame() {
this.windowAdapter = new WindowAdapter() {
// WINDOW_CLOSING event handler
#Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
// You can still stop closing if you want to
int res = JOptionPane.showConfirmDialog(ClosableFrame.this, "Are you sure you want to close?", "Close?", JOptionPane.YES_NO_OPTION);
if ( res == 0 ) {
// dispose method issues the WINDOW_CLOSED event
ClosableFrame.this.dispose();
}
}
// WINDOW_CLOSED event handler
#Override
public void windowClosed(WindowEvent e) {
super.windowClosed(e);
// Close application if you want to with System.exit(0)
// but don't forget to dispose of all resources
// like child frames, threads, ...
// System.exit(0);
}
};
// when you press "X" the WINDOW_CLOSING event is called but that is it
// nothing else happens
this.setDefaultCloseOperation(ClosableFrame.DO_NOTHING_ON_CLOSE);
// don't forget this
this.addWindowListener(this.windowAdapter);
}
You can close the frame programmatically by sending it the WINDOW_CLOSING event, like this:
WindowEvent closingEvent = new WindowEvent(targetFrame, WindowEvent.WINDOW_CLOSING);
Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(closingEvent);
This will close the frame like the "X" button was pressed.
If you really do not want your application to terminate when a JFrame is closed then,
use : setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
instead of : setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Here's a synopsis of what the solution looks like,
myFrame.dispatchEvent(new WindowEvent(myFrame, WindowEvent.WINDOW_CLOSING));
This examples shows how to realize the confirmed window close operation.
The window has a Window adapter which switches the default close operation to EXIT_ON_CLOSEor DO_NOTHING_ON_CLOSE dependent on your answer in the OptionDialog.
The method closeWindow of the ConfirmedCloseWindow fires a close window event and can be used anywhere i.e. as an action of an menu item
public class WindowConfirmedCloseAdapter extends WindowAdapter {
public void windowClosing(WindowEvent e) {
Object options[] = {"Yes", "No"};
int close = JOptionPane.showOptionDialog(e.getComponent(),
"Really want to close this application?\n", "Attention",
JOptionPane.YES_NO_OPTION,
JOptionPane.INFORMATION_MESSAGE,
null,
options,
null);
if(close == JOptionPane.YES_OPTION) {
((JFrame)e.getSource()).setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE);
} else {
((JFrame)e.getSource()).setDefaultCloseOperation(
JFrame.DO_NOTHING_ON_CLOSE);
}
}
}
public class ConfirmedCloseWindow extends JFrame {
public ConfirmedCloseWindow() {
addWindowListener(new WindowConfirmedCloseAdapter());
}
private void closeWindow() {
processWindowEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
}
}
Based on the answers already provided here, this is the way I implemented it:
JFrame frame= new JFrame()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// frame stuffs here ...
frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));
The JFrame gets the event to close and upon closing, exits.
You have to insert the call into the AWT message queue so all the timing happens correctly, otherwise it will not dispatch the correct event sequence, especially in a multi-threaded program. When this is done you may handle the resulting event sequence exactly as you would if the user has clicked on the [x] button for an OS suppled decorated JFrame.
public void closeWindow()
{
if(awtWindow_ != null) {
EventQueue.invokeLater(new Runnable() {
public void run() {
awtWindow_.dispatchEvent(new WindowEvent(awtWindow_, WindowEvent.WINDOW_CLOSING));
}
});
}
}
I have tried this, write your own code for formWindowClosing() event.
private void formWindowClosing(java.awt.event.WindowEvent evt) {
int selectedOption = JOptionPane.showConfirmDialog(null,
"Do you want to exit?",
"FrameToClose",
JOptionPane.YES_NO_OPTION);
if (selectedOption == JOptionPane.YES_OPTION) {
setVisible(false);
dispose();
} else {
setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
}
}
This asks user whether he want to exit the Frame or Application.
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Posting what was in the question body as CW answer.
Wanted to share the results, mainly derived from following camickr's link. Basically I need to throw a WindowEvent.WINDOW_CLOSING at the application's event queue. Here's a synopsis of what the solution looks like
// closing down the window makes sense as a method, so here are
// the salient parts of what happens with the JFrame extending class ..
public class FooWindow extends JFrame {
public FooWindow() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(5, 5, 400, 300); // yeah yeah, this is an example ;P
setVisible(true);
}
public void pullThePlug() {
WindowEvent wev = new WindowEvent(this, WindowEvent.WINDOW_CLOSING);
Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(wev);
}
}
// Here's how that would be employed from elsewhere -
// someplace the window gets created ..
FooWindow fooey = new FooWindow();
...
// and someplace else, you can close it thusly
fooey.pullThePlug();
If you do not want your application to terminate when a JFrame is closed,
use:
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
instead of:
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
From the documentation:
DO_NOTHING_ON_CLOSE (defined in WindowConstants): Don't do anything; require the program to handle the operation in the windowClosing method of a registered WindowListener object.
HIDE_ON_CLOSE (defined in WindowConstants): Automatically hide the frame after invoking any registered WindowListener objects.
DISPOSE_ON_CLOSE (defined in WindowConstants): Automatically hide and dispose the frame after invoking any registered WindowListener objects.
EXIT_ON_CLOSE (defined in JFrame): Exit the application using the System exit method. Use this only in applications.
might still be useful:
You can use setVisible(false) on your JFrame if you want to display the same frame again.
Otherwise call dispose() to remove all of the native screen resources.
copied from Peter Lang
https://stackoverflow.com/a/1944474/3782247