skrueger/swing/DialogManager.java

package skrueger.swing;

import java.awt.Component;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;

import javax.swing.JDialog;

import org.apache.log4j.Logger;

public abstract class DialogManager<KEY, DIALOG extends AtlasDialog> {
        final static private Logger LOGGER = Logger.getLogger(DialogManager.class);

        public abstract class FactoryInterface {

                public abstract DIALOG create();

                /** May be overridden to add Listeners **/
                public void afterCreation(DIALOG newInstance) {
                };

                /** May be overridden to remove Listeners added earlier **/
                public void beforeDispose(DIALOG newInstance) {
                };

        }

        protected HashMap<KEY, DIALOG> dialogCache = new HashMap<KEY, DIALOG>();

        /**
         * A {@link DialogManager} instance can be created for any extension of
         * {@link JDialog} that will implement the
         * {@link #getInstanceFor(Object, Component, Object...)} method.
         */
        public DialogManager() {
        }

        /**
         * This will be done with every dialog that an instance is required for.
         * 
         * @param dialog
         * @return
         */
        protected DIALOG bringup(DIALOG dialog) {
                if (!dialog.isVisible())
                        dialog.setVisible(true);
                dialog.toFront();

                return dialog;
        }

        /**
         * Implementing this should have a <br/>
         * <code>try { ... return ... } catch (Exception e) {
                                ExceptionDialog.show(owner, e);
                                return null;
                        } </code> block.
         * 
         * @param key
         * @param owner
         * @param constArgs
         * @return a cached instance or creates a new instance. Instances are always
         *         returned visible and toFront.
         */
        public abstract DIALOG getInstanceFor(final KEY key, final Component owner,
                        final Object... constArgs);

        /**
         * @return Is there an open/visible dialog for the given layer id?
         */
        public boolean isVisibleFor(KEY key) {
                return dialogCache.containsKey(key) && dialogCache.get(key).isVisible();
        }

        /**
         * Will dispose any dialog that is registered to the given parent
         * {@link Component}
         * 
         * @param parent
         */
        public void disposeInstanceForParent(final Component parent) {

                final HashMap<KEY, JDialog> clonedHashMap = (HashMap<KEY, JDialog>) dialogCache
                                .clone();

                for (KEY chartId : clonedHashMap.keySet()) {
                        if (dialogCache.get(chartId).getParent() == parent) {
                                disposeInstanceFor(chartId);
                        }
                }
        }

        public boolean disposeInstanceFor(KEY key) {
                synchronized (dialogCache) {

                        final DIALOG dialog = dialogCache.get(key);
                        if (dialog != null) {
                                dialog.dispose();
                                dialogCache.remove(key);
                                return true;
                        }
                        return false;
                }
        }

        /**
         * Checks whether there already is an instance for that key and otherwise
         * will create the instance by invoking the {@link FactoryInterface} #create
         * method.
         * 
         * @param factory
         *            {@link FactoryInterface} that creates the DIALOG
         * 
         * @return Always a visible and inFront instance of DIALOG for the given
         *         key.
         */
        public DIALOG getInstanceFor(final KEY key, final FactoryInterface factory) {
                final DIALOG dialog;
                if (isVisibleFor(key)) {
                        dialog = dialogCache.get(key);
                } else {

                        dialog = factory.create();
                        dialogCache.put(key, dialog);
                        dialog.setVisible(true);
                        dialog.toFront();

                        dialog.addWindowListener(new WindowAdapter() {
                                @Override
                                public void windowClosed(final WindowEvent e) {
                                        dialogCache.remove(key);
                                        factory.beforeDispose(dialog);
                                }

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

                        factory.afterCreation(dialog);
                }

                return dialog;
        }

        /**
         * Disposes all open instances and removes them from the cache.
         * 
         * @return <code>true</code> if at least one window has been disposed.
         */
        public boolean disposeAll() {

                boolean atLeastOne = false;
                HashSet<KEY> tempKeys = new HashSet<KEY>(dialogCache.keySet());
                for (KEY key : tempKeys) {
                        DIALOG dialog = dialogCache.get(key);
                        if (dialog != null) {
                                dialog.dispose();
                                atLeastOne = true;
                        }
                }
                tempKeys.clear();
                dialogCache.clear();
                return atLeastOne;
        }

        /**
         * @return All instances of DIALOG as they are cached.
         */
        public Collection<DIALOG> getAllInstances() {
                return dialogCache.values();
        }

}
1	package skrueger.swing;
2
3	import java.awt.Component;
4	import java.awt.event.WindowAdapter;
5	import java.awt.event.WindowEvent;
6	import java.util.Collection;
7	import java.util.HashMap;
8	import java.util.HashSet;
9
10	import javax.swing.JDialog;
11
12	import org.apache.log4j.Logger;
13
14	public abstract class DialogManager<KEY, DIALOG extends AtlasDialog> {
15	final static private Logger LOGGER = Logger.getLogger(DialogManager.class);
16
17	public abstract class FactoryInterface {
18
19	public abstract DIALOG create();
20
21	/ May be overridden to add Listeners /
22	public void afterCreation(DIALOG newInstance) {
23	};
24
25	/ May be overridden to remove Listeners added earlier /
26	public void beforeDispose(DIALOG newInstance) {
27	};
28
29	}
30
31	protected HashMap<KEY, DIALOG> dialogCache = new HashMap<KEY, DIALOG>();
32
33	/**
34	* A {@link DialogManager} instance can be created for any extension of
35	* {@link JDialog} that will implement the
36	* {@link #getInstanceFor(Object, Component, Object...)} method.
37	*/
38	public DialogManager() {
39	}
40
41	/**
42	* This will be done with every dialog that an instance is required for.
43	*
44	* @param dialog
45	* @return
46	*/
47	protected DIALOG bringup(DIALOG dialog) {
48	if (!dialog.isVisible())
49	dialog.setVisible(true);
50	dialog.toFront();
51
52	return dialog;
53	}
54
55	/**
56	* Implementing this should have a <br/>
57	* <code>try { ... return ... } catch (Exception e) {
58	ExceptionDialog.show(owner, e);
59	return null;
60	} </code> block.
61	*
62	* @param key
63	* @param owner
64	* @param constArgs
65	* @return a cached instance or creates a new instance. Instances are always
66	* returned visible and toFront.
67	*/
68	public abstract DIALOG getInstanceFor(final KEY key, final Component owner,
69	final Object... constArgs);
70
71	/**
72	* @return Is there an open/visible dialog for the given layer id?
73	*/
74	public boolean isVisibleFor(KEY key) {
75	return dialogCache.containsKey(key) && dialogCache.get(key).isVisible();
76	}
77
78	/**
79	* Will dispose any dialog that is registered to the given parent
80	* {@link Component}
81	*
82	* @param parent
83	*/
84	public void disposeInstanceForParent(final Component parent) {
85
86	final HashMap<KEY, JDialog> clonedHashMap = (HashMap<KEY, JDialog>) dialogCache
87	.clone();
88
89	for (KEY chartId : clonedHashMap.keySet()) {
90	if (dialogCache.get(chartId).getParent() == parent) {
91	disposeInstanceFor(chartId);
92	}
93	}
94	}
95
96	public boolean disposeInstanceFor(KEY key) {
97	synchronized (dialogCache) {
98
99	final DIALOG dialog = dialogCache.get(key);
100	if (dialog != null) {
101	dialog.dispose();
102	dialogCache.remove(key);
103	return true;
104	}
105	return false;
106	}
107	}
108
109	/**
110	* Checks whether there already is an instance for that key and otherwise
111	* will create the instance by invoking the {@link FactoryInterface} #create
112	* method.
113	*
114	* @param factory
115	* {@link FactoryInterface} that creates the DIALOG
116	*
117	* @return Always a visible and inFront instance of DIALOG for the given
118	* key.
119	*/
120	public DIALOG getInstanceFor(final KEY key, final FactoryInterface factory) {
121	final DIALOG dialog;
122	if (isVisibleFor(key)) {
123	dialog = dialogCache.get(key);
124	} else {
125
126	dialog = factory.create();
127	dialogCache.put(key, dialog);
128	dialog.setVisible(true);
129	dialog.toFront();
130
131	dialog.addWindowListener(new WindowAdapter() {
132	@Override
133	public void windowClosed(final WindowEvent e) {
134	dialogCache.remove(key);
135	factory.beforeDispose(dialog);
136	}
137
138	@Override
139	public void windowClosing(final WindowEvent e) {
140	}
141	});
142
143	factory.afterCreation(dialog);
144	}
145
146	return dialog;
147	}
148
149	/**
150	* Disposes all open instances and removes them from the cache.
151	*
152	* @return <code>true</code> if at least one window has been disposed.
153	*/
154	public boolean disposeAll() {
155
156	boolean atLeastOne = false;
157	HashSet<KEY> tempKeys = new HashSet<KEY>(dialogCache.keySet());
158	for (KEY key : tempKeys) {
159	DIALOG dialog = dialogCache.get(key);
160	if (dialog != null) {
161	dialog.dispose();
162	atLeastOne = true;
163	}
164	}
165	tempKeys.clear();
166	dialogCache.clear();
167	return atLeastOne;
168	}
169
170	/**
171	* @return All instances of DIALOG as they are cached.
172	*/
173	public Collection<DIALOG> getAllInstances() {
174	return dialogCache.values();
175	}
176
177	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain