| /******************************************************************************* |
| * Copyright (c) 2006 Sybase, Inc. and others. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Sybase, Inc. - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.pagedesigner; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.MissingResourceException; |
| import java.util.Properties; |
| import java.util.ResourceBundle; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.FileLocator; |
| import org.eclipse.core.runtime.ILog; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.resource.ImageRegistry; |
| import org.eclipse.jst.jsf.common.ui.internal.guiutils.Alerts; |
| import org.eclipse.jst.jsf.common.ui.internal.logging.Logger; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.plugin.AbstractUIPlugin; |
| import org.osgi.framework.BundleContext; |
| |
| /** |
| * The main plugin class to be used in the desktop. |
| */ |
| public class PDPlugin extends AbstractUIPlugin { |
| private static final String ICONS_LIB_PATH = "icons"; //$NON-NLS-1$ |
| |
| //private static final boolean ROOT_PLUGIN = false; |
| |
| // The shared instance. |
| private static PDPlugin _plugin; |
| |
| private static Logger _log; |
| |
| private static Alerts _alerts; |
| |
| private ResourceBundle _resourceBundle; |
| |
| private Properties _properties; |
| |
| private URL _pluginBase; |
| |
| /** |
| * The constructor. |
| */ |
| public PDPlugin() { |
| super(); |
| _plugin = this; |
| } |
| |
| /** |
| * This method is called upon plug-in activation |
| */ |
| public void start(BundleContext context) throws Exception { |
| super.start(context); |
| |
| try { |
| // get resource bundle. |
| _resourceBundle = ResourceBundle |
| .getBundle(IJMTConstants.ROOT_RESOURCEBUNDLE); |
| _alerts = new Alerts(this, _resourceBundle); |
| |
| // get properties. |
| _properties = new Properties(); |
| InputStream input = null; |
| _pluginBase = getBundle().getEntry("/"); //$NON-NLS-1$ |
| try { |
| input = (new URL(_pluginBase, IJMTConstants.DEFAULT_PROPERTIES)) |
| .openStream(); |
| _properties.load(input); |
| } finally { |
| try { |
| input.close(); |
| } catch (IOException ee)// NOPMD |
| { |
| // nothing to do when IOException throwed in closing files. |
| } |
| } |
| |
| // set up logging for this plugin and everthing under it. |
| _log = new Logger(this.getBundle(), _resourceBundle); |
| |
| // NOTE: add in any other plugin code statup HERE!!!! |
| |
| // log.CommonPlugin=Web Application Development Common Plugin |
| // initialized on eclipse version {0}. |
| |
| // log.info("log.CommonPlugin", version); |
| |
| } catch (Exception ee) { |
| // only log if the logger was configured correctly. |
| if (_log != null) { |
| _log |
| .error( |
| "log.msg", //$NON-NLS-1$ |
| "Problems starting plug-in Web Application Development Common.", //$NON-NLS-1$ |
| ee); |
| } |
| |
| throw new CoreException( |
| new Status( |
| IStatus.ERROR, |
| getBundle().getSymbolicName(), |
| IStatus.OK, |
| "Problems starting plug-in Web Application Development Common", //$NON-NLS-1$ |
| ee)); |
| } |
| } |
| |
| /** |
| * Returns the shared instance. |
| * @return the default plugin |
| */ |
| public static PDPlugin getDefault() { |
| return _plugin; |
| } |
| |
| /** |
| * get the alerts objects associated with this plugin for alerting the user. |
| * |
| * @return the Alerts object |
| */ |
| public static Alerts getAlerts() { |
| return _alerts; |
| } |
| |
| /** |
| * Returns a logger for the new class using this plugin for reference. |
| * @param theClass |
| * @return the Logger object associated with theClass |
| */ |
| public static Logger getLogger(Class theClass) { |
| if (getDefault() != null && getDefault().getRootLogger() != null) { |
| return getDefault().getRootLogger(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the plugin's root logger |
| * @return the root logger |
| */ |
| public Logger getRootLogger() { |
| return _log; |
| } |
| |
| /** |
| * Returns this plugin's unique identifier |
| * @return the plugin id |
| */ |
| public static String getPluginId() { |
| return getDefault().getBundle().getSymbolicName(); |
| } |
| |
| /** |
| * @return the plugin's resource bundle |
| */ |
| public ResourceBundle getResourceBundle() { |
| return _resourceBundle; |
| } |
| |
| /** |
| * @param key |
| * @return the string from the plugin's resource bundle, or 'key' if not |
| * found. |
| */ |
| public static String getResourceString(String key) { |
| ResourceBundle bundle = PDPlugin.getDefault().getResourceBundle(); |
| try { |
| return (bundle != null) ? bundle.getString(key) : key; |
| } catch (MissingResourceException e) { |
| return '!' + key + '!'; |
| } |
| } |
| |
| /** |
| * @return the plugin's descriptor's resource bundle, |
| */ |
| public ResourceBundle getPluginDecriptorBundle() { |
| return Platform.getResourceBundle(getDefault().getBundle()); |
| } |
| |
| /** |
| * @return the plugin's default properties. These are normally used for |
| * default preferences. |
| */ |
| public Properties getProperties() { |
| return _properties; |
| } |
| |
| /** |
| * @return the standard display to be used. The method first checks, if the |
| * thread calling this method has an associated dispaly. If so, this display |
| * is returned. Otherwise the method returns the default display. |
| */ |
| public static Display getStandardDisplay() { |
| Display display; |
| display = Display.getCurrent(); |
| if (display == null) { |
| display = Display.getDefault(); |
| } |
| return display; |
| } |
| |
| /** |
| * @return the workspace instance. |
| */ |
| public static IWorkspace getWorkspace() { |
| return ResourcesPlugin.getWorkspace(); |
| } |
| |
| /** |
| * Returns a shared image for the given name. Image must exist in icons folder of pagedesigner plugin. |
| * <p> |
| * Note: Images returned from this method will be automitically disposed of |
| * when this plug-in shuts down. Callers must not dispose of these images |
| * themselves. |
| * </p> |
| * |
| * @param name |
| * the image name found in /icons (with extension) |
| * @return the image, null on error or not found. |
| */ |
| public Image getImage(String name) { |
| if (name == null) { |
| return null; |
| } |
| |
| ImageRegistry images = getImageRegistry(); |
| Image image = images.get(name); |
| if (image == null) { |
| getImageDescriptor(name); |
| image = images.get(name); |
| } |
| return image; |
| } |
| |
| /** |
| * Returns a shared ImageDescriptor for the given name |
| * <p> |
| * Note: ImageDescriptor returned from this method will be automatically |
| * disposed of when this plug-in shuts down. Callers must not dispose of |
| * these ImageDescriptor themselves. |
| * </p> |
| * |
| * @param name |
| * the ImageDescriptor name found in /icons (with extension) |
| * @return the ImageDescriptor, null on error or not found. |
| */ |
| public ImageDescriptor getImageDescriptor(String name) { |
| if (name == null) { |
| return null; |
| } |
| |
| ImageRegistry images = getImageRegistry(); |
| ImageDescriptor id = images.getDescriptor(name); |
| if (id == null) { |
| InputStream stream = null; |
| try {//check existance of file |
| URL url = new URL(_pluginBase, |
| ICONS_LIB_PATH + "/" + name); //$NON-NLS-1$ |
| |
| //doing the following to check existance... exception will be caught and null descriptor returned |
| stream = url.openStream(); |
| stream.close(); |
| |
| id = ImageDescriptor.createFromURL(url); |
| images.put(name, id); |
| } catch (IOException e1) { |
| _log.info("Unable to create ImageDescriptor for: "+name, e1); //$NON-NLS-1$ |
| return null; |
| } |
| } |
| return id; |
| } |
| |
| /** |
| * Read a file resource. The file should contain any partial path and the |
| * filename from the plugin base. The caller is responsible for closing the |
| * file. |
| * @param file |
| * @return the input stream for the file |
| * @throws MalformedURLException |
| * @throws IOException |
| */ |
| public InputStream readFile(String file) throws MalformedURLException, |
| IOException { |
| return (new URL(_pluginBase, file)).openStream(); |
| } |
| |
| /** |
| * @param file |
| * @return the File associate with the name 'file' |
| * @throws MalformedURLException |
| * @throws IOException |
| */ |
| public File getFile(String file) throws MalformedURLException, IOException { |
| return new File((new URL(_pluginBase, file)).getPath()); |
| } |
| |
| /** |
| * @return the plugin's install location with the leading "/" removed |
| * and normalized to the the os string. |
| */ |
| public static Path getInstallLocation() { |
| try { |
| URL url = getDefault().getBundle().getEntry("/"); //$NON-NLS-1$ |
| String s1 = FileLocator.resolve(url).getFile(); |
| if (s1.startsWith("/")) //$NON-NLS-1$ |
| { |
| s1 = s1.substring(1); |
| } |
| s1 = (new Path(s1)).toOSString(); |
| String s; |
| if (s1.endsWith(File.separator)) { |
| s = s1; |
| } else { |
| s = s1 + File.separator; |
| } |
| return new Path(s); |
| } catch (Exception exception) { |
| _log.error("Error.PDPlugin.Installation.15", exception); //$NON-NLS-1$ |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the active workbench window. |
| * |
| * @return the active workbench window. this can be null but I've never seen |
| * it. |
| */ |
| public static IWorkbenchWindow getActiveWorkbenchWindow() { |
| if (getDefault().getWorkbench() == null) { |
| return null; |
| } |
| return getDefault().getWorkbench().getActiveWorkbenchWindow(); |
| } |
| |
| /** |
| * Returns the active workbench page. Note that the active page may not be |
| * the one that the user perceives as active in some situations so this |
| * method of obtaining the activate page should only be used if no other |
| * method is available. |
| * |
| * @return the active workbench page |
| */ |
| public static IWorkbenchPage getActivePage() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window == null) { |
| return null; |
| } |
| return window.getActivePage(); |
| } |
| |
| /** |
| * Initializes the preference controls to the default values. These values |
| * are used the first time the preference page is displayed or when the user |
| * presses the Defaults button in the preferences page. |
| */ |
| protected void initializeDefaultPreferences(IPreferenceStore store) { |
| // initialize any preferences for this plugin. |
| } |
| |
| /** |
| * @return the active workbench Shell. Used for some funciton need IShell |
| * Parameter. |
| */ |
| public static Shell getActiveWorkbenchShell() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window != null) { |
| return window.getShell(); |
| } |
| IWorkbenchWindow[] windows = getDefault().getWorkbench() |
| .getWorkbenchWindows(); |
| if (windows.length > 0) { |
| return windows[0].getShell(); |
| } |
| return null; |
| } |
| |
| /** |
| * @return the active display. |
| */ |
| public static Display getDisplay() { |
| Shell shell = getActiveWorkbenchShell(); |
| if (shell != null) { |
| return shell.getDisplay(); |
| } |
| return Display.getDefault(); |
| } |
| |
| /** |
| * @return current active project. |
| */ |
| public static IProject getCurrentProject() { |
| IProject curProject = null; |
| IEditorPart editor = PDPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage().getActiveEditor(); |
| IEditorInput input = editor.getEditorInput(); |
| IFile inputFile = null; |
| if (input instanceof IFileEditorInput) { |
| inputFile = ((IFileEditorInput) input).getFile(); |
| curProject = inputFile.getProject(); |
| } |
| return curProject; |
| } |
| |
| /** |
| * Log status using the default plugin logger |
| * @param status |
| */ |
| public static void log(IStatus status) |
| { |
| ILog log = getDefault().getLog(); |
| log.log(status); |
| } |
| |
| /** |
| * @param message |
| * @param excp |
| */ |
| public static void log(String message, Throwable excp) |
| { |
| Status status = new Status(IStatus.ERROR, getPluginId(), message, excp); |
| log(status); |
| } |
| } |