/*****************************************************************************
* Limpet - the Lightweight InforMation ProcEssing Toolkit
* http://limpet.info
*
* (C) 2015-2016, Deep Blue C Technologies Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the Eclipse Public License v1.0
* (http://www.eclipse.org/legal/epl-v10.html)
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
package info.limpet.rcp.product;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IBundleGroup;
import org.eclipse.core.runtime.IBundleGroupProvider;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.ProgressMonitorWrapper;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.Policy;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.application.IWorkbenchConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.ISelectionConversionService;
import org.eclipse.ui.internal.PluginActionBuilder;
import org.eclipse.ui.internal.Workbench;
import org.eclipse.ui.internal.ide.AboutInfo;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEInternalWorkbenchImages;
import org.eclipse.ui.internal.ide.IDESelectionConversionService;
import org.eclipse.ui.internal.ide.IDEWorkbenchActivityHelper;
import org.eclipse.ui.internal.ide.IDEWorkbenchErrorHandler;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.application.DelayedEventsProcessor;
import org.eclipse.ui.internal.ide.undo.WorkspaceUndoMonitor;
import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
import org.eclipse.ui.progress.IProgressService;
import org.eclipse.ui.statushandlers.AbstractStatusHandler;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.Version;
/**
* IDE-specified workbench advisor which configures the workbench for use as an IDE.
* <p>
* Note: This class replaces <code>org.eclipse.ui.internal.Workbench</code>.
* </p>
*
* @since 3.0
*/
@SuppressWarnings("restriction")
public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor
{
private static final String WORKBENCH_PREFERENCE_CATEGORY_ID =
"org.eclipse.ui.preferencePages.Workbench"; //$NON-NLS-1$
/**
* The dialog setting key to access the known installed features since the last time the workbench
* was run.
*/
private static final String INSTALLED_FEATURES = "installedFeatures"; //$NON-NLS-1$
private static ApplicationWorkbenchAdvisor workbenchAdvisor = null;
/**
* Contains the workspace location if the -showlocation command line argument is specified, or
* <code>null</code> if not specified.
*/
private String workspaceLocation = null;
/**
* Ordered map of versioned feature ids -> info that are new for this session; <code>null</code>
* if uninitialized. Key type: <code>String</code>, Value type: <code>AboutInfo</code>.
*/
private Map<String, AboutInfo> newlyAddedBundleGroups;
/**
* Array of <code>AboutInfo</code> for all new installed features that specify a welcome
* perspective.
*/
private AboutInfo[] welcomePerspectiveInfos = null;
/**
* Helper for managing activites in response to workspace changes.
*/
private IDEWorkbenchActivityHelper activityHelper = null;
/**
* Helper for managing work that is performed when the system is otherwise idle.
*/
private IDEIdleHelper idleHelper;
private Listener settingsChangeListener;
/**
* Support class for monitoring workspace changes and periodically validating the undo history
*/
private WorkspaceUndoMonitor workspaceUndoMonitor;
/**
* The IDE workbench error handler.
*/
private AbstractStatusHandler ideWorkbenchErrorHandler;
/**
* Helper class used to process delayed events.
*/
private DelayedEventsProcessor delayedEventsProcessor;
/**
* Creates a new workbench advisor instance.
*/
public ApplicationWorkbenchAdvisor()
{
super();
if (workbenchAdvisor != null)
{
throw new IllegalStateException();
}
workbenchAdvisor = this;
Listener closeListener = new Listener()
{
public void handleEvent(Event event)
{
boolean doExit = ApplicationWorkbenchWindowAdvisor.promptOnExit(null);
event.doit = doExit;
if (!doExit)
{
event.type = SWT.None;
}
}
};
Display.getDefault().addListener(SWT.Close, closeListener);
}
/**
* Creates a new workbench advisor instance supporting delayed file open.
*
* @param processor
* helper class used to process delayed events
*/
public ApplicationWorkbenchAdvisor(DelayedEventsProcessor processor)
{
this();
this.delayedEventsProcessor = processor;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#initialize
*/
public void initialize(IWorkbenchConfigurer configurer)
{
PluginActionBuilder.setAllowIdeLogging(true);
// make sure we always save and restore workspace state
configurer.setSaveAndRestore(true);
// register workspace adapters
IDE.registerAdapters();
// get the command line arguments
String[] cmdLineArgs = Platform.getCommandLineArgs();
// include the workspace location in the title
// if the command line option -showlocation is specified
for (int i = 0; i < cmdLineArgs.length; i++)
{
if ("-showlocation".equalsIgnoreCase(cmdLineArgs[i]))
{ //$NON-NLS-1$
String name = null;
if (cmdLineArgs.length > i + 1)
{
name = cmdLineArgs[i + 1];
}
if (name != null && name.indexOf("-") == -1)
{ //$NON-NLS-1$
workspaceLocation = name;
}
else
{
workspaceLocation = Platform.getLocation().toOSString();
}
break;
}
}
// register shared images
declareWorkbenchImages();
// initialize the activity helper
activityHelper = IDEWorkbenchActivityHelper.getInstance();
// initialize idle handler
idleHelper = new IDEIdleHelper(configurer);
// initialize the workspace undo monitor
workspaceUndoMonitor = WorkspaceUndoMonitor.getInstance();
// show Help button in JFace dialogs
TrayDialog.setDialogHelpAvailable(true);
Policy.setComparator(Collator.getInstance());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#preStartup()
*/
public void preStartup()
{
// Suspend background jobs while we startup
Job.getJobManager().suspend();
// Register the build actions
IProgressService service = PlatformUI.getWorkbench().getProgressService();
ImageDescriptor newImage =
IDEInternalWorkbenchImages
.getImageDescriptor(IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC);
service
.registerIconForFamily(newImage, ResourcesPlugin.FAMILY_MANUAL_BUILD);
service.registerIconForFamily(newImage, ResourcesPlugin.FAMILY_AUTO_BUILD);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#postStartup()
*/
public void postStartup()
{
try
{
refreshFromLocal();
activateProxyService();
((Workbench) PlatformUI.getWorkbench()).registerService(
ISelectionConversionService.class,
new IDESelectionConversionService());
initializeSettingsChangeListener();
Display.getCurrent().addListener(SWT.Settings, settingsChangeListener);
}
finally
{
// Resume background jobs after we startup
Job.getJobManager().resume();
}
}
/**
* Activate the proxy service by obtaining it.
*/
@SuppressWarnings(
{"rawtypes", "unchecked"})
private void activateProxyService()
{
Bundle bundle = Platform.getBundle("org.eclipse.ui.ide"); //$NON-NLS-1$
Object proxyService = null;
if (bundle != null)
{
ServiceReference ref =
bundle.getBundleContext().getServiceReference(
IProxyService.class.getName());
if (ref != null)
{
proxyService = bundle.getBundleContext().getService(ref);
}
}
if (proxyService == null)
{
IDEWorkbenchPlugin.log("Proxy service could not be found."); //$NON-NLS-1$
}
}
/**
* Initialize the listener for settings changes.
*/
private void initializeSettingsChangeListener()
{
settingsChangeListener = new Listener()
{
private boolean currentHighContrast = Display.getCurrent()
.getHighContrast();
public void handleEvent(Event event)
{
if (Display.getCurrent().getHighContrast() == currentHighContrast)
{
return;
}
currentHighContrast = !currentHighContrast;
// make sure they really want to do this
if (new MessageDialog(null,
IDEWorkbenchMessages.SystemSettingsChange_title, null,
IDEWorkbenchMessages.SystemSettingsChange_message,
MessageDialog.QUESTION, new String[]
{IDEWorkbenchMessages.SystemSettingsChange_yes,
IDEWorkbenchMessages.SystemSettingsChange_no}, 1).open() == Window.OK)
{
PlatformUI.getWorkbench().restart();
}
}
};
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#postShutdown
*/
public void postShutdown()
{
if (activityHelper != null)
{
activityHelper.shutdown();
activityHelper = null;
}
if (idleHelper != null)
{
idleHelper.shutdown();
idleHelper = null;
}
if (workspaceUndoMonitor != null)
{
workspaceUndoMonitor.shutdown();
workspaceUndoMonitor = null;
}
if (IDEWorkbenchPlugin.getPluginWorkspace() != null)
{
disconnectFromWorkspace();
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#preShutdown()
*/
public boolean preShutdown()
{
Display.getCurrent().removeListener(SWT.Settings, settingsChangeListener);
return super.preShutdown();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.application.WorkbenchAdvisor#createWorkbenchWindowAdvisor(org.eclipse.ui.application
* .IWorkbenchWindowConfigurer)
*/
public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
IWorkbenchWindowConfigurer configurer)
{
return new ApplicationWorkbenchWindowAdvisor(this, configurer);
}
/**
* Return true if the intro plugin is present and false otherwise.
*
* @return boolean
*/
public boolean hasIntro()
{
return getWorkbenchConfigurer().getWorkbench().getIntroManager().hasIntro();
}
private void refreshFromLocal()
{
String[] commandLineArgs = Platform.getCommandLineArgs();
IPreferenceStore store =
IDEWorkbenchPlugin.getDefault().getPreferenceStore();
boolean refresh =
store.getBoolean(IDEInternalPreferences.REFRESH_WORKSPACE_ON_STARTUP);
if (!refresh)
{
return;
}
// Do not refresh if it was already done by core on startup.
for (int i = 0; i < commandLineArgs.length; i++)
{
if (commandLineArgs[i].equalsIgnoreCase("-refresh"))
{
//$NON-NLS-1$
return;
}
}
final IContainer root = ResourcesPlugin.getWorkspace().getRoot();
Job job = new WorkspaceJob(IDEWorkbenchMessages.Workspace_refreshing)
{
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException
{
root.refreshLocal(IResource.DEPTH_INFINITE, monitor);
return Status.OK_STATUS;
}
};
job.setRule(root);
job.schedule();
}
private static class CancelableProgressMonitorWrapper extends
ProgressMonitorWrapper
{
private double total = 0;
private ProgressMonitorJobsDialog dialog;
CancelableProgressMonitorWrapper(IProgressMonitor monitor,
ProgressMonitorJobsDialog dialog)
{
super(monitor);
this.dialog = dialog;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.ProgressMonitorWrapper#internalWorked(double)
*/
public void internalWorked(double work)
{
super.internalWorked(work);
total += work;
updateProgressDetails();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.ProgressMonitorWrapper#worked(int)
*/
public void worked(int work)
{
super.worked(work);
total += work;
updateProgressDetails();
}
public void beginTask(String name, int totalWork)
{
super.beginTask(name, totalWork);
subTask(IDEWorkbenchMessages.IDEWorkbenchAdvisor_preHistoryCompaction);
}
private void updateProgressDetails()
{
if (!isCanceled() && Math.abs(total - 4.0) < 0.0001 /* right before history compacting */)
{
subTask(IDEWorkbenchMessages.IDEWorkbenchAdvisor_cancelHistoryPruning);
dialog.setCancelable(true);
}
if (Math.abs(total - 5.0) < 0.0001 /* history compacting finished */)
{
subTask(IDEWorkbenchMessages.IDEWorkbenchAdvisor_postHistoryCompaction);
dialog.setCancelable(false);
}
}
}
private static class CancelableProgressMonitorJobsDialog extends
ProgressMonitorJobsDialog
{
CancelableProgressMonitorJobsDialog(Shell parent)
{
super(parent);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog#createDetailsButton(org.eclipse
* .swt.widgets.Composite)
*/
protected void createButtonsForButtonBar(Composite parent)
{
super.createButtonsForButtonBar(parent);
registerCancelButtonListener();
}
public void registerCancelButtonListener()
{
cancel.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent e)
{
subTaskLabel.setText(""); //$NON-NLS-1$
}
});
}
}
/**
* Disconnect from the core workspace.
*/
private void disconnectFromWorkspace()
{
// save the workspace
final MultiStatus status =
new MultiStatus(IDEWorkbenchPlugin.IDE_WORKBENCH, 1,
IDEWorkbenchMessages.ProblemSavingWorkbench, null);
try
{
final ProgressMonitorJobsDialog p =
new CancelableProgressMonitorJobsDialog(null);
final boolean applyPolicy =
ResourcesPlugin.getWorkspace().getDescription()
.isApplyFileStatePolicy();
IRunnableWithProgress runnable = new IRunnableWithProgress()
{
public void run(IProgressMonitor monitor)
{
try
{
if (applyPolicy)
{
monitor = new CancelableProgressMonitorWrapper(monitor, p);
}
status.merge(((Workspace) ResourcesPlugin.getWorkspace()).save(
true, true, monitor));
}
catch (CoreException e)
{
status.merge(e.getStatus());
}
}
};
p.run(true, false, runnable);
}
catch (InvocationTargetException e)
{
status.merge(new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH,
1, IDEWorkbenchMessages.InternalError, e.getTargetException()));
}
catch (InterruptedException e)
{
status.merge(new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH,
1, IDEWorkbenchMessages.InternalError, e));
}
ErrorDialog.openError(null, IDEWorkbenchMessages.ProblemsSavingWorkspace,
null, status, IStatus.ERROR | IStatus.WARNING);
if (!status.isOK())
{
IDEWorkbenchPlugin.log(IDEWorkbenchMessages.ProblemsSavingWorkspace,
status);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#getDefaultPageInput
*/
public IAdaptable getDefaultPageInput()
{
return ResourcesPlugin.getWorkspace().getRoot();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor
*/
public String getInitialWindowPerspectiveId()
{
int index = PlatformUI.getWorkbench().getWorkbenchWindowCount() - 1;
String perspectiveId = null;
AboutInfo[] welcomeInfos = getWelcomePerspectiveInfos();
if (index >= 0 && welcomeInfos != null && index < welcomeInfos.length)
{
perspectiveId = welcomeInfos[index].getWelcomePerspectiveId();
}
if (perspectiveId == null)
{
perspectiveId = Perspective.ID;
}
return perspectiveId;
}
/**
* Returns the map of versioned feature ids -> info object for all installed features. The format
* of the versioned feature id (the key of the map) is featureId + ":" + versionId.
*
* @return map of versioned feature ids -> info object (key type: <code>String</code>, value type:
* <code>AboutInfo</code>)
* @since 3.0
*/
private Map<String, AboutInfo> computeBundleGroupMap()
{
// use tree map to get predicable order
Map<String, AboutInfo> ids = new TreeMap<String, AboutInfo>();
IBundleGroupProvider[] providers = Platform.getBundleGroupProviders();
for (int i = 0; i < providers.length; ++i)
{
IBundleGroup[] groups = providers[i].getBundleGroups();
for (int j = 0; j < groups.length; ++j)
{
IBundleGroup group = groups[j];
AboutInfo info = new AboutInfo(group);
String version = info.getVersionId();
version = version == null ? "0.0.0" //$NON-NLS-1$
: new Version(version).toString();
String versionedFeature = group.getIdentifier() + ":" + version; //$NON-NLS-1$
ids.put(versionedFeature, info);
}
}
return ids;
}
/**
* Returns the ordered map of versioned feature ids -> AboutInfo that are new for this session.
*
* @return ordered map of versioned feature ids (key type: <code>String</code>) -> infos (value
* type: <code>AboutInfo</code>).
*/
public Map<String, AboutInfo> getNewlyAddedBundleGroups()
{
if (newlyAddedBundleGroups == null)
{
newlyAddedBundleGroups = createNewBundleGroupsMap();
}
return newlyAddedBundleGroups;
}
/**
* Updates the old features setting and returns a map of new features.
*/
private Map<String, AboutInfo> createNewBundleGroupsMap()
{
// retrieve list of installed bundle groups from last session
IDialogSettings settings =
IDEWorkbenchPlugin.getDefault().getDialogSettings();
String[] previousFeaturesArray = settings.getArray(INSTALLED_FEATURES);
// get a map of currently installed bundle groups and store it for next
// session
Map<String, AboutInfo> bundleGroups = computeBundleGroupMap();
String[] currentFeaturesArray = new String[bundleGroups.size()];
bundleGroups.keySet().toArray(currentFeaturesArray);
settings.put(INSTALLED_FEATURES, currentFeaturesArray);
// remove the previously known from the current set
if (previousFeaturesArray != null)
{
for (int i = 0; i < previousFeaturesArray.length; ++i)
{
bundleGroups.remove(previousFeaturesArray[i]);
}
}
return bundleGroups;
}
/**
* Declares all IDE-specific workbench images. This includes both "shared" images (named in
* {@link IDE.SharedImages}) and internal images (named in
* {@link org.eclipse.ui.internal.ide.IDEInternalWorkbenchImages}).
*
* @see IWorkbenchConfigurer#declareImage
*/
private void declareWorkbenchImages()
{
final String iconsPATH = "$nl$/icons/full/"; //$NON-NLS-1$
final String pathELOCALTOOL = iconsPATH + "elcl16/"; // Enabled //$NON-NLS-1$
// toolbar
// icons.
final String pathDLOCALTOOL = iconsPATH + "dlcl16/"; // Disabled //$NON-NLS-1$
// //$NON-NLS-1$
// toolbar
// icons.
final String pathETOOL = iconsPATH + "etool16/"; // Enabled toolbar //$NON-NLS-1$
// //$NON-NLS-1$
// icons.
final String pathDTOOL = iconsPATH + "dtool16/"; // Disabled toolbar //$NON-NLS-1$
// //$NON-NLS-1$
// icons.
final String pathOBJECT = iconsPATH + "obj16/"; // Model object //$NON-NLS-1$
// //$NON-NLS-1$
// icons
final String pathWIZBAN = iconsPATH + "wizban/"; // Wizard //$NON-NLS-1$
// //$NON-NLS-1$
// icons
// View icons
final String pathEVIEW = iconsPATH + "eview16/"; //$NON-NLS-1$
Bundle ideBundle = Platform.getBundle(IDEWorkbenchPlugin.IDE_WORKBENCH);
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC, pathETOOL
+ "build_exec.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC_HOVER, pathETOOL
+ "build_exec.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC_DISABLED, pathDTOOL
+ "build_exec.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC, pathETOOL
+ "search_src.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC_HOVER, pathETOOL
+ "search_src.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC_DISABLED, pathDTOOL
+ "search_src.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_NEXT_NAV, pathETOOL
+ "next_nav.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_PREVIOUS_NAV, pathETOOL
+ "prev_nav.gif", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_NEWPRJ_WIZ, pathWIZBAN
+ "newprj_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_NEWFOLDER_WIZ, pathWIZBAN
+ "newfolder_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_NEWFILE_WIZ, pathWIZBAN
+ "newfile_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTDIR_WIZ, pathWIZBAN
+ "importdir_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTZIP_WIZ, pathWIZBAN
+ "importzip_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTDIR_WIZ, pathWIZBAN
+ "exportdir_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTZIP_WIZ, pathWIZBAN
+ "exportzip_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_WIZBAN_RESOURCEWORKINGSET_WIZ,
pathWIZBAN + "workset_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_DLGBAN_SAVEAS_DLG, pathWIZBAN
+ "saveas_wiz.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_DLGBAN_QUICKFIX_DLG, pathWIZBAN
+ "quick_fix.png", false); //$NON-NLS-1$
declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJ_PROJECT,
pathOBJECT + "prj_obj.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJ_PROJECT_CLOSED,
pathOBJECT + "cprj_obj.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OPEN_MARKER,
pathELOCALTOOL + "gotoobj_tsk.gif", true); //$NON-NLS-1$
// Quick fix icons
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ELCL_QUICK_FIX_ENABLED, pathELOCALTOOL
+ "smartmode_co.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_DLCL_QUICK_FIX_DISABLED, pathDLOCALTOOL
+ "smartmode_co.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_FIXABLE_WARNING, pathOBJECT
+ "quickfix_warning_obj.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_FIXABLE_ERROR, pathOBJECT
+ "quickfix_error_obj.gif", true); //$NON-NLS-1$
// task objects
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_HPRIO_TSK,
// PATH_OBJECT+"hprio_tsk.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_MPRIO_TSK,
// PATH_OBJECT+"mprio_tsk.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_LPRIO_TSK,
// PATH_OBJECT+"lprio_tsk.gif");
declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJS_TASK_TSK,
pathOBJECT + "taskmrk_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJS_BKMRK_TSK,
pathOBJECT + "bkmrk_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_COMPLETE_TSK, pathOBJECT
+ "complete_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_INCOMPLETE_TSK, pathOBJECT
+ "incomplete_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_ITEM, pathOBJECT
+ "welcome_item.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_BANNER, pathOBJECT
+ "welcome_banner.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_ERROR_PATH, pathOBJECT
+ "error_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_WARNING_PATH, pathOBJECT
+ "warn_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_OBJS_INFO_PATH, pathOBJECT
+ "info_tsk.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_LCL_FLAT_LAYOUT, pathELOCALTOOL
+ "flatLayout.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_LCL_HIERARCHICAL_LAYOUT, pathELOCALTOOL
+ "hierarchicalLayout.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEM_CATEGORY, pathETOOL
+ "problem_category.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEMS_VIEW, pathEVIEW
+ "problems_view.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEMS_VIEW_ERROR, pathEVIEW
+ "problems_view_error.gif", true); //$NON-NLS-1$
declareWorkbenchImage(ideBundle,
IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEMS_VIEW_WARNING, pathEVIEW
+ "problems_view_warning.gif", true); //$NON-NLS-1$
// synchronization indicator objects
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_WBET_STAT,
// PATH_OVERLAY+"wbet_stat.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_SBET_STAT,
// PATH_OVERLAY+"sbet_stat.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_CONFLICT_STAT,
// PATH_OVERLAY+"conflict_stat.gif");
// content locality indicator objects
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_NOTLOCAL_STAT,
// PATH_STAT+"notlocal_stat.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_LOCAL_STAT,
// PATH_STAT+"local_stat.gif");
// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_FILLLOCAL_STAT,
// PATH_STAT+"filllocal_stat.gif");
}
/**
* Declares an IDE-specific workbench image.
*
* @param symbolicName
* the symbolic name of the image
* @param path
* the path of the image file; this path is relative to the base of the IDE plug-in
* @param shared
* <code>true</code> if this is a shared image, and <code>false</code> if this is not a
* shared image
* @see IWorkbenchConfigurer#declareImage
*/
private void declareWorkbenchImage(Bundle ideBundle, String symbolicName,
String path, boolean shared)
{
URL url = FileLocator.find(ideBundle, new Path(path), null);
ImageDescriptor desc = ImageDescriptor.createFromURL(url);
getWorkbenchConfigurer().declareImage(symbolicName, desc, shared);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#getMainPreferencePageId
*/
public String getMainPreferencePageId()
{
// indicate that we want the Workench preference page to be prominent
return WORKBENCH_PREFERENCE_CATEGORY_ID;
}
/**
* @return the workspace location string, or <code>null</code> if the location is not being shown
*/
public String getWorkspaceLocation()
{
return workspaceLocation;
}
/**
* @return the welcome perspective infos, or <code>null</code> if none or if they should be
* ignored due to the new intro being present
*/
public AboutInfo[] getWelcomePerspectiveInfos()
{
// support old welcome perspectives if intro plugin is not present
if (welcomePerspectiveInfos == null && !hasIntro())
{
Map<String, AboutInfo> m = getNewlyAddedBundleGroups();
List<AboutInfo> list = new ArrayList<AboutInfo>(m.size());
for (Iterator<AboutInfo> i = m.values().iterator(); i.hasNext();)
{
AboutInfo info = (AboutInfo) i.next();
if (info != null && info.getWelcomePerspectiveId() != null
&& info.getWelcomePageURL() != null)
{
list.add(info);
}
}
welcomePerspectiveInfos = new AboutInfo[list.size()];
list.toArray(welcomePerspectiveInfos);
}
return welcomePerspectiveInfos;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#getWorkbenchErrorHandler()
*/
public synchronized AbstractStatusHandler getWorkbenchErrorHandler()
{
if (ideWorkbenchErrorHandler == null)
{
ideWorkbenchErrorHandler =
new IDEWorkbenchErrorHandler(getWorkbenchConfigurer());
}
return ideWorkbenchErrorHandler;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#eventLoopIdle(org.eclipse.swt.widgets.Display)
*/
public void eventLoopIdle(Display display)
{
if (delayedEventsProcessor != null)
{
delayedEventsProcessor.catchUp(display);
}
super.eventLoopIdle(display);
}
}