dispose() method to
47 | * release the operating system resources managed by cached objects when those
48 | * objects and OS resources are no longer needed.
49 | *
50 | * This class may be freely distributed as part of any application or plugin.
51 | *
52 | *
53 | * @author scheglov_ke
54 | * @author Dan Rubel
55 | * @author Wim Jongman
56 | */
57 | public class ResourceManager extends SWTResourceManager {
58 |
59 | /**
60 | * The map where we store our images.
61 | */
62 | private static Map m_descriptorImageMap = new HashMap();
63 |
64 | /**
65 | * Returns an {@link ImageDescriptor} stored in the file at the specified path
66 | * relative to the specified class.
67 | *
68 | * @param clazz the {@link Class} relative to which to find the image
69 | * descriptor.
70 | * @param path the path to the image file.
71 | * @return the {@link ImageDescriptor} stored in the file at the specified path.
72 | */
73 | public static ImageDescriptor getImageDescriptor(Class clazz, String path) {
74 | return ImageDescriptor.createFromFile(clazz, path);
75 | }
76 |
77 | /**
78 | * Returns an {@link ImageDescriptor} stored in the file at the specified path.
79 | *
80 | * @param path the path to the image file.
81 | * @return the {@link ImageDescriptor} stored in the file at the specified path.
82 | */
83 | public static ImageDescriptor getImageDescriptor(String path) {
84 | try {
85 | return ImageDescriptor.createFromURL(new File(path).toURI().toURL());
86 | } catch (MalformedURLException e) {
87 | return null;
88 | }
89 | }
90 |
91 | /**
92 | * Returns an {@link Image} based on the specified {@link ImageDescriptor}.
93 | *
94 | * @param descriptor the {@link ImageDescriptor} for the {@link Image}.
95 | * @return the {@link Image} based on the specified {@link ImageDescriptor}.
96 | */
97 | public static Image getImage(ImageDescriptor descriptor) {
98 | if (descriptor == null) {
99 | return null;
100 | }
101 | Image image = m_descriptorImageMap.get(descriptor);
102 | if (image == null) {
103 | image = descriptor.createImage();
104 | m_descriptorImageMap.put(descriptor, image);
105 | }
106 | return image;
107 | }
108 |
109 | /**
110 | * Maps images to decorated images.
111 | */
112 | @SuppressWarnings("unchecked")
113 | private static Map>[] m_decoratedImageMap = new Map[LAST_CORNER_KEY];
114 |
115 | /**
116 | * Returns an {@link Image} composed of a base image decorated by another image.
117 | *
118 | * @param baseImage the base {@link Image} that should be decorated.
119 | * @param decorator the {@link Image} to decorate the base image.
120 | * @return {@link Image} The resulting decorated image.
121 | */
122 | public static Image decorateImage(Image baseImage, Image decorator) {
123 | return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
124 | }
125 |
126 | /**
127 | * Returns an {@link Image} composed of a base image decorated by another image.
128 | *
129 | * @param baseImage
130 | * the base {@link Image} that should be decorated.
131 | * @param decorator
132 | * the {@link Image} to decorate the base image.
133 | * @param corner
134 | * the corner to place decorator image.
135 | * @return the resulting decorated {@link Image}.
136 | */
137 | public static Image decorateImage(final Image baseImage, final Image decorator, final int corner) {
138 | if (corner <= 0 || corner >= LAST_CORNER_KEY) {
139 | throw new IllegalArgumentException("Wrong decorate corner");
140 | }
141 | Map> cornerDecoratedImageMap = m_decoratedImageMap[corner];
142 | if (cornerDecoratedImageMap == null) {
143 | cornerDecoratedImageMap = new HashMap>();
144 | m_decoratedImageMap[corner] = cornerDecoratedImageMap;
145 | }
146 | Map decoratedMap = cornerDecoratedImageMap.get(baseImage);
147 | if (decoratedMap == null) {
148 | decoratedMap = new HashMap();
149 | cornerDecoratedImageMap.put(baseImage, decoratedMap);
150 | }
151 | //
152 | Image result = decoratedMap.get(decorator);
153 | if (result == null) {
154 | final Rectangle bib = baseImage.getBounds();
155 | final Rectangle dib = decorator.getBounds();
156 | final Point baseImageSize = new Point(bib.width, bib.height);
157 | CompositeImageDescriptor compositImageDesc = new CompositeImageDescriptor() {
158 | @Override
159 | protected void drawCompositeImage(int width, int height) {
160 | drawImage(createCachedImageDataProvider(baseImage), 0, 0);
161 | if (corner == TOP_LEFT) {
162 | drawImage(getUnzoomedImageDataProvider(decorator.getImageData()) , 0, 0);
163 | } else if (corner == TOP_RIGHT) {
164 | drawImage(getUnzoomedImageDataProvider(decorator.getImageData()), bib.width - dib.width, 0);
165 | } else if (corner == BOTTOM_LEFT) {
166 | drawImage(getUnzoomedImageDataProvider(decorator.getImageData()), 0, bib.height - dib.height);
167 | } else if (corner == BOTTOM_RIGHT) {
168 | drawImage(getUnzoomedImageDataProvider(decorator.getImageData()), bib.width - dib.width, bib.height - dib.height);
169 | }
170 | }
171 | @Override
172 | protected Point getSize() {
173 | return baseImageSize;
174 | }
175 | };
176 | //
177 | result = compositImageDesc.createImage();
178 | decoratedMap.put(decorator, result);
179 | }
180 | return result;
181 | }
182 |
183 | private static ImageDataProvider getUnzoomedImageDataProvider(ImageData imageData) {
184 | return zoom -> zoom == 100 ? imageData : null;
185 | }
186 |
187 |
188 | /**
189 | * Dispose all of the cached images.
190 | */
191 | public static void disposeImages() {
192 | SWTResourceManager.disposeImages();
193 | // dispose ImageDescriptor images
194 | {
195 | for (Iterator I = m_descriptorImageMap.values().iterator(); I.hasNext();) {
196 | I.next().dispose();
197 | }
198 | m_descriptorImageMap.clear();
199 | }
200 | // dispose decorated images
201 | for (int i = 0; i < m_decoratedImageMap.length; i++) {
202 | Map> cornerDecoratedImageMap = m_decoratedImageMap[i];
203 | if (cornerDecoratedImageMap != null) {
204 | for (Map decoratedMap : cornerDecoratedImageMap.values()) {
205 | for (Image image : decoratedMap.values()) {
206 | image.dispose();
207 | }
208 | decoratedMap.clear();
209 | }
210 | cornerDecoratedImageMap.clear();
211 | }
212 | }
213 | // dispose plugin images
214 | {
215 | for (Iterator I = m_URLImageMap.values().iterator(); I.hasNext();) {
216 | I.next().dispose();
217 | }
218 | m_URLImageMap.clear();
219 | }
220 | }
221 |
222 | ////////////////////////////////////////////////////////////////////////////
223 | //
224 | // Plugin images support
225 | //
226 | ////////////////////////////////////////////////////////////////////////////
227 | /**
228 | * Maps URL to images.
229 | */
230 | private static Map m_URLImageMap = new HashMap();
231 |
232 | /**
233 | * Provider for plugin resources, used by WindowBuilder at design time.
234 | */
235 | public interface PluginResourceProvider {
236 | URL getEntry(String symbolicName, String path);
237 | }
238 |
239 | /**
240 | * Instance of {@link PluginResourceProvider}, used by WindowBuilder at design
241 | * time.
242 | */
243 | private static PluginResourceProvider m_designTimePluginResourceProvider = null;
244 |
245 | /**
246 | * Returns an {@link Image} based on a plugin and file path.
247 | *
248 | * @param plugin the plugin {@link Object} containing the image
249 | * @param name the path to the image within the plugin
250 | * @return the {@link Image} stored in the file at the specified path
251 | *
252 | * @deprecated Use {@link #getPluginImage(String, String)} instead.
253 | */
254 | @Deprecated
255 | public static Image getPluginImage(Object plugin, String name) {
256 | try {
257 | URL url = getPluginImageURL(plugin, name);
258 | if (url != null) {
259 | return getPluginImageFromUrl(url);
260 | }
261 | } catch (Throwable e) {
262 | // Ignore any exceptions
263 | }
264 | return null;
265 | }
266 |
267 | /**
268 | * Returns an {@link Image} based on a {@link Bundle} and resource entry path.
269 | *
270 | * @param symbolicName the symbolic name of the {@link Bundle}.
271 | * @param path the path of the resource entry.
272 | * @return the {@link Image} stored in the file at the specified path.
273 | */
274 | public static Image getPluginImage(String symbolicName, String path) {
275 | try {
276 | URL url = getPluginImageURL(symbolicName, path);
277 | if (url != null) {
278 | return getPluginImageFromUrl(url);
279 | }
280 | } catch (Throwable e) {
281 | // Ignore any exceptions
282 | }
283 | return null;
284 | }
285 |
286 | /**
287 | * Returns an {@link Image} based on given {@link URL}.
288 | */
289 | private static Image getPluginImageFromUrl(URL url) {
290 | try {
291 | try {
292 | String key = url.toExternalForm();
293 | Image image = m_URLImageMap.get(key);
294 | if (image == null) {
295 | InputStream stream = url.openStream();
296 | try {
297 | image = getImage(stream);
298 | m_URLImageMap.put(key, image);
299 | } finally {
300 | stream.close();
301 | }
302 | }
303 | return image;
304 | } catch (Throwable e) {
305 | // Ignore any exceptions
306 | }
307 | } catch (Throwable e) {
308 | // Ignore any exceptions
309 | }
310 | return null;
311 | }
312 |
313 | /**
314 | * Returns an {@link ImageDescriptor} based on a plugin and file path.
315 | *
316 | * @param plugin the plugin {@link Object} containing the image.
317 | * @param name the path to th eimage within the plugin.
318 | * @return the {@link ImageDescriptor} stored in the file at the specified path.
319 | *
320 | * @deprecated Use {@link #getPluginImageDescriptor(String, String)} instead.
321 | */
322 | @Deprecated
323 | public static ImageDescriptor getPluginImageDescriptor(Object plugin, String name) {
324 | try {
325 | try {
326 | URL url = getPluginImageURL(plugin, name);
327 | return ImageDescriptor.createFromURL(url);
328 | } catch (Throwable e) {
329 | // Ignore any exceptions
330 | }
331 | } catch (Throwable e) {
332 | // Ignore any exceptions
333 | }
334 | return null;
335 | }
336 |
337 | /**
338 | * Returns an {@link ImageDescriptor} based on a {@link Bundle} and resource
339 | * entry path.
340 | *
341 | * @param symbolicName the symbolic name of the {@link Bundle}.
342 | * @param path the path of the resource entry.
343 | * @return the {@link ImageDescriptor} based on a {@link Bundle} and resource
344 | * entry path.
345 | */
346 | public static ImageDescriptor getPluginImageDescriptor(String symbolicName, String path) {
347 | try {
348 | URL url = getPluginImageURL(symbolicName, path);
349 | if (url != null) {
350 | return ImageDescriptor.createFromURL(url);
351 | }
352 | } catch (Throwable e) {
353 | // Ignore any exceptions
354 | }
355 | return null;
356 | }
357 |
358 | /**
359 | * Returns an {@link URL} based on a {@link Bundle} and resource entry path.
360 | */
361 | private static URL getPluginImageURL(String symbolicName, String path) {
362 | // try runtime plugins
363 | {
364 | Bundle bundle = Platform.getBundle(symbolicName);
365 | if (bundle != null) {
366 | return bundle.getEntry(path);
367 | }
368 | }
369 | // try design time provider
370 | if (m_designTimePluginResourceProvider != null) {
371 | return m_designTimePluginResourceProvider.getEntry(symbolicName, path);
372 | }
373 | // no such resource
374 | return null;
375 | }
376 |
377 | /**
378 | * Returns an {@link URL} based on a plugin and file path.
379 | *
380 | * @param plugin the plugin {@link Object} containing the file path.
381 | * @param name the file path.
382 | * @return the {@link URL} representing the file at the specified path.
383 | * @throws Exception
384 | */
385 | private static URL getPluginImageURL(Object plugin, String name) throws Exception {
386 | // try to work with 'plugin' as with OSGI BundleContext
387 | try {
388 | Class BundleClass = Class.forName("org.osgi.framework.Bundle"); //$NON-NLS-1$
389 | Class BundleContextClass = Class.forName("org.osgi.framework.BundleContext"); //$NON-NLS-1$
390 | if (BundleContextClass.isAssignableFrom(plugin.getClass())) {
391 | Method getBundleMethod = BundleContextClass.getMethod("getBundle", new Class[0]); //$NON-NLS-1$
392 | Object bundle = getBundleMethod.invoke(plugin, new Object[0]);
393 | //
394 | Class PathClass = Class.forName("org.eclipse.core.runtime.Path"); //$NON-NLS-1$
395 | Constructor pathConstructor = PathClass.getConstructor(new Class[] { String.class });
396 | Object path = pathConstructor.newInstance(new Object[] { name });
397 | //
398 | Class IPathClass = Class.forName("org.eclipse.core.runtime.IPath"); //$NON-NLS-1$
399 | Class PlatformClass = Class.forName("org.eclipse.core.runtime.Platform"); //$NON-NLS-1$
400 | Method findMethod = PlatformClass.getMethod("find", new Class[] { BundleClass, IPathClass }); //$NON-NLS-1$
401 | return (URL) findMethod.invoke(null, new Object[] { bundle, path });
402 | }
403 | } catch (Throwable e) {
404 | // Ignore any exceptions
405 | }
406 | // else work with 'plugin' as with usual Eclipse plugin
407 | {
408 | Class PluginClass = Class.forName("org.eclipse.core.runtime.Plugin"); //$NON-NLS-1$
409 | if (PluginClass.isAssignableFrom(plugin.getClass())) {
410 | //
411 | Class PathClass = Class.forName("org.eclipse.core.runtime.Path"); //$NON-NLS-1$
412 | Constructor pathConstructor = PathClass.getConstructor(new Class[] { String.class });
413 | Object path = pathConstructor.newInstance(new Object[] { name });
414 | //
415 | Class IPathClass = Class.forName("org.eclipse.core.runtime.IPath"); //$NON-NLS-1$
416 | Method findMethod = PluginClass.getMethod("find", new Class[] { IPathClass }); //$NON-NLS-1$
417 | return (URL) findMethod.invoke(plugin, new Object[] { path });
418 | }
419 | }
420 | return null;
421 | }
422 |
423 | ////////////////////////////////////////////////////////////////////////////
424 | //
425 | // General
426 | //
427 | ////////////////////////////////////////////////////////////////////////////
428 | /**
429 | * Dispose of cached objects and their underlying OS resources. This should only
430 | * be called when the cached objects are no longer needed (e.g. on application
431 | * shutdown).
432 | */
433 | public static void dispose() {
434 | disposeColors();
435 | disposeFonts();
436 | disposeImages();
437 | }
438 | }
--------------------------------------------------------------------------------
/src/org/eclipse/wb/swt/SWTResourceManager.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 Google, Inc.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Google, Inc. - initial API and implementation
10 | *******************************************************************************/
11 | package org.eclipse.wb.swt;
12 |
13 | import java.io.FileInputStream;
14 | import java.io.IOException;
15 | import java.io.InputStream;
16 | import java.util.HashMap;
17 | import java.util.Map;
18 |
19 | import org.eclipse.swt.SWT;
20 | import org.eclipse.swt.graphics.Color;
21 | import org.eclipse.swt.graphics.Cursor;
22 | import org.eclipse.swt.graphics.Font;
23 | import org.eclipse.swt.graphics.FontData;
24 | import org.eclipse.swt.graphics.GC;
25 | import org.eclipse.swt.graphics.Image;
26 | import org.eclipse.swt.graphics.ImageData;
27 | import org.eclipse.swt.graphics.RGB;
28 | import org.eclipse.swt.graphics.Rectangle;
29 | import org.eclipse.swt.widgets.Display;
30 |
31 | /**
32 | * Utility class for managing OS resources associated with SWT controls such as colors, fonts, images, etc.
33 | *
34 | * !!! IMPORTANT !!! Application code must explicitly invoke the dispose() method to release the
35 | * operating system resources managed by cached objects when those objects and OS resources are no longer
36 | * needed (e.g. on application shutdown)
37 | *
38 | * This class may be freely distributed as part of any application or plugin.
39 | *
40 | * @author scheglov_ke
41 | * @author Dan Rubel
42 | */
43 | public class SWTResourceManager {
44 | ////////////////////////////////////////////////////////////////////////////
45 | //
46 | // Color
47 | //
48 | ////////////////////////////////////////////////////////////////////////////
49 | private static Map m_colorMap = new HashMap();
50 | /**
51 | * Returns the system {@link Color} matching the specific ID.
52 | *
53 | * @param systemColorID
54 | * the ID value for the color
55 | * @return the system {@link Color} matching the specific ID
56 | */
57 | public static Color getColor(int systemColorID) {
58 | Display display = Display.getCurrent();
59 | return display.getSystemColor(systemColorID);
60 | }
61 | /**
62 | * Returns a {@link Color} given its red, green and blue component values.
63 | *
64 | * @param r
65 | * the red component of the color
66 | * @param g
67 | * the green component of the color
68 | * @param b
69 | * the blue component of the color
70 | * @return the {@link Color} matching the given red, green and blue component values
71 | */
72 | public static Color getColor(int r, int g, int b) {
73 | return getColor(new RGB(r, g, b));
74 | }
75 | /**
76 | * Returns a {@link Color} given its RGB value.
77 | *
78 | * @param rgb
79 | * the {@link RGB} value of the color
80 | * @return the {@link Color} matching the RGB value
81 | */
82 | public static Color getColor(RGB rgb) {
83 | Color color = m_colorMap.get(rgb);
84 | if (color == null) {
85 | Display display = Display.getCurrent();
86 | color = new Color(display, rgb);
87 | m_colorMap.put(rgb, color);
88 | }
89 | return color;
90 | }
91 | /**
92 | * Dispose of all the cached {@link Color}'s.
93 | */
94 | public static void disposeColors() {
95 | for (Color color : m_colorMap.values()) {
96 | color.dispose();
97 | }
98 | m_colorMap.clear();
99 | }
100 | ////////////////////////////////////////////////////////////////////////////
101 | //
102 | // Image
103 | //
104 | ////////////////////////////////////////////////////////////////////////////
105 | /**
106 | * Maps image paths to images.
107 | */
108 | private static Map m_imageMap = new HashMap();
109 | /**
110 | * Returns an {@link Image} encoded by the specified {@link InputStream}.
111 | *
112 | * @param stream
113 | * the {@link InputStream} encoding the image data
114 | * @return the {@link Image} encoded by the specified input stream
115 | */
116 | protected static Image getImage(InputStream stream) throws IOException {
117 | try {
118 | Display display = Display.getCurrent();
119 | ImageData data = new ImageData(stream);
120 | if (data.transparentPixel > 0) {
121 | return new Image(display, data, data.getTransparencyMask());
122 | }
123 | return new Image(display, data);
124 | } finally {
125 | stream.close();
126 | }
127 | }
128 | /**
129 | * Returns an {@link Image} stored in the file at the specified path.
130 | *
131 | * @param path
132 | * the path to the image file
133 | * @return the {@link Image} stored in the file at the specified path
134 | */
135 | public static Image getImage(String path) {
136 | Image image = m_imageMap.get(path);
137 | if (image == null) {
138 | try {
139 | image = getImage(new FileInputStream(path));
140 | m_imageMap.put(path, image);
141 | } catch (Exception e) {
142 | image = getMissingImage();
143 | m_imageMap.put(path, image);
144 | }
145 | }
146 | return image;
147 | }
148 | /**
149 | * Returns an {@link Image} stored in the file at the specified path relative to the specified class.
150 | *
151 | * @param clazz
152 | * the {@link Class} relative to which to find the image
153 | * @param path
154 | * the path to the image file, if starts with '/'
155 | * @return the {@link Image} stored in the file at the specified path
156 | */
157 | public static Image getImage(Class clazz, String path) {
158 | String key = clazz.getName() + '|' + path;
159 | Image image = m_imageMap.get(key);
160 | if (image == null) {
161 | try {
162 | image = getImage(clazz.getResourceAsStream(path));
163 | m_imageMap.put(key, image);
164 | } catch (Exception e) {
165 | image = getMissingImage();
166 | m_imageMap.put(key, image);
167 | }
168 | }
169 | return image;
170 | }
171 | private static final int MISSING_IMAGE_SIZE = 10;
172 | /**
173 | * @return the small {@link Image} that can be used as placeholder for missing image.
174 | */
175 | private static Image getMissingImage() {
176 | Image image = new Image(Display.getCurrent(), MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
177 | //
178 | GC gc = new GC(image);
179 | gc.setBackground(getColor(SWT.COLOR_RED));
180 | gc.fillRectangle(0, 0, MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
181 | gc.dispose();
182 | //
183 | return image;
184 | }
185 | /**
186 | * Style constant for placing decorator image in top left corner of base image.
187 | */
188 | public static final int TOP_LEFT = 1;
189 | /**
190 | * Style constant for placing decorator image in top right corner of base image.
191 | */
192 | public static final int TOP_RIGHT = 2;
193 | /**
194 | * Style constant for placing decorator image in bottom left corner of base image.
195 | */
196 | public static final int BOTTOM_LEFT = 3;
197 | /**
198 | * Style constant for placing decorator image in bottom right corner of base image.
199 | */
200 | public static final int BOTTOM_RIGHT = 4;
201 | /**
202 | * Internal value.
203 | */
204 | protected static final int LAST_CORNER_KEY = 5;
205 | /**
206 | * Maps images to decorated images.
207 | */
208 | @SuppressWarnings("unchecked")
209 | private static Map>[] m_decoratedImageMap = new Map[LAST_CORNER_KEY];
210 | /**
211 | * Returns an {@link Image} composed of a base image decorated by another image.
212 | *
213 | * @param baseImage
214 | * the base {@link Image} that should be decorated
215 | * @param decorator
216 | * the {@link Image} to decorate the base image
217 | * @return {@link Image} The resulting decorated image
218 | */
219 | public static Image decorateImage(Image baseImage, Image decorator) {
220 | return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
221 | }
222 | /**
223 | * Returns an {@link Image} composed of a base image decorated by another image.
224 | *
225 | * @param baseImage
226 | * the base {@link Image} that should be decorated
227 | * @param decorator
228 | * the {@link Image} to decorate the base image
229 | * @param corner
230 | * the corner to place decorator image
231 | * @return the resulting decorated {@link Image}
232 | */
233 | public static Image decorateImage(final Image baseImage, final Image decorator, final int corner) {
234 | if (corner <= 0 || corner >= LAST_CORNER_KEY) {
235 | throw new IllegalArgumentException("Wrong decorate corner");
236 | }
237 | Map> cornerDecoratedImageMap = m_decoratedImageMap[corner];
238 | if (cornerDecoratedImageMap == null) {
239 | cornerDecoratedImageMap = new HashMap>();
240 | m_decoratedImageMap[corner] = cornerDecoratedImageMap;
241 | }
242 | Map decoratedMap = cornerDecoratedImageMap.get(baseImage);
243 | if (decoratedMap == null) {
244 | decoratedMap = new HashMap();
245 | cornerDecoratedImageMap.put(baseImage, decoratedMap);
246 | }
247 | //
248 | Image result = decoratedMap.get(decorator);
249 | if (result == null) {
250 | Rectangle bib = baseImage.getBounds();
251 | Rectangle dib = decorator.getBounds();
252 | //
253 | result = new Image(Display.getCurrent(), bib.width, bib.height);
254 | //
255 | GC gc = new GC(result);
256 | gc.drawImage(baseImage, 0, 0);
257 | if (corner == TOP_LEFT) {
258 | gc.drawImage(decorator, 0, 0);
259 | } else if (corner == TOP_RIGHT) {
260 | gc.drawImage(decorator, bib.width - dib.width, 0);
261 | } else if (corner == BOTTOM_LEFT) {
262 | gc.drawImage(decorator, 0, bib.height - dib.height);
263 | } else if (corner == BOTTOM_RIGHT) {
264 | gc.drawImage(decorator, bib.width - dib.width, bib.height - dib.height);
265 | }
266 | gc.dispose();
267 | //
268 | decoratedMap.put(decorator, result);
269 | }
270 | return result;
271 | }
272 | /**
273 | * Dispose all of the cached {@link Image}'s.
274 | */
275 | public static void disposeImages() {
276 | // dispose loaded images
277 | {
278 | for (Image image : m_imageMap.values()) {
279 | image.dispose();
280 | }
281 | m_imageMap.clear();
282 | }
283 | // dispose decorated images
284 | for (int i = 0; i < m_decoratedImageMap.length; i++) {
285 | Map> cornerDecoratedImageMap = m_decoratedImageMap[i];
286 | if (cornerDecoratedImageMap != null) {
287 | for (Map decoratedMap : cornerDecoratedImageMap.values()) {
288 | for (Image image : decoratedMap.values()) {
289 | image.dispose();
290 | }
291 | decoratedMap.clear();
292 | }
293 | cornerDecoratedImageMap.clear();
294 | }
295 | }
296 | }
297 | ////////////////////////////////////////////////////////////////////////////
298 | //
299 | // Font
300 | //
301 | ////////////////////////////////////////////////////////////////////////////
302 | /**
303 | * Maps font names to fonts.
304 | */
305 | private static Map m_fontMap = new HashMap();
306 | /**
307 | * Maps fonts to their bold versions.
308 | */
309 | private static Map m_fontToBoldFontMap = new HashMap();
310 | /**
311 | * Returns a {@link Font} based on its name, height and style.
312 | *
313 | * @param name
314 | * the name of the font
315 | * @param height
316 | * the height of the font
317 | * @param style
318 | * the style of the font
319 | * @return {@link Font} The font matching the name, height and style
320 | */
321 | public static Font getFont(String name, int height, int style) {
322 | return getFont(name, height, style, false, false);
323 | }
324 | /**
325 | * Returns a {@link Font} based on its name, height and style. Windows-specific strikeout and underline
326 | * flags are also supported.
327 | *
328 | * @param name
329 | * the name of the font
330 | * @param size
331 | * the size of the font
332 | * @param style
333 | * the style of the font
334 | * @param strikeout
335 | * the strikeout flag (warning: Windows only)
336 | * @param underline
337 | * the underline flag (warning: Windows only)
338 | * @return {@link Font} The font matching the name, height, style, strikeout and underline
339 | */
340 | public static Font getFont(String name, int size, int style, boolean strikeout, boolean underline) {
341 | String fontName = name + '|' + size + '|' + style + '|' + strikeout + '|' + underline;
342 | Font font = m_fontMap.get(fontName);
343 | if (font == null) {
344 | FontData fontData = new FontData(name, size, style);
345 | if (strikeout || underline) {
346 | try {
347 | Class logFontClass = Class.forName("org.eclipse.swt.internal.win32.LOGFONT"); //$NON-NLS-1$
348 | Object logFont = FontData.class.getField("data").get(fontData); //$NON-NLS-1$
349 | if (logFont != null && logFontClass != null) {
350 | if (strikeout) {
351 | logFontClass.getField("lfStrikeOut").set(logFont, Byte.valueOf((byte) 1)); //$NON-NLS-1$
352 | }
353 | if (underline) {
354 | logFontClass.getField("lfUnderline").set(logFont, Byte.valueOf((byte) 1)); //$NON-NLS-1$
355 | }
356 | }
357 | } catch (Throwable e) {
358 | System.err.println("Unable to set underline or strikeout" + " (probably on a non-Windows platform). " + e); //$NON-NLS-1$ //$NON-NLS-2$
359 | }
360 | }
361 | font = new Font(Display.getCurrent(), fontData);
362 | m_fontMap.put(fontName, font);
363 | }
364 | return font;
365 | }
366 | /**
367 | * Returns a bold version of the given {@link Font}.
368 | *
369 | * @param baseFont
370 | * the {@link Font} for which a bold version is desired
371 | * @return the bold version of the given {@link Font}
372 | */
373 | public static Font getBoldFont(Font baseFont) {
374 | Font font = m_fontToBoldFontMap.get(baseFont);
375 | if (font == null) {
376 | FontData fontDatas[] = baseFont.getFontData();
377 | FontData data = fontDatas[0];
378 | font = new Font(Display.getCurrent(), data.getName(), data.getHeight(), SWT.BOLD);
379 | m_fontToBoldFontMap.put(baseFont, font);
380 | }
381 | return font;
382 | }
383 | /**
384 | * Dispose all of the cached {@link Font}'s.
385 | */
386 | public static void disposeFonts() {
387 | // clear fonts
388 | for (Font font : m_fontMap.values()) {
389 | font.dispose();
390 | }
391 | m_fontMap.clear();
392 | // clear bold fonts
393 | for (Font font : m_fontToBoldFontMap.values()) {
394 | font.dispose();
395 | }
396 | m_fontToBoldFontMap.clear();
397 | }
398 | ////////////////////////////////////////////////////////////////////////////
399 | //
400 | // Cursor
401 | //
402 | ////////////////////////////////////////////////////////////////////////////
403 | /**
404 | * Maps IDs to cursors.
405 | */
406 | private static Map m_idToCursorMap = new HashMap();
407 | /**
408 | * Returns the system cursor matching the specific ID.
409 | *
410 | * @param id
411 | * int The ID value for the cursor
412 | * @return Cursor The system cursor matching the specific ID
413 | */
414 | public static Cursor getCursor(int id) {
415 | Integer key = Integer.valueOf(id);
416 | Cursor cursor = m_idToCursorMap.get(key);
417 | if (cursor == null) {
418 | cursor = new Cursor(Display.getDefault(), id);
419 | m_idToCursorMap.put(key, cursor);
420 | }
421 | return cursor;
422 | }
423 | /**
424 | * Dispose all of the cached cursors.
425 | */
426 | public static void disposeCursors() {
427 | for (Cursor cursor : m_idToCursorMap.values()) {
428 | cursor.dispose();
429 | }
430 | m_idToCursorMap.clear();
431 | }
432 | ////////////////////////////////////////////////////////////////////////////
433 | //
434 | // General
435 | //
436 | ////////////////////////////////////////////////////////////////////////////
437 | /**
438 | * Dispose of cached objects and their underlying OS resources. This should only be called when the cached
439 | * objects are no longer needed (e.g. on application shutdown).
440 | */
441 | public static void dispose() {
442 | disposeColors();
443 | disposeImages();
444 | disposeFonts();
445 | disposeCursors();
446 | }
447 | }
--------------------------------------------------------------------------------
/src/soot/AstGeneratror.java:
--------------------------------------------------------------------------------
1 | package soot;
2 |
3 | import java.io.File;
4 | import java.io.FileWriter;
5 | import java.io.PrintWriter;
6 | import java.nio.file.Paths;
7 |
8 | import com.github.javaparser.JavaParser;
9 | import com.github.javaparser.ParseResult;
10 | import com.github.javaparser.StaticJavaParser;
11 | import com.github.javaparser.ast.CompilationUnit;
12 | import com.github.javaparser.ast.expr.VariableDeclarationExpr;
13 | import com.github.javaparser.printer.YamlPrinter;
14 | import com.github.javaparser.printer.XmlPrinter;
15 | import com.github.javaparser.printer.DotPrinter;
16 |
17 |
18 | public class AstGeneratror {
19 |
20 | public ParseResult generate(String filepath) throws Exception {
21 |
22 | // 1. java file
23 | String absolutePath = filepath;
24 | ParseResult result = new JavaParser().parse(Paths.get(absolutePath));
25 | System.out.println(result.getResult().get());
26 | // 2. java code
27 | // ParseResult exprResult = new JavaParser().parseVariableDeclarationExpr("int x = 3");
28 | // System.out.println(exprResult.getResult().get());
29 | // YamlPrinter printer = new YamlPrinter(true);
30 | // System.out.println(printer.output(result.getResult().get()));
31 |
32 | // YamlPrinter printer = new YamlPrinter(true);
33 | // System.out.println(printer.output(result.getResult().get()));
34 | //
35 | // XmlPrinter printer = new XmlPrinter(true);
36 | // System.out.println(printer.output(result.getResult().get()));
37 | //
38 | String split[]=filepath.split("/");
39 | String arg1="";
40 | for(int i=0;i options) {
104 | if (drawer == null) {
105 | drawer = new CFGToDotGraph();
106 | drawer.setBriefLabels(PhaseOptions.getBoolean(options, briefLabelOptionName));
107 | drawer.setOnePage(!PhaseOptions.getBoolean(options, multipageOptionName));
108 | drawer.setUnexceptionalControlFlowAttr("color", "black");
109 | drawer.setExceptionalControlFlowAttr("color", "red");
110 | drawer.setExceptionEdgeAttr("color", "lightgray");
111 | drawer.setShowExceptions(Options.v().show_exception_dests());
112 | ir = CFGIntermediateRep.getIR(PhaseOptions.getString(options, irOptionName));
113 | graphtype = CFGGraphType.getGraphType(PhaseOptions.getString(options, graphTypeOptionName));
114 |
115 | AltClassLoader.v().setAltClassPath(PhaseOptions.getString(options, altClassPathOptionName));
116 | AltClassLoader.v().setAltClasses(
117 | new String[] { "soot.toolkits.graph.ArrayRefBlockGraph", "soot.toolkits.graph.Block",
118 | "soot.toolkits.graph.Block$AllMapTo", "soot.toolkits.graph.BlockGraph",
119 | "soot.toolkits.graph.BriefBlockGraph", "soot.toolkits.graph.BriefUnitGraph",
120 | "soot.toolkits.graph.CompleteBlockGraph", "soot.toolkits.graph.CompleteUnitGraph",
121 | "soot.toolkits.graph.TrapUnitGraph", "soot.toolkits.graph.UnitGraph",
122 | "soot.toolkits.graph.ZonedBlockGraph", });
123 | }
124 | }
125 |
126 | protected void print_cfg(Body body) {
127 | DirectedGraph graph = graphtype.buildGraph(body);
128 | //System.out.println(graph);
129 | DotGraph canvas = graphtype.drawGraph(drawer, graph, body);
130 | //GenerateFlow gen = new GenerateFlow((UnitGraph) graph);
131 |
132 |
133 |
134 | String methodname = body.getMethod().getSubSignature();
135 | String classname = body.getMethod().getDeclaringClass().getName().replaceAll("\\$", "\\.");
136 | String filename = soot.SourceLocator.v().getOutputDir();
137 | if (filename.length() > 0) {
138 | filename = filename + java.io.File.separator;
139 | }
140 | String pathname = filename + classname + " " + methodname.replace(java.io.File.separatorChar, '.') + DotGraph.DOT_EXTENSION;
141 |
142 | G.v().out.println("Generate dot file in " + pathname);
143 | canvas.plot(pathname);
144 |
145 |
146 |
147 | try {
148 | Runtime.getRuntime().exec("cmd /c copy "+eclipsepath+filename+classname+"*.dot "+path.replaceAll("/","\\\\")+" && "
149 | + "ren "+path.replaceAll("/","\\\\")+classname+"*.dot cfg.dot");
150 | } catch (IOException e) {
151 | // TODO Auto-generated catch block
152 | e.printStackTrace();
153 | }
154 | }
155 | }
--------------------------------------------------------------------------------
/src/soot/DataFlowGraph.java:
--------------------------------------------------------------------------------
1 | package soot;
2 |
3 |
4 | import java.util.List;
5 |
6 | import facade.JavaDataFlow;
7 | import facade.StaticJavaDataFlow;
8 | import model.DataFlowMethod;
9 | import model.DataFlowNode;
10 |
11 |
12 | public class DataFlowGraph {
13 |
14 | public model.DataFlowGraph generate(String filepath) {
15 |
16 | String split[]=filepath.split("/");
17 | String arg1="";
18 | for(int i=0;i m.getName().equals(nodeName)).findFirst().get();
37 | // List inputNodes = getA.getReturnNode().get().walkBackUntil(DataFlowNode::isInputParameter, dfg::owns);
38 | // System.out.println(inputNodes.get(0).getName());
39 |
40 | System.out.println("================Printing all fields in the DFG================");
41 | System.out.println(dfg);
42 | return dfg;
43 | }
44 |
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/soot/GenerateGraph.java:
--------------------------------------------------------------------------------
1 | package soot;
2 |
3 | import java.io.IOException;
4 |
5 | public class GenerateGraph {
6 | public void genera(String filepath) {
7 | String split[]=filepath.split("/");
8 | String arg1="";
9 | for(int i=0;i