001 package resource.util;
002
003 import java.net.*;
004 import java.util.*;
005
006 /**
007 * The global manager for all resources. The ResourceManager is responsible for managing all binary resources
008 * of the framework. This can be images, videos, text ...<br>
009 * <br>
010 * Resources are managed as follows:<br>
011 * <br>
012 * The root directory is a directory ending with the name "resource". Here it is just the directory
013 * "resource". Starting from this directory all resources are given back relative to this path.<br>
014 * <br>
015 * There can be multiple resouces to manage: gif-images, jpeg-images, text and others.<br>
016 * For all of these resources there should exist one resource module.<br>
017 * There is already one module for {@link #RESOURCE_GIF gif-resources}.<br>
018 * </br>
019 * Resources are requested as follows:<br>
020 * <CODE>URL url = ResourceManager.getInstance().getResource (String type, String path);</CODE></br>
021 * The "type" is the name of the resource module. The path string is the path relative to the directory
022 * of the requested type and is separated with a dot.
023 * </br>
024 * Example:</br>
025 * </br>
026 * An icon of the size 16x16 should be requested. It is located in the directory "resource/gif/icon".<br>
027 * The icon's name is "document.gif".
028 * So the call is:<br>
029 * <CODE>URL url = ResourceManager.getInstance().getResource (RESOURCE_GIF, "icon.document");</CODE>
030 *
031 * @author Thomas Medack
032 * @version 1.0
033 */
034 public class ResourceManager {
035
036 /**
037 * Interface for a resource module.
038 */
039 public static interface ResourceModule {
040 /**
041 * Returns the path relative to the current resource path.
042 *
043 * @return the path.
044 */
045 public String getPath();
046
047 /**
048 * Returns the file extension of the resource, e.g. "gif".
049 *
050 * @return the file extension
051 */
052 public String getExtension();
053
054 /**
055 * Returns the type name of the module. This is the name by which the resources are requested.
056 *
057 * @return the type name
058 */
059 public String getTypeName();
060 }
061
062 /**
063 * Map of all resource modules.
064 */
065 private HashMap<String, ResourceModule> moduls = new HashMap<String, ResourceModule>();
066
067 /**
068 * The root path of all resources.
069 */
070 protected String resourceRootPath = "";
071
072 /**
073 * The singleton instance of the resource manager.
074 */
075 private static ResourceManager instance = null;
076
077 /**
078 * Creates a new instance of ResourceManager.
079 */
080 protected ResourceManager() {
081 // add resource module
082 addResourceModule(new ResourceModuleGIF());
083 addResourceModule(new ResourceModulePNG());
084
085 // root path is package "resource"
086 resourceRootPath = "resource";
087 }
088
089 /**
090 * Returns the singleton instance of the ResourceManager.
091 *
092 * @return the singleton instance.
093 */
094 public static ResourceManager getInstance() {
095 if (instance == null) {
096 instance = new ResourceManager();
097
098 }
099 return instance;
100 }
101
102 /**
103 * Adds a resource module to the ResourceManager.
104 *
105 * @param rm the resource module to be added.
106 */
107 public void addResourceModule(ResourceModule rm) {
108 moduls.put(rm.getTypeName(), rm);
109 }
110
111 /**
112 * Removes a resource module from the ResourceManager.
113 *
114 * @param rm the resource module to be removed.
115 */
116 public void removeResourceModule(ResourceModule rm) {
117 moduls.remove(rm.getTypeName());
118 }
119
120 /**
121 * Returns a resource as URL. Therefor the logical name of the resource module and the relative path
122 * starting from it have to be specified.<br>
123 * </br>
124 * Example:</br>
125 * </br>
126 * logical name of the gif-module: "RESOURCE_GIF". The absolute path of this module is
127 * "org/eit/ui/resource/gif". The requested resource is "document.gif".<br>
128 * Therefore the call is: <CODE>getResource ("RESOURCE_GIF", "icon.16x16.document)</CODE>
129 * (without file extension).
130 *
131 * @param type the logical type name
132 * @param path der relative path + file name without extension
133 * @return the resource's URL.
134 */
135 public URL getResource(String type, String path) {
136 //changed from ClassLoader.getSystemClassLoader() to this.getClass().getClassLoader()
137 //because the first version does not work with Java Web Start
138 //return ClassLoader.getSystemClassLoader().getResource(getFullPath(type, path));
139 return this.getClass().getClassLoader().getResource(getFullPath(type, path));
140 }
141
142 /**
143 * Returns the full path of a resource..
144 *
145 * @param type the logical type name
146 * @param path der relative path + file name without extension
147 * @return the resource's full path as String.
148 */
149 public String getFullPath(String type, String path) {
150 ResourceModule rm = (ResourceModule)moduls.get(type);
151 String p = resourceRootPath + "/" + rm.getPath();
152
153 if (rm != null) {
154 // construct path
155 StringTokenizer st = new StringTokenizer(path, ".");
156 while (st.hasMoreTokens()) {
157 p = p + "/" + st.nextToken();
158 }
159 // append extension
160 p = p + "." + rm.getExtension();
161
162 return p;
163 }
164
165 return "";
166 }
167
168 /**
169 * Type name for resource module: GIF
170 */
171 public static final String RESOURCE_GIF = "gif";
172
173 /**
174 * Predefined module for .gif-resources.
175 */
176 private static final class ResourceModuleGIF implements ResourceModule {
177
178 /**
179 * Returns the resource's file extension: "gif".
180 *
181 * @return the file extension
182 */
183 public String getExtension() {
184 return "gif";
185 }
186
187 /**
188 * Returns the path relative to the current resource path.
189 *
190 * @return the path.
191 */
192 public String getPath() {
193 return "gif";
194 }
195
196 /**
197 * Returns the type name of the module. This is the name by which the resources are requested.
198 *
199 * @return the type name
200 */
201 public String getTypeName() {
202 return RESOURCE_GIF;
203 }
204 }
205
206 public static final String RESOURCE_PNG = "png";
207
208 /**
209 * Predefined module for .png-resources.
210 */
211 private static final class ResourceModulePNG implements ResourceModule {
212
213 /**
214 * Returns the resource's file extension: "png".
215 *
216 * @return the file extension
217 */
218 public String getExtension() {
219 return "png";
220 }
221
222 /**
223 * Returns the path relative to the current resource path.
224 *
225 * @return the path.
226 */
227 public String getPath() {
228 return "png";
229 }
230
231 /**
232 * Returns the type name of the module. This is the name by which the resources are requested.
233 *
234 * @return the type name
235 */
236 public String getTypeName() {
237 return RESOURCE_PNG;
238 }
239 }
240
241 }