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;

import schmitzm.swing.ExceptionDialog;

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