| /******************************************************************************* |
| * Copyright (c) 2005 IBM Corporation 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.debug.internal.ui.preferences; |
| |
| import java.io.IOException; |
| import java.io.StringReader; |
| import com.ibm.icu.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.ILaunchConfigurationType; |
| import org.eclipse.debug.core.ILaunchManager; |
| import org.eclipse.debug.core.ILaunchMode; |
| import org.eclipse.debug.internal.ui.DebugUIPlugin; |
| import org.eclipse.debug.internal.ui.IDebugHelpContextIds; |
| import org.eclipse.debug.internal.ui.IInternalDebugUIConstants; |
| import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager; |
| import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupFilter; |
| import org.eclipse.debug.internal.ui.launchConfigurations.PerspectiveManager; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.MessageDialogWithToggle; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferencePage; |
| import org.eclipse.jface.preference.RadioGroupFieldEditor; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.ui.IPerspectiveDescriptor; |
| import org.eclipse.ui.IPerspectiveRegistry; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPreferencePage; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.activities.ActivityManagerEvent; |
| import org.eclipse.ui.activities.IActivityManagerListener; |
| import org.eclipse.ui.activities.WorkbenchActivityHelper; |
| import org.eclipse.ui.model.WorkbenchViewerSorter; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| /** |
| * Provides one place to set perspective preferences |
| * |
| * @since 3.2 |
| */ |
| public class PerspectivePreferencePage extends PreferencePage implements IWorkbenchPreferencePage, IDebugPreferenceConstants, IActivityManagerListener { |
| |
| // constants |
| private static final String DEBUG_LAUNCH_GROUP = "org.eclipse.debug.ui.launchGroup.debug"; //$NON-NLS-1$ |
| |
| private static final String LAST_SELECTED_CONFIGTYPE = "last_selected"; //$NON-NLS-1$ |
| |
| private static final int LABEL_WIDTH_HINT = 450; |
| |
| /** |
| * A composite to add and dispose fComboComposites from |
| */ |
| private Composite fPerspectiveComp = null; |
| |
| /** |
| * Launch configuration type to mode mapping. allows us to store all the |
| * changed information until ok, apply or cancel is pressed Formed as |
| * follows: Map<typeId,HashMap<modeId, perspective>> |
| */ |
| private HashMap fTypeInformationMapping = null; |
| |
| /** |
| * The list of perspective labels |
| */ |
| private String[] fPerspectiveLabels = null; |
| |
| /** |
| * A mapping of perspective labels to ids of the form Map<label, id> |
| */ |
| private HashMap fPerspectiveIds = null; |
| |
| /** |
| * the composite to add the combo boxes and their labels to |
| */ |
| private Composite fComboPlaceHolder = null; |
| |
| /** |
| * the viewer for the list of launch configurations |
| */ |
| private TreeViewer fViewer = null; |
| |
| /** |
| * The tree for the viewer |
| */ |
| private Tree fTree = null; |
| |
| /** |
| * Manages a launch configuration |
| */ |
| private ILaunchManager fLManager = DebugPlugin.getDefault().getLaunchManager(); |
| |
| /** |
| * The global manager for all launch configurations |
| */ |
| private LaunchConfigurationManager fLCM = DebugUIPlugin.getDefault().getLaunchConfigurationManager(); |
| |
| /** |
| * manages perspectives |
| */ |
| private PerspectiveManager fPmanager = DebugUIPlugin.getDefault().getPerspectiveManager(); |
| |
| /** |
| * The field for switching perspective on run/debug |
| */ |
| private RadioGroupFieldEditor perspec = null; |
| |
| /** |
| * The field for switching when suspends |
| */ |
| private RadioGroupFieldEditor suspend = null; |
| |
| /** |
| * The currently selected ILaunchConfiguration from the tree |
| */ |
| private ILaunchConfigurationType fCurrentType = null; |
| |
| /** |
| * listens for widgets to change their selection. In this case we use it |
| * soley for setting changes in any of the combo boxes for perspective |
| * types. |
| */ |
| private SelectionAdapter fSelectionAdapter = new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| Object source = e.getSource(); |
| if (source instanceof Combo) { |
| Combo combo = (Combo) source; |
| HashMap map = (HashMap) fTypeInformationMapping.get(fCurrentType); |
| if (map == null) { |
| map = new HashMap(); |
| }// end if |
| map.put(combo.getData(), fPerspectiveIds.get(combo.getText())); |
| fTypeInformationMapping.put(fCurrentType, map); |
| }// end if |
| }// end widgetselected |
| }; |
| |
| /** |
| * Default constructor |
| */ |
| public PerspectivePreferencePage() { |
| IPreferenceStore store = DebugUIPlugin.getDefault().getPreferenceStore(); |
| setPreferenceStore(store); |
| setTitle(DebugPreferencesMessages.PerspectivePreferencePage_6); |
| setDescription(DebugPreferencesMessages.PerspectivePreferencePage_0); |
| }// end constructor |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.preference.IPreferencePage#performOk() |
| */ |
| public boolean performOk() { |
| IPreferenceStore store = getPreferenceStore(); |
| perspec.store(); |
| suspend.store(); |
| for (Iterator iter = fTypeInformationMapping.keySet().iterator(); iter.hasNext();) { |
| ILaunchConfigurationType typekey = (ILaunchConfigurationType)iter.next(); |
| HashMap map = (HashMap) fTypeInformationMapping.get(typekey); |
| for (Iterator iter2 = map.keySet().iterator(); iter2.hasNext();) { |
| String modekey = (String) iter2.next(); |
| String perspective = (String) map.get(modekey); |
| if (perspective != null) { |
| if (perspective.equals(DebugPreferencesMessages.PerspectivePreferencePage_4)) { |
| perspective = IDebugUIConstants.PERSPECTIVE_NONE; |
| }// end if |
| }// end if |
| else { |
| perspective = IDebugUIConstants.PERSPECTIVE_NONE; |
| }//end else |
| fPmanager.setLaunchPerspective(typekey, modekey, perspective); |
| }// end for |
| }// end for |
| if(fCurrentType != null) { |
| store.setValue(LAST_SELECTED_CONFIGTYPE, fCurrentType.getName()); |
| } |
| DebugUIPlugin.getDefault().savePluginPreferences(); |
| return super.performOk(); |
| }// end performOK |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench) |
| */ |
| public void init(IWorkbench workbench) {} |
| |
| /** |
| * Restore the state from the preference store |
| */ |
| private void restoreState() { |
| String xml = getPreferenceStore().getString(IInternalDebugUIConstants.PREF_LAUNCH_PERSPECTIVES); |
| // bug 111485 in case a new plugin offers a launch type between invocations, do this prior to setting them to saved states |
| setDefaultPerspectives(); |
| if (xml != null && xml.length() > 0) { |
| try { |
| Element root = null; |
| DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder(); |
| parser.setErrorHandler(new DefaultHandler()); |
| StringReader reader = new StringReader(xml); |
| InputSource source = new InputSource(reader); |
| root = parser.parse(source).getDocumentElement(); |
| NodeList list = root.getChildNodes(); |
| int length = list.getLength(); |
| for (int i = 0; i < length; ++i) { |
| Node node = list.item(i); |
| short nt = node.getNodeType(); |
| if (nt == Node.ELEMENT_NODE) { |
| Element element = (Element) node; |
| String nodeName = element.getNodeName(); |
| if (nodeName.equalsIgnoreCase(PerspectiveManager.ELEMENT_PERSPECTIVE)) { |
| String type = element.getAttribute(PerspectiveManager.ATTR_TYPE_ID); |
| ILaunchConfigurationType typeobj = fLManager.getLaunchConfigurationType(type); |
| String mode = element.getAttribute(PerspectiveManager.ATTR_MODE_ID); |
| if(typeobj != null) { |
| String perspective = fPmanager.getLaunchPerspective(typeobj, mode); |
| HashMap map = (HashMap) fTypeInformationMapping.get(typeobj); |
| if(map == null) { |
| map = new HashMap(); |
| }//end if |
| map.put(mode, (perspective != null ? perspective : IDebugUIConstants.PERSPECTIVE_NONE)); |
| fTypeInformationMapping.put(typeobj, map); |
| }//end if |
| }// end if |
| }// end if |
| }// end for |
| }// end try |
| catch (ParserConfigurationException e) {DebugUIPlugin.log(e);} |
| catch (SAXException e) {DebugUIPlugin.log(e);} |
| catch (IOException e) {DebugUIPlugin.log(e);} |
| }// end if |
| perspec.load(); |
| suspend.load(); |
| TreeItem item = findLastSelected(getPreferenceStore().getString(LAST_SELECTED_CONFIGTYPE)); |
| if (item != null) { |
| fTree.setSelection(new TreeItem[] { item }); |
| }// end if |
| else { |
| if(fTree.getItemCount() > 0) { |
| fTree.setSelection(new TreeItem[] { fTree.getItem(0) }); |
| } |
| }// end else |
| fCurrentType = (ILaunchConfigurationType) ((IStructuredSelection) fViewer.getSelection()).getFirstElement(); |
| buildComboBoxes(fCurrentType); |
| }// restoreState |
| |
| /** |
| * Sets the default perspectives for the modes of an ILaunchConfiguration |
| */ |
| private void setDefaultPerspectives() { |
| ILaunchConfigurationType[] types = fLManager.getLaunchConfigurationTypes(); |
| ArrayList modes = null; |
| HashMap map = null; |
| for (int i = 0; i < types.length; i++) { |
| modes = new ArrayList(types[i].getSupportedModes()); |
| map = new HashMap(); |
| for (int j = 0; j < modes.size(); j++) { |
| String mode = (String) modes.get(j); |
| String persp = fPmanager.getDefaultLaunchPerspective(types[i], mode); |
| map.put(mode, (persp != null ? persp : IDebugUIConstants.PERSPECTIVE_NONE)); |
| }// end for |
| fTypeInformationMapping.put(types[i], map); |
| }// end for |
| }//setDefaultPerspective |
| |
| /** |
| * Finds the ILaunchConfiguration within the tree based on its text |
| * |
| * @param last |
| * the name of the last Launch Configuration selected |
| * @return the treeitem if found or null |
| */ |
| private TreeItem findLastSelected(String last) { |
| TreeItem[] selection = fTree.getItems(); |
| for (int i = 0; i < selection.length; i++) { |
| if (selection[i].getText().equals(last)) { |
| return selection[i]; |
| }// end if |
| }// end for |
| return null; |
| }// end findLastSelected |
| |
| /** |
| * Builds all possible combo boxes per supported modes |
| */ |
| private void buildComboBoxes(ILaunchConfigurationType type) { |
| HashMap launchmodes = (HashMap) fTypeInformationMapping.get(type); |
| if (fComboPlaceHolder != null) { |
| fComboPlaceHolder.dispose(); |
| }// end if |
| Font font = fPerspectiveComp.getFont(); |
| fComboPlaceHolder = new Composite(fPerspectiveComp, SWT.NONE); |
| fComboPlaceHolder.setLayout(new GridLayout(2, false)); |
| fComboPlaceHolder.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| fComboPlaceHolder.setFont(font); |
| Label label = new Label(fComboPlaceHolder, SWT.NONE); |
| label.setText(DebugPreferencesMessages.PerspectivePreferencePage_2); |
| label.setFont(font); |
| GridData gd = null; |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| gd.horizontalSpan = 2; |
| label.setLayoutData(gd); |
| if(launchmodes != null) { |
| for(Iterator iter = launchmodes.keySet().iterator(); iter.hasNext();) { |
| String modekey = (String)iter.next(); |
| String persp = (String)launchmodes.get(modekey); |
| // build label |
| label = new Label(fComboPlaceHolder, SWT.NONE); |
| label.setFont(font); |
| gd = new GridData(GridData.BEGINNING); |
| label.setLayoutData(gd); |
| ILaunchMode mode = fLManager.getLaunchMode(modekey); |
| String clabel = mode.getLabel(); |
| //resolve conflict with Default and Debug mneumonics bug 122882 |
| if(clabel.equals(DebugPreferencesMessages.PerspectivePreferencePage_7)) { |
| clabel = DebugPreferencesMessages.PerspectivePreferencePage_8; |
| } |
| label.setText(MessageFormat.format(DebugPreferencesMessages.PerspectivePreferencePage_3, new String[] { clabel })); |
| // build combobox |
| Combo combo = new Combo(fComboPlaceHolder, SWT.READ_ONLY); |
| combo.setFont(font); |
| combo.setItems(fPerspectiveLabels); |
| combo.setData(modekey); |
| gd = new GridData(GridData.BEGINNING); |
| combo.setLayoutData(gd); |
| if(persp.equals(IDebugUIConstants.PERSPECTIVE_NONE)) { |
| persp = DebugPreferencesMessages.PerspectivePreferencePage_4; |
| }//end if |
| else { |
| IPerspectiveDescriptor desc = PlatformUI.getWorkbench().getPerspectiveRegistry().findPerspectiveWithId(persp); |
| persp = (desc != null ? desc.getLabel() : DebugPreferencesMessages.PerspectivePreferencePage_4); |
| }//end else |
| combo.setText(persp); |
| combo.addSelectionListener(fSelectionAdapter); |
| }//end for |
| } |
| fPerspectiveComp.layout(); |
| }// buildComboBoxes |
| |
| /** |
| * Handles the change in selection from the launch configuration listing |
| * |
| * @param event |
| * the selection changed event |
| */ |
| private void handleLaunchConfigurationSelectionChanged(SelectionChangedEvent event) { |
| // handle prompting and saving before moving on. |
| ILaunchConfigurationType type = (ILaunchConfigurationType) ((IStructuredSelection) event.getSelection()).getFirstElement(); |
| if(type != null) { |
| if(!type.equals(fCurrentType)) { |
| //if they are the same do nothing |
| fCurrentType = type; |
| buildComboBoxes(fCurrentType); |
| } |
| } |
| }// end handleLaunchConfigurationSelectionChanged |
| |
| /** |
| * Gets the perspective labels |
| * |
| * @return the (label, id) mappings of perspectives |
| */ |
| private void getPerspectiveLabels() { |
| IPerspectiveRegistry registry = PlatformUI.getWorkbench().getPerspectiveRegistry(); |
| IPerspectiveDescriptor[] descriptors = filterIds(registry.getPerspectives()); |
| fPerspectiveLabels = new String[descriptors.length + 1]; |
| fPerspectiveLabels[0] = DebugPreferencesMessages.PerspectivePreferencePage_4; |
| fPerspectiveIds = new HashMap(); |
| for (int i = 0; i < descriptors.length; i++) { |
| fPerspectiveLabels[i + 1] = descriptors[i].getLabel(); |
| fPerspectiveIds.put(descriptors[i].getLabel(), descriptors[i].getId()); |
| }// end for |
| }// end getPerspectiveLabels |
| |
| /** |
| * filters the list of labels based on capabilities |
| * @param ids ther ids we want to filter |
| * @return the filtered list of ids based on capabilities |
| */ |
| private IPerspectiveDescriptor[] filterIds(IPerspectiveDescriptor[] ids) { |
| ArrayList list = new ArrayList(); |
| for(int i = 0; i < ids.length; i++) { |
| if(!WorkbenchActivityHelper.filterItem(ids[i])) { |
| list.add(ids[i]); |
| } |
| } |
| return (IPerspectiveDescriptor[])list.toArray(new IPerspectiveDescriptor[list.size()]); |
| } |
| |
| /** |
| * Simple method to create a spacer in the page |
| * |
| * @param composite |
| * the composite to add the spacer to |
| * @param columnSpan |
| * the amount of space for the spacer |
| */ |
| protected void createSpacer(Composite composite, int columnSpan) { |
| Label label = new Label(composite, SWT.NONE); |
| GridData gd = new GridData(); |
| gd.horizontalSpan = columnSpan; |
| label.setLayoutData(gd); |
| }// end createSpacer |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.preference.PreferencePage#performDefaults() |
| */ |
| protected void performDefaults() { |
| perspec.loadDefault(); |
| suspend.loadDefault(); |
| setDefaultPerspectives(); |
| buildComboBoxes(fCurrentType); |
| super.performDefaults(); |
| }// end performdefaults |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.preference.PreferencePage#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createControl(Composite parent) { |
| super.createControl(parent); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IDebugHelpContextIds.PERSPECTIVE_PREFERENCE_PAGE); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite) |
| */ |
| protected Control createContents(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NONE); |
| composite.setLayout(new GridLayout(1, false)); |
| composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // create the global radio buttons |
| createSpacer(composite, 1); |
| perspec = new RadioGroupFieldEditor( |
| IInternalDebugUIConstants.PREF_SWITCH_TO_PERSPECTIVE, |
| DebugPreferencesMessages.LaunchingPreferencePage_11, 3, |
| new String[][] {{DebugPreferencesMessages.LaunchingPreferencePage_12, MessageDialogWithToggle.ALWAYS }, |
| { DebugPreferencesMessages.LaunchingPreferencePage_13, MessageDialogWithToggle.NEVER }, |
| { DebugPreferencesMessages.LaunchingPreferencePage_14, MessageDialogWithToggle.PROMPT } }, |
| composite, |
| true); |
| perspec.setPreferenceName(IInternalDebugUIConstants.PREF_SWITCH_TO_PERSPECTIVE); |
| perspec.setPreferenceStore(getPreferenceStore()); |
| suspend = new RadioGroupFieldEditor( |
| IInternalDebugUIConstants.PREF_SWITCH_PERSPECTIVE_ON_SUSPEND, |
| DebugPreferencesMessages.DebugPreferencePage_21, 3, |
| new String[][] {{ DebugPreferencesMessages.DebugPreferencePage_22, MessageDialogWithToggle.ALWAYS }, |
| { DebugPreferencesMessages.DebugPreferencePage_23, MessageDialogWithToggle.NEVER }, |
| { DebugPreferencesMessages.DebugPreferencePage_24, MessageDialogWithToggle.PROMPT } }, |
| composite, |
| true); |
| suspend.setPreferenceName(IInternalDebugUIConstants.PREF_SWITCH_PERSPECTIVE_ON_SUSPEND); |
| suspend.setPreferenceStore(getPreferenceStore()); |
| |
| createSpacer(composite, 1); |
| |
| Label lbl = new Label(composite, SWT.LEFT + SWT.WRAP); |
| lbl.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| ((GridData)lbl.getLayoutData()).widthHint = LABEL_WIDTH_HINT; |
| lbl.setText(MessageFormat.format(DebugPreferencesMessages.PerspectivePreferencePage_5, null)); |
| |
| Composite comp = new Composite(composite, SWT.FILL); |
| comp.setLayout(new GridLayout(2, false)); |
| comp.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| Composite treeComp = new Composite(comp, SWT.NONE); |
| treeComp.setLayout(new GridLayout(1, true)); |
| treeComp.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| Label label = new Label(treeComp, SWT.NONE); |
| label.setText(DebugPreferencesMessages.PerspectivePreferencePage_1); |
| |
| fTree = new Tree(treeComp, SWT.H_SCROLL + SWT.V_SCROLL + SWT.SINGLE + SWT.BORDER); |
| fTree.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| fViewer = new TreeViewer(fTree); |
| fViewer.setLabelProvider(DebugUITools.newDebugModelPresentation()); |
| fViewer.setSorter(new WorkbenchViewerSorter()); |
| fViewer.setContentProvider(new LaunchConfigurationTreeContentProviderNoChildren(null, parent.getShell())); |
| fViewer.addFilter(new LaunchGroupFilter(fLCM.getLaunchGroup(DEBUG_LAUNCH_GROUP))); |
| fViewer.setInput(fLManager.getLaunchConfigurationTypes()); |
| fViewer.expandAll(); |
| fViewer.addPostSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleLaunchConfigurationSelectionChanged(event); |
| }//end selectionChanged |
| }); |
| fPerspectiveComp = new Composite(comp, SWT.NONE); |
| fPerspectiveComp.setLayout(new GridLayout(1, true)); |
| fPerspectiveComp.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| fTypeInformationMapping = new HashMap(); |
| // get the available labels |
| getPerspectiveLabels(); |
| // restore from preference store |
| restoreState(); |
| |
| PlatformUI.getWorkbench().getActivitySupport().getActivityManager().addActivityManagerListener(this); |
| |
| Dialog.applyDialogFont(composite); |
| return composite; |
| }// end createControl |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.activities.IActivityManagerListener#activityManagerChanged(org.eclipse.ui.activities.ActivityManagerEvent) |
| */ |
| public void activityManagerChanged(ActivityManagerEvent activityManagerEvent) { |
| if(!fTree.isDisposed()) { |
| fViewer.refresh(); |
| getPerspectiveLabels(); |
| restoreState(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.dialogs.DialogPage#dispose() |
| */ |
| public void dispose() { |
| PlatformUI.getWorkbench().getActivitySupport().getActivityManager().removeActivityManagerListener(this); |
| super.dispose(); |
| } |
| |
| }// end class |
