/*****************************************************************************
* 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.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProduct;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IPageListener;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveRegistry;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartConstants;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PerspectiveAdapter;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.ide.FileStoreEditorInput;
import org.eclipse.ui.internal.ide.AboutInfo;
import org.eclipse.ui.internal.ide.EditorAreaDropAdapter;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.WorkbenchActionBuilder;
import org.eclipse.ui.internal.ide.application.IDEApplication;
import org.eclipse.ui.internal.ide.dialogs.WelcomeEditorInput;
import org.eclipse.ui.internal.tweaklets.TitlePathUpdater;
import org.eclipse.ui.internal.tweaklets.Tweaklets;
import org.eclipse.ui.part.EditorInputTransfer;
import org.eclipse.ui.part.MarkerTransfer;
import org.eclipse.ui.part.ResourceTransfer;
import org.eclipse.ui.statushandlers.StatusManager;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
@SuppressWarnings("restriction")
public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor
{
private static final String WELCOME_EDITOR_ID =
"org.eclipse.ui.internal.ide.dialogs.WelcomeEditor"; //$NON-NLS-1$
private ApplicationWorkbenchAdvisor wbAdvisor;
private boolean editorsAndIntrosOpened = false;
private IEditorPart lastActiveEditor = null;
private IPerspectiveDescriptor lastPerspective = null;
private IWorkbenchPage lastActivePage;
private String lastEditorTitle = ""; //$NON-NLS-1$
private IPropertyListener editorPropertyListener = new IPropertyListener()
{
public void propertyChanged(Object source, int propId)
{
if (propId == IWorkbenchPartConstants.PROP_TITLE
&& lastActiveEditor != null)
{
String newTitle = lastActiveEditor.getTitle();
if (!lastEditorTitle.equals(newTitle))
{
recomputeTitle();
}
}
}
};
private IAdaptable lastInput;
private IWorkbenchAction openPerspectiveAction;
/**
* The property change listener.
*
* @since 3.6.1
*/
private IPropertyChangeListener propertyChangeListener;
private TitlePathUpdater titlePathUpdater;
/**
* Crates a new IDE workbench window advisor.
*
* @param wbAdvisor
* the workbench advisor
* @param configurer
* the window configurer
*/
public ApplicationWorkbenchWindowAdvisor(
ApplicationWorkbenchAdvisor wbAdvisor,
IWorkbenchWindowConfigurer configurer)
{
super(configurer);
this.wbAdvisor = wbAdvisor;
titlePathUpdater = (TitlePathUpdater) Tweaklets.get(TitlePathUpdater.KEY);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.application.WorkbenchWindowAdvisor#createActionBarAdvisor(org.eclipse.ui.application
* .IActionBarConfigurer)
*/
public ActionBarAdvisor
createActionBarAdvisor(IActionBarConfigurer configurer)
{
return new WorkbenchActionBuilder(configurer);
}
/**
* Returns the workbench.
*
* @return the workbench
*/
private IWorkbench getWorkbench()
{
return getWindowConfigurer().getWorkbenchConfigurer().getWorkbench();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#preWindowShellClose
*/
public boolean preWindowShellClose()
{
if (getWorkbench().getWorkbenchWindowCount() > 1)
{
return true;
}
// the user has asked to close the last window, while will cause the
// workbench to close in due course - prompt the user for confirmation
return promptOnExit(getWindowConfigurer().getWindow().getShell());
}
/**
* Asks the user whether the workbench should really be closed. Only asks if the preference is
* enabled.
*
* @param parentShell
* the parent shell to use for the confirmation dialog
* @return <code>true</code> if OK to exit, <code>false</code> if the user canceled
* @since 3.6
*/
@SuppressWarnings("deprecation")
static boolean promptOnExit(Shell parentShell)
{
IPreferenceStore store =
IDEWorkbenchPlugin.getDefault().getPreferenceStore();
boolean promptOnExit =
store
.getBoolean(IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW);
if (promptOnExit)
{
if (parentShell == null)
{
IWorkbenchWindow workbenchWindow =
PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (workbenchWindow != null)
{
parentShell = workbenchWindow.getShell();
}
}
if (parentShell != null)
{
parentShell.setMinimized(false);
parentShell.forceActive();
}
String message;
String productName = null;
IProduct product = Platform.getProduct();
if (product != null)
{
productName = product.getName();
}
if (productName == null)
{
message = IDEWorkbenchMessages.PromptOnExitDialog_message0;
}
else
{
message =
NLS.bind(IDEWorkbenchMessages.PromptOnExitDialog_message1,
productName);
}
MessageDialogWithToggle dlg =
MessageDialogWithToggle
.openOkCancelConfirm(parentShell,
IDEWorkbenchMessages.PromptOnExitDialog_shellTitle, message,
IDEWorkbenchMessages.PromptOnExitDialog_choice, false, null,
null);
if (dlg.getReturnCode() != IDialogConstants.OK_ID)
{
return false;
}
if (dlg.getToggleState())
{
store.setValue(IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW,
false);
IDEWorkbenchPlugin.getDefault().savePluginPreferences();
}
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#preWindowOpen
*/
public void preWindowOpen()
{
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
// show the shortcut bar and progress indicator, which are hidden by
// default
configurer.setShowPerspectiveBar(true);
configurer.setShowFastViewBars(true);
configurer.setShowProgressIndicator(true);
// add the drag and drop support for the editor area
configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
configurer.addEditorAreaTransfer(FileTransfer.getInstance());
configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
configurer.getWindow()));
hookTitleUpdateListeners(configurer);
}
/**
* Hooks the listeners needed on the window
*
* @param configurer
*/
private void hookTitleUpdateListeners(IWorkbenchWindowConfigurer configurer)
{
// hook up the listeners to update the window title
configurer.getWindow().addPageListener(new IPageListener()
{
public void pageActivated(IWorkbenchPage page)
{
updateTitle(false);
}
public void pageClosed(IWorkbenchPage page)
{
updateTitle(false);
}
public void pageOpened(IWorkbenchPage page)
{
// do nothing
}
});
configurer.getWindow().addPerspectiveListener(new PerspectiveAdapter()
{
public void perspectiveActivated(IWorkbenchPage page,
IPerspectiveDescriptor perspective)
{
updateTitle(false);
}
public void perspectiveSavedAs(IWorkbenchPage page,
IPerspectiveDescriptor oldPerspective,
IPerspectiveDescriptor newPerspective)
{
updateTitle(false);
}
public void perspectiveDeactivated(IWorkbenchPage page,
IPerspectiveDescriptor perspective)
{
updateTitle(false);
}
});
configurer.getWindow().getPartService().addPartListener(
new IPartListener2()
{
public void partActivated(IWorkbenchPartReference ref)
{
if (ref instanceof IEditorReference)
{
updateTitle(false);
}
}
public void partBroughtToTop(IWorkbenchPartReference ref)
{
if (ref instanceof IEditorReference)
{
updateTitle(false);
}
}
public void partClosed(IWorkbenchPartReference ref)
{
updateTitle(false);
}
public void partDeactivated(IWorkbenchPartReference ref)
{
// do nothing
}
public void partOpened(IWorkbenchPartReference ref)
{
// do nothing
}
public void partHidden(IWorkbenchPartReference ref)
{
if (ref.getPart(false) == lastActiveEditor
&& lastActiveEditor != null)
{
updateTitle(true);
}
}
public void partVisible(IWorkbenchPartReference ref)
{
if (ref.getPart(false) == lastActiveEditor
&& lastActiveEditor != null)
{
updateTitle(false);
}
}
public void partInputChanged(IWorkbenchPartReference ref)
{
// do nothing
}
});
// Listen for changes of the workspace name.
propertyChangeListener = new IPropertyChangeListener()
{
public void propertyChange(PropertyChangeEvent event)
{
if (IDEInternalPreferences.WORKSPACE_NAME.equals(event.getProperty()))
{
// Make sure the title is actually updated by
// setting last active page.
lastActivePage = null;
updateTitle(false);
}
}
};
IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.addPropertyChangeListener(propertyChangeListener);
}
private String computeTitle()
{
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
IWorkbenchPage currentPage = configurer.getWindow().getActivePage();
IEditorPart activeEditor = null;
if (currentPage != null)
{
activeEditor = lastActiveEditor;
}
String title = null;
IProduct product = Platform.getProduct();
if (product != null)
{
title = product.getName();
}
if (title == null)
{
title = ""; //$NON-NLS-1$
}
if (currentPage != null)
{
if (activeEditor != null)
{
lastEditorTitle = activeEditor.getTitleToolTip();
title =
NLS.bind(IDEWorkbenchMessages.WorkbenchWindow_shellTitle,
lastEditorTitle, title);
}
IPerspectiveDescriptor persp = currentPage.getPerspective();
String label = ""; //$NON-NLS-1$
if (persp != null)
{
label = persp.getLabel();
}
IAdaptable input = currentPage.getInput();
if (input != null && !input.equals(wbAdvisor.getDefaultPageInput()))
{
label = currentPage.getLabel();
}
if (label != null && !label.equals(""))
{ //$NON-NLS-1$
title =
NLS.bind(IDEWorkbenchMessages.WorkbenchWindow_shellTitle, label,
title);
}
}
String workspaceLocation = wbAdvisor.getWorkspaceLocation();
if (workspaceLocation != null)
{
title =
NLS.bind(IDEWorkbenchMessages.WorkbenchWindow_shellTitle, title,
workspaceLocation);
}
// Bug 284447: Prepend workspace name to the title
String workspaceName =
IDEWorkbenchPlugin.getDefault().getPreferenceStore().getString(
IDEInternalPreferences.WORKSPACE_NAME);
if (workspaceName != null && workspaceName.length() > 0)
{
title =
NLS.bind(IDEWorkbenchMessages.WorkbenchWindow_shellTitle,
workspaceName, title);
}
return title;
}
private void recomputeTitle()
{
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
String oldTitle = configurer.getTitle();
String newTitle = computeTitle();
if (!newTitle.equals(oldTitle))
{
configurer.setTitle(newTitle);
}
setTitlePath();
}
private void setTitlePath()
{
String titlePath = null;
if (lastActiveEditor != null)
{
IEditorInput editorInput = lastActiveEditor.getEditorInput();
if (editorInput instanceof IFileEditorInput)
{
titlePath = computeTitlePath((IFileEditorInput) editorInput);
}
else if (editorInput instanceof FileStoreEditorInput)
{
titlePath = computeTitlePath((FileStoreEditorInput) editorInput);
}
}
titlePathUpdater.updateTitlePath(getWindowConfigurer().getWindow()
.getShell(), titlePath);
}
private String computeTitlePath(FileStoreEditorInput editorInput)
{
return editorInput.getURI().getPath().toString();
}
private String computeTitlePath(IFileEditorInput editorInput)
{
IFile file = editorInput.getFile();
IPath location = file.getLocation();
if (location != null)
{
return location.toFile().toString();
}
return null;
}
/**
* Updates the window title. Format will be: [pageInput -] [currentPerspective -] [editorInput -]
* [workspaceLocation -] productName
*
* @param editorHidden
* TODO
*/
private void updateTitle(boolean editorHidden)
{
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
IWorkbenchWindow window = configurer.getWindow();
IEditorPart activeEditor = null;
IWorkbenchPage currentPage = window.getActivePage();
IPerspectiveDescriptor persp = null;
IAdaptable input = null;
if (currentPage != null)
{
activeEditor = currentPage.getActiveEditor();
persp = currentPage.getPerspective();
input = currentPage.getInput();
}
if (editorHidden)
{
activeEditor = null;
}
// Nothing to do if the editor hasn't changed
if (activeEditor == lastActiveEditor && currentPage == lastActivePage
&& persp == lastPerspective && input == lastInput)
{
return;
}
if (lastActiveEditor != null)
{
lastActiveEditor.removePropertyListener(editorPropertyListener);
}
lastActiveEditor = activeEditor;
lastActivePage = currentPage;
lastPerspective = persp;
lastInput = input;
if (activeEditor != null)
{
activeEditor.addPropertyListener(editorPropertyListener);
}
recomputeTitle();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchAdvisor#postWindowRestore
*/
public void postWindowRestore() throws WorkbenchException
{
IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
IWorkbenchWindow window = configurer.getWindow();
int index = getWorkbench().getWorkbenchWindowCount() - 1;
AboutInfo[] welcomePerspectiveInfos =
wbAdvisor.getWelcomePerspectiveInfos();
if (index >= 0 && welcomePerspectiveInfos != null
&& index < welcomePerspectiveInfos.length)
{
// find a page that exist in the window
IWorkbenchPage page = window.getActivePage();
if (page == null)
{
IWorkbenchPage[] pages = window.getPages();
if (pages != null && pages.length > 0)
{
page = pages[0];
}
}
// if the window does not contain a page, create one
String perspectiveId =
welcomePerspectiveInfos[index].getWelcomePerspectiveId();
if (page == null)
{
IAdaptable root = wbAdvisor.getDefaultPageInput();
page = window.openPage(perspectiveId, root);
}
else
{
IPerspectiveRegistry reg = getWorkbench().getPerspectiveRegistry();
IPerspectiveDescriptor desc = reg.findPerspectiveWithId(perspectiveId);
if (desc != null)
{
page.setPerspective(desc);
}
}
// set the active page and open the welcome editor
window.setActivePage(page);
page.openEditor(new WelcomeEditorInput(welcomePerspectiveInfos[index]),
WELCOME_EDITOR_ID, true);
}
cleanUpEditorArea();
}
/**
* Tries to open the intro, if one exists and otherwise will open the legacy Welcome pages.
*
* @see org.eclipse.ui.application.WorkbenchWindowAdvisor#openIntro()
*/
@SuppressWarnings("deprecation")
public void openIntro()
{
if (editorsAndIntrosOpened)
{
return;
}
editorsAndIntrosOpened = true;
// don't try to open the welcome editors if there is an intro
if (wbAdvisor.hasIntro())
{
super.openIntro();
}
else
{
openWelcomeEditors(getWindowConfigurer().getWindow());
// save any preferences changes caused by the above actions
IDEWorkbenchPlugin.getDefault().savePluginPreferences();
}
}
/*
* Open the welcome editor for the primary feature and for any newly installed features.
*/
private void openWelcomeEditors(IWorkbenchWindow window)
{
if (IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(
IDEInternalPreferences.WELCOME_DIALOG))
{
// show the welcome page for the product the first time the
// workbench opens
IProduct product = Platform.getProduct();
if (product == null)
{
return;
}
AboutInfo productInfo = new AboutInfo(product);
URL url = productInfo.getWelcomePageURL();
if (url == null)
{
return;
}
IDEWorkbenchPlugin.getDefault().getPreferenceStore().setValue(
IDEInternalPreferences.WELCOME_DIALOG, false);
openWelcomeEditor(window, new WelcomeEditorInput(productInfo), null);
}
else
{
// Show the welcome page for any newly installed features
List<AboutInfo> welcomeFeatures = new ArrayList<AboutInfo>();
for (Iterator<Entry<String, AboutInfo>> it =
wbAdvisor.getNewlyAddedBundleGroups().entrySet().iterator(); it
.hasNext();)
{
Entry<String, AboutInfo> entry = it.next();
AboutInfo info = (AboutInfo) entry.getValue();
if (info != null && info.getWelcomePageURL() != null)
{
welcomeFeatures.add(info);
// activate the feature plug-in so it can run some install
// code
String pi = info.getBrandingBundleId();
if (pi != null)
{
// Start the bundle if there is one
Bundle bundle = Platform.getBundle(pi);
if (bundle != null)
{
try
{
bundle.start(Bundle.START_TRANSIENT);
}
catch (BundleException exception)
{
StatusManager.getManager().handle(
new Status(IStatus.ERROR, IDEApplication.PLUGIN_ID,
"Failed to load feature", exception)); //$NON-NLS-1$
}
}
}
}
}
int wCount = getWorkbench().getWorkbenchWindowCount();
for (int i = 0; i < welcomeFeatures.size(); i++)
{
AboutInfo newInfo = (AboutInfo) welcomeFeatures.get(i);
String id = newInfo.getWelcomePerspectiveId();
// Other editors were already opened in postWindowRestore(..)
if (id == null || i >= wCount)
{
openWelcomeEditor(window, new WelcomeEditorInput(newInfo), id);
}
}
}
}
/**
* Open a welcome editor for the given input
*/
private void openWelcomeEditor(IWorkbenchWindow window,
WelcomeEditorInput input, String perspectiveId)
{
if (getWorkbench().getWorkbenchWindowCount() == 0)
{
// Something is wrong, there should be at least
// one workbench window open by now.
return;
}
IWorkbenchWindow win = window;
if (perspectiveId != null)
{
try
{
win =
getWorkbench().openWorkbenchWindow(perspectiveId,
wbAdvisor.getDefaultPageInput());
if (win == null)
{
win = window;
}
}
catch (WorkbenchException e)
{
IDEWorkbenchPlugin.log(
"Error opening window with welcome perspective.", e.getStatus()); //$NON-NLS-1$
return;
}
}
if (win == null)
{
win = getWorkbench().getWorkbenchWindows()[0];
}
IWorkbenchPage page = win.getActivePage();
String id = perspectiveId;
if (id == null)
{
id = getWorkbench().getPerspectiveRegistry().getDefaultPerspective();
}
if (page == null)
{
try
{
page = win.openPage(id, wbAdvisor.getDefaultPageInput());
}
catch (WorkbenchException e)
{
ErrorDialog.openError(win.getShell(),
IDEWorkbenchMessages.Problems_Opening_Page, e.getMessage(), e
.getStatus());
}
}
if (page == null)
{
return;
}
if (page.getPerspective() == null)
{
try
{
page = getWorkbench().showPerspective(id, win);
}
catch (WorkbenchException e)
{
ErrorDialog.openError(win.getShell(),
IDEWorkbenchMessages.Workbench_openEditorErrorDialogTitle,
IDEWorkbenchMessages.Workbench_openEditorErrorDialogMessage, e
.getStatus());
return;
}
}
page.setEditorAreaVisible(true);
// see if we already have an editor
IEditorPart editor = page.findEditor(input);
if (editor != null)
{
page.activate(editor);
return;
}
try
{
page.openEditor(input, WELCOME_EDITOR_ID);
}
catch (PartInitException e)
{
ErrorDialog.openError(win.getShell(),
IDEWorkbenchMessages.Workbench_openEditorErrorDialogTitle,
IDEWorkbenchMessages.Workbench_openEditorErrorDialogMessage, e
.getStatus());
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.application.WorkbenchAdvisor#createEmptyWindowContents(org.eclipse.ui.application
* .IWorkbenchWindowConfigurer, org.eclipse.swt.widgets.Composite)
*/
public Control createEmptyWindowContents(Composite parent)
{
final IWorkbenchWindow window = getWindowConfigurer().getWindow();
Composite composite = new Composite(parent, SWT.NONE);
composite.setLayout(new GridLayout(2, false));
Display display = composite.getDisplay();
Color bgCol = display.getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND);
composite.setBackground(bgCol);
Label label = new Label(composite, SWT.WRAP);
label.setForeground(display
.getSystemColor(SWT.COLOR_TITLE_INACTIVE_FOREGROUND));
label.setBackground(bgCol);
label.setFont(JFaceResources.getFontRegistry().getBold(
JFaceResources.DEFAULT_FONT));
String msg = IDEWorkbenchMessages.IDEWorkbenchAdvisor_noPerspective;
label.setText(msg);
ToolBarManager toolBarManager = new ToolBarManager();
// TODO: should obtain the open perspective action from ActionFactory
openPerspectiveAction =
ActionFactory.OPEN_PERSPECTIVE_DIALOG.create(window);
toolBarManager.add(openPerspectiveAction);
ToolBar toolBar = toolBarManager.createControl(composite);
toolBar.setBackground(bgCol);
return composite;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.application.WorkbenchWindowAdvisor#dispose()
*/
public void dispose()
{
if (propertyChangeListener != null)
{
IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.removePropertyChangeListener(propertyChangeListener);
propertyChangeListener = null;
}
if (openPerspectiveAction != null)
{
openPerspectiveAction.dispose();
openPerspectiveAction = null;
}
super.dispose();
}
}