KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > ui > internal > browser > WebBrowserUtil


1 /*******************************************************************************
2  * Copyright (c) 2003, 2005 IBM Corporation and others.
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  * IBM Corporation - Initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.ui.internal.browser;
12
13 import java.io.File JavaDoc;
14 import java.util.ArrayList JavaDoc;
15 import java.util.Iterator JavaDoc;
16 import java.util.List JavaDoc;
17
18 import org.eclipse.swt.program.Program;
19 import org.eclipse.swt.widgets.Display;
20 import org.eclipse.swt.widgets.Shell;
21 import org.eclipse.core.runtime.IStatus;
22 import org.eclipse.core.runtime.Platform;
23 import org.eclipse.core.runtime.Status;
24 import org.eclipse.jface.dialogs.MessageDialog;
25 import org.eclipse.swt.SWT;
26 import org.eclipse.swt.browser.Browser;
27 import org.eclipse.ui.PlatformUI;
28 /**
29  * Utility class for the Web browser tools.
30  */

31 public class WebBrowserUtil {
32     private static final String JavaDoc BROWSER_PACKAGE_NAME = "org.eclipse.swt.browser.Browser"; //$NON-NLS-1$
33

34     public static Boolean JavaDoc isInternalBrowserOperational;
35
36     private static final char STYLE_SEP = '-';
37
38     private static final int DEFAULT_STYLE = BrowserViewer.BUTTON_BAR
39             | BrowserViewer.LOCATION_BAR;
40
41     /**
42      * WebBrowserUtil constructor comment.
43      */

44     public WebBrowserUtil() {
45         super();
46     }
47
48     /**
49      * Returns true if we're running on Windows.
50      *
51      * @return boolean
52      */

53     public static boolean isWindows() {
54         String JavaDoc os = System.getProperty("os.name"); //$NON-NLS-1$
55
if (os != null && os.toLowerCase().indexOf("win") >= 0) //$NON-NLS-1$
56
return true;
57         return false;
58     }
59
60     /**
61      * Returns true if we're running on linux.
62      *
63      * @return boolean
64      */

65     public static boolean isLinux() {
66         String JavaDoc os = System.getProperty("os.name"); //$NON-NLS-1$
67
if (os != null && os.toLowerCase().indexOf("lin") >= 0) //$NON-NLS-1$
68
return true;
69         return false;
70     }
71
72     /**
73      * Open a dialog window.
74      *
75      * @param message
76      * java.lang.String
77      */

78     public static void openError(String JavaDoc message) {
79         Display d = Display.getCurrent();
80         if (d == null)
81             d = Display.getDefault();
82
83         Shell shell = d.getActiveShell();
84         MessageDialog.openError(shell, Messages.errorDialogTitle, message);
85     }
86
87     /**
88      * Open a dialog window.
89      *
90      * @param message
91      * java.lang.String
92      */

93     public static void openMessage(String JavaDoc message) {
94         Display d = Display.getCurrent();
95         if (d == null)
96             d = Display.getDefault();
97
98         Shell shell = d.getActiveShell();
99         MessageDialog.openInformation(shell, Messages.searchingTaskName,
100                 message);
101     }
102
103     /**
104      * Returns whether it should be possible to use the internal browser or not,
105      * based on whether or not the org.eclipse.swt.Browser class can be
106      * found/loaded. If it can it means is is supported on the platform in which
107      * this plugin is running. If not, disable the ability to use the internal
108      * browser. This method checks to see if it can new up a new
109      * ExternalBrowserInstance. If the SWT widget can not be bound to the
110      * particular operating system it throws an SWTException. We catch that and
111      * set a boolean flag which represents whether or not we were successfully
112      * able to create a ExternalBrowserInstance instance or not. If not, don't
113      * bother adding the Internal Web ExternalBrowserInstance that uses this
114      * widget. Designed to be attemped only once and the flag set used
115      * throughout.
116      *
117      * @return boolean
118      */

119     public static boolean canUseInternalWebBrowser() {
120         // if we have already figured this out, don't do it again.
121
if (isInternalBrowserOperational != null)
122             return isInternalBrowserOperational.booleanValue();
123
124         // check for the class
125
try {
126             Class.forName(BROWSER_PACKAGE_NAME);
127         } catch (ClassNotFoundException JavaDoc e) {
128             isInternalBrowserOperational = new Boolean JavaDoc(false);
129             return false;
130         }
131
132         // try loading it
133
Shell shell = null;
134         try {
135             shell = new Shell(PlatformUI.getWorkbench().getDisplay());
136             new Browser(shell, SWT.NONE);
137             isInternalBrowserOperational = new Boolean JavaDoc(true);
138             return true;
139         } catch (Throwable JavaDoc t) {
140             WebBrowserUIPlugin.getInstance().getLog().log(
141                     new Status(IStatus.WARNING, WebBrowserUIPlugin.PLUGIN_ID,
142                             0, "Internal browser is not available: " + t.getMessage(), null)); //$NON-NLS-1$
143
isInternalBrowserOperational = new Boolean JavaDoc(false);
144             return false;
145         } finally {
146             if (shell != null)
147                 shell.dispose();
148         }
149     }
150
151     public static boolean canUseSystemBrowser() {
152         // Disabling system browser on Solaris due to bug 94497
153
if (Platform.OS_SOLARIS.equals(Platform.getOS()))
154             return false;
155         return Program.findProgram("html") != null; //$NON-NLS-1$
156
}
157
158     public static List JavaDoc getExternalBrowserPaths() {
159         List JavaDoc paths = new ArrayList JavaDoc();
160         Iterator JavaDoc iterator = BrowserManager.getInstance().getWebBrowsers()
161                 .iterator();
162         while (iterator.hasNext()) {
163             IBrowserDescriptor wb = (IBrowserDescriptor) iterator.next();
164             if (wb != null && wb.getLocation() != null)
165                 paths.add(wb.getLocation().toLowerCase());
166         }
167         return paths;
168     }
169
170     /**
171      * Add any supported EXTERNAL web browsers found after an arbitrary check in
172      * specific paths
173      */

174     public static void addFoundBrowsers(List JavaDoc list) {
175         List JavaDoc paths = getExternalBrowserPaths();
176
177         String JavaDoc os = Platform.getOS();
178         File JavaDoc[] roots = getUsableDrives(File.listRoots());
179         int rootSize = roots.length;
180
181         // Math.min(roots.length, 2); // just check the first two drives
182

183         IBrowserExt[] browsers = WebBrowserUIPlugin.getBrowsers();
184         int size = browsers.length;
185         for (int i = 0; i < size; i++) {
186             if (browsers[i].getDefaultLocations() != null
187                     && browsers[i].getOS().toLowerCase().indexOf(os) >= 0) {
188                 for (int k = 0; k < rootSize; k++) {
189                     int size2 = browsers[i].getDefaultLocations().length;
190                     for (int j = 0; j < size2; j++) {
191                         String JavaDoc location = browsers[i].getDefaultLocations()[j];
192                         try {
193                             File JavaDoc f = new File JavaDoc(roots[k], location);
194                             if (!paths.contains(f.getAbsolutePath()
195                                     .toLowerCase())) {
196                                 if (f.exists()) {
197                                     BrowserDescriptor browser = new BrowserDescriptor();
198                                     browser.name = browsers[i].getName();
199                                     browser.location = f.getAbsolutePath();
200                                     browser.parameters = browsers[i]
201                                             .getParameters();
202                                     list.add(browser);
203                                     j += size2;
204                                 }
205                             }
206                         } catch (Exception JavaDoc e) {
207                             // ignore
208
}
209                     }
210                 }
211             }
212         }
213     }
214
215     private static File JavaDoc[] getUsableDrives(File JavaDoc[] roots) {
216         if (!Platform.getOS().equals(Platform.OS_WIN32))
217             return roots;
218         ArrayList JavaDoc list = new ArrayList JavaDoc();
219         for (int i = 0; i < roots.length; i++) {
220             String JavaDoc path = roots[i].getAbsolutePath();
221             if (path != null
222                     && (path.toLowerCase().startsWith("a:") || path.toLowerCase().startsWith("b:"))) //$NON-NLS-1$ //$NON-NLS-2$
223
continue;
224             list.add(roots[i]);
225         }
226         return (File JavaDoc[]) list.toArray(new File JavaDoc[list.size()]);
227     }
228
229     /**
230      * Create an external Web browser if the file matches the default (known)
231      * browsers.
232      *
233      * @param file
234      * @return an external browser working copy
235      */

236     public static IBrowserDescriptorWorkingCopy createExternalBrowser(File JavaDoc file) {
237         if (file == null || !file.isFile())
238             return null;
239
240         String JavaDoc executable = file.getName();
241         IBrowserExt[] browsers = WebBrowserUIPlugin.getBrowsers();
242         int size = browsers.length;
243         for (int i = 0; i < size; i++) {
244             if (executable.equals(browsers[i].getExecutable())) {
245                 IBrowserDescriptorWorkingCopy browser = BrowserManager
246                         .getInstance().createExternalWebBrowser();
247                 browser.setName(browsers[i].getName());
248                 browser.setLocation(file.getAbsolutePath());
249                 browser.setParameters(browsers[i].getParameters());
250                 return browser;
251             }
252         }
253
254         return null;
255     }
256
257     /**
258      * Encodes browser style in the secondary id as id-style
259      *
260      * @param browserId
261      * @param style
262      * @return secondaryId
263      */

264     public static String JavaDoc encodeStyle(String JavaDoc browserId, int style) {
265         return browserId + STYLE_SEP + style;
266     }
267
268     /**
269      * Decodes secondary id into a browser style.
270      *
271      * @param secondaryId
272      * @return style
273      */

274     public static int decodeStyle(String JavaDoc secondaryId) {
275         if (secondaryId != null) {
276             int sep = secondaryId.lastIndexOf(STYLE_SEP);
277             if (sep != -1) {
278                 String JavaDoc stoken = secondaryId.substring(sep + 1);
279                 try {
280                     return Integer.parseInt(stoken);
281                 } catch (NumberFormatException JavaDoc e) {
282                     // ignore
283
}
284             }
285         }
286         return DEFAULT_STYLE;
287     }
288
289     public static String JavaDoc decodeId(String JavaDoc encodedId) {
290         int sep = encodedId.lastIndexOf(STYLE_SEP);
291         if (sep != -1) {
292             return encodedId.substring(0, sep);
293         }
294         return encodedId;
295     }
296 }
Popular Tags