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 JDialog> {
        final static private Logger LOGGER = Logger.getLogger(DialogManager.class);

        public abstract class FactoryInterface {

                public abstract DIALOG create();

        }

        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;
        }

        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 chartId) {
                synchronized (dialogCache) {

                        final DIALOG dialog = dialogCache.get(chartId);
                        if (dialog != null) {
                                dialog.dispose();
                                dialogCache.remove(chartId);
                                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, FactoryInterface factory) {
                DIALOG dialog;
                if (isVisibleFor(key)) {
                        dialog = dialogCache.get(key);
                } else {

                        dialog = factory.create();

                        dialogCache.put(key, dialog);

                        dialog.addWindowListener(new WindowAdapter() {
                                @Override
                                public void windowClosed(final WindowEvent e) {
                                        disposeInstanceFor(key);
                                }
                        });
                }
                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	421	public abstract class DialogManager<KEY, DIALOG extends JDialog> {
15			final static private Logger LOGGER = Logger.getLogger(DialogManager.class);
16	alfonx	420
17			public abstract class FactoryInterface {
18
19			public abstract DIALOG create();
20
21			}
22
23	alfonx	422	protected HashMap<KEY, DIALOG> dialogCache = new HashMap<KEY, DIALOG>();
24	alfonx	420
25	alfonx	421	/**
26			* A {@link DialogManager} instance can be created for any extension of
27			* {@link JDialog} that will implement the
28			* {@link #getInstanceFor(Object, Component, Object...)} method.
29			*/
30	alfonx	420	public DialogManager() {
31			}
32
33			/**
34			* This will be done with every dialog that an instance is required for.
35			*
36			* @param dialog
37			* @return
38			*/
39			protected DIALOG bringup(DIALOG dialog) {
40			if (!dialog.isVisible())
41			dialog.setVisible(true);
42			dialog.toFront();
43
44			return dialog;
45			}
46
47			public abstract DIALOG getInstanceFor(final KEY key, final Component owner,
48			final Object... constArgs);
49
50			/**
51			* @return Is there an open/visible dialog for the given layer id?
52			*/
53			public boolean isVisibleFor(KEY key) {
54			return dialogCache.containsKey(key) && dialogCache.get(key).isVisible();
55			}
56
57			/**
58			* Will dispose any dialog that is registered to the given parent
59			* {@link Component}
60			*
61			* @param parent
62			*/
63			public void disposeInstanceForParent(final Component parent) {
64
65			final HashMap<KEY, JDialog> clonedHashMap = (HashMap<KEY, JDialog>) dialogCache
66			.clone();
67
68			for (KEY chartId : clonedHashMap.keySet()) {
69			if (dialogCache.get(chartId).getParent() == parent) {
70			disposeInstanceFor(chartId);
71			}
72			}
73			}
74
75			public boolean disposeInstanceFor(KEY chartId) {
76			synchronized (dialogCache) {
77
78			final DIALOG dialog = dialogCache.get(chartId);
79			if (dialog != null) {
80			dialog.dispose();
81	alfonx	421	dialogCache.remove(chartId);
82	alfonx	420	return true;
83			}
84			return false;
85			}
86			}
87
88			/**
89			* Checks whether there already is an instance for that key and otherwise
90			* will create the instance by invoking the {@link FactoryInterface} #create
91			* method.
92			*
93			* @param factory
94			* {@link FactoryInterface} that creates the DIALOG
95			*
96	alfonx	421	* @return Always a visible and inFront instance of DIALOG for the given
97			* key.
98	alfonx	420	*/
99			public DIALOG getInstanceFor(final KEY key, FactoryInterface factory) {
100			DIALOG dialog;
101			if (isVisibleFor(key)) {
102			dialog = dialogCache.get(key);
103			} else {
104
105			dialog = factory.create();
106
107			dialogCache.put(key, dialog);
108
109			dialog.addWindowListener(new WindowAdapter() {
110			@Override
111			public void windowClosed(final WindowEvent e) {
112			disposeInstanceFor(key);
113			}
114			});
115			}
116			return dialog;
117			}
118
119			/**
120	alfonx	421	* Disposes all open instances and removes them from the cache.
121	alfonx	420	*
122			* @return <code>true</code> if at least one window has been disposed.
123			*/
124			public boolean disposeAll() {
125	alfonx	421
126	alfonx	420	boolean atLeastOne = false;
127			HashSet<KEY> tempKeys = new HashSet<KEY>(dialogCache.keySet());
128			for (KEY key : tempKeys) {
129	alfonx	421	DIALOG dialog = dialogCache.get(key);
130	alfonx	420	if (dialog != null) {
131			dialog.dispose();
132			atLeastOne = true;
133			}
134			}
135			tempKeys.clear();
136			dialogCache.clear();
137			return atLeastOne;
138			}
139	alfonx	421
140	alfonx	422	/**
141			* @return All instances of DIALOG as they are cached.
142			*/
143			public Collection<DIALOG> getAllInstances() {
144			return dialogCache.values();
145			}
146
147
148	alfonx	420	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain