| /******************************************************************************* |
| * Copyright (c) 2008 Wind River Systems 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 |
| * Wind River Systems - adapted to use with IToggleBreakpiontsTargetFactory extension |
| *******************************************************************************/ |
| package org.eclipse.debug.internal.ui.actions; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.core.expressions.EvaluationContext; |
| import org.eclipse.core.expressions.EvaluationResult; |
| import org.eclipse.core.expressions.Expression; |
| import org.eclipse.core.expressions.ExpressionConverter; |
| import org.eclipse.core.expressions.ExpressionTagNames; |
| import org.eclipse.core.expressions.IEvaluationContext; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IAdapterManager; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.internal.core.IConfigurationElementConstants; |
| import org.eclipse.debug.internal.ui.DebugUIPlugin; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.debug.ui.actions.IToggleBreakpointsTarget; |
| import org.eclipse.debug.ui.actions.IToggleBreakpointsTargetFactory; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.services.IEvaluationService; |
| |
| /** |
| * Organizes the toggle breakpoints target factories contributed through the |
| * extension point and keeps track of the toggle breakpoints target that |
| * the factories produce. The manager is accessed as a singleton through |
| * the <code>getDefault()</code> method. |
| * <p> |
| * The adapter mechanism for obtaining a toggle breakpoints target is |
| * still supported through a specialized toggle target factory. Targets |
| * contributed through this mechanism are labeled as "Default" in the UI. |
| * </p> |
| * |
| * @see IToggleBreakpointsTargetFactory |
| * @see IToggleBreakpointsTarget |
| * @see IToggleBreakpointsTargetExtension |
| * @since 3.5 |
| */ |
| public class ToggleBreakpointsTargetManager { |
| |
| /** |
| * Toggle breakpoints target ID which refers to a target contributed |
| * through the legacy adapter mechanism. |
| */ |
| public static String DEFAULT_TOGGLE_TARGET_ID = "default"; //$NON-NLS-1$ |
| |
| private static Set DEFAULT_TOGGLE_TARGET_ID_SET = new HashSet(); |
| static { |
| DEFAULT_TOGGLE_TARGET_ID_SET.add(DEFAULT_TOGGLE_TARGET_ID); |
| } |
| |
| /** |
| * Acts as a proxy between the toggle breakpoints target manager and the factories |
| * contributed to the extension point. Only loads information from the plug-in xml |
| * and only instantiates the specified factory if required (lazy loading). |
| */ |
| private static class ToggleTargetFactory implements IToggleBreakpointsTargetFactory { |
| |
| private IConfigurationElement fConfigElement; |
| private IToggleBreakpointsTargetFactory fFactory; |
| private Expression fEnablementExpression; |
| |
| public ToggleTargetFactory(IConfigurationElement configElement){ |
| fConfigElement = configElement; |
| } |
| |
| /** |
| * Returns the instantiated factory specified by the class property. |
| */ |
| private IToggleBreakpointsTargetFactory getFactory() { |
| if (fFactory != null) return fFactory; |
| try{ |
| Object obj = fConfigElement.createExecutableExtension(IConfigurationElementConstants.CLASS); |
| if(obj instanceof IToggleBreakpointsTargetFactory) { |
| fFactory = (IToggleBreakpointsTargetFactory)obj; |
| } else { |
| throw new CoreException(new Status(IStatus.ERROR, DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, "org.eclipse.debug.ui.toggleBreakpointsTargetFactories extension failed to load breakpoint toggle target because the specified class does not implement org.eclipse.debug.ui.actions.IToggleBreakpointsTargetFactory. Class specified was: " + obj, null)); //$NON-NLS-1$ |
| } |
| } catch (CoreException e){ |
| DebugUIPlugin.log(e.getStatus()); |
| fFactory = null; |
| } |
| return fFactory; |
| } |
| |
| /** |
| * Checks if the enablement expression for the factory evaluates to true for the |
| * given part and selection. |
| */ |
| public boolean isEnabled(IWorkbenchPart part, ISelection selection) { |
| boolean enabled = false; |
| Expression expression = getEnablementExpression(); |
| if (expression != null) { |
| enabled = evalEnablementExpression(part, selection, expression); |
| } else { |
| enabled = true; |
| } |
| return enabled; |
| } |
| |
| /** |
| * Returns the active debug context given the active part. It is used |
| * in creating the evaluation context for the factories' enablement expression. |
| * @param part active part |
| * @return current active debug context |
| */ |
| private IStructuredSelection getDebugContext(IWorkbenchPart part) { |
| ISelection selection = DebugUITools.getDebugContextManager(). |
| getContextService(part.getSite().getWorkbenchWindow()).getActiveContext(); |
| if (selection instanceof IStructuredSelection) { |
| return (IStructuredSelection)selection; |
| } |
| return StructuredSelection.EMPTY; |
| } |
| |
| /** |
| * Evaluate the given expression within the given context and return |
| * the result. Returns <code>true</code> iff result is either TRUE. |
| * |
| * @param exp the enablement expression to evaluate or <code>null</code> |
| * @param context the context of the evaluation. Usually, the |
| * user's selection. |
| * @return the result of evaluating the expression |
| */ |
| private boolean evalEnablementExpression(IWorkbenchPart part, ISelection selection, Expression exp) { |
| if (exp != null){ |
| IEvaluationContext parentContext = null; |
| IEvaluationService evaluationService = (IEvaluationService)PlatformUI.getWorkbench().getService(IEvaluationService.class); |
| if (evaluationService != null) { |
| parentContext = evaluationService.getCurrentState(); |
| } |
| IEvaluationContext context = new EvaluationContext(parentContext, part); |
| |
| List debugContextList = getDebugContext(part).toList(); |
| context.addVariable(IConfigurationElementConstants.DEBUG_CONTEXT, debugContextList); |
| |
| if (selection instanceof IStructuredSelection) { |
| List selectionList = ((IStructuredSelection)selection).toList(); |
| context.addVariable(IConfigurationElementConstants.SELECTION, selectionList); |
| } |
| |
| if (part instanceof IEditorPart) { |
| context.addVariable(IConfigurationElementConstants.EDITOR_INPUT, ((IEditorPart)part).getEditorInput()); |
| } |
| |
| try{ |
| EvaluationResult result = exp.evaluate(context); |
| if (result == EvaluationResult.TRUE){ |
| return true; |
| } |
| } catch (CoreException e){ |
| // Evaluation failed |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns an expression that represents the enablement logic for the |
| * breakpiont toggle target. |
| */ |
| private Expression getEnablementExpression(){ |
| if (fEnablementExpression == null) { |
| try{ |
| IConfigurationElement[] elements = fConfigElement.getChildren(ExpressionTagNames.ENABLEMENT); |
| IConfigurationElement enablement = elements.length > 0 ? elements[0] : null; |
| if (enablement != null) { |
| fEnablementExpression = ExpressionConverter.getDefault().perform(enablement); |
| } |
| } catch (CoreException e){ |
| DebugUIPlugin.log(e.getStatus()); |
| fEnablementExpression = null; |
| } |
| } |
| return fEnablementExpression; |
| } |
| |
| /** |
| * Instantiates the factory and asks it to produce the IToggleBreakpointsTarget |
| * for the given ID |
| */ |
| public IToggleBreakpointsTarget createToggleTarget(String targetID) { |
| IToggleBreakpointsTargetFactory factory = getFactory(); |
| if (factory != null) { |
| return factory.createToggleTarget(targetID); |
| } |
| return null; |
| } |
| |
| /** |
| * Instantiates the factory and asks it for the set of toggle target |
| * IDs that the factory can produce for the given part and selection. |
| */ |
| public Set getToggleTargets(IWorkbenchPart part, ISelection selection) { |
| IToggleBreakpointsTargetFactory factory = getFactory(); |
| if (factory != null) { |
| return factory.getToggleTargets(part, selection); |
| } |
| return Collections.EMPTY_SET; |
| } |
| |
| /** |
| * Instantiates the factory and asks it to produce the name of the toggle target |
| * for the given ID. |
| */ |
| public String getToggleTargetName(String targetID) { |
| IToggleBreakpointsTargetFactory factory = getFactory(); |
| if (factory != null) { |
| return factory.getToggleTargetName(targetID); |
| } |
| return null; |
| } |
| |
| /** |
| * Instantiates the factory and asks it to produce the description of the toggle |
| * target for the given ID. |
| */ |
| public String getToggleTargetDescription(String targetID) { |
| IToggleBreakpointsTargetFactory factory = getFactory(); |
| if (factory != null) { |
| return factory.getToggleTargetDescription(targetID); |
| } |
| return null; |
| } |
| |
| /** |
| * Instantiates the factory and asks it for the toggle tareget ID that |
| * the factory considers the default for the given part and selection. |
| */ |
| public String getDefaultToggleTarget(IWorkbenchPart part, ISelection selection) { |
| IToggleBreakpointsTargetFactory factory = getFactory(); |
| if (factory != null) { |
| return factory.getDefaultToggleTarget(part, selection); |
| } |
| return null; |
| } |
| } |
| |
| |
| /** |
| * Factory for toggle breakpoints targets contributed through the |
| * adapter mechanism. |
| */ |
| private static class ToggleBreakpointsTargetAdapterFactory implements IToggleBreakpointsTargetFactory { |
| |
| private IAdaptable getAdaptable(IWorkbenchPart part, ISelection selection) { |
| IAdaptable adaptable = null; |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection ss = (IStructuredSelection)selection; |
| if (ss.getFirstElement() instanceof IAdaptable) { |
| adaptable = (IAdaptable) ss.getFirstElement(); |
| } |
| } else { |
| adaptable = part; |
| } |
| return adaptable; |
| } |
| |
| private boolean canGetToggleBreakpointsTarget(IAdaptable adaptable) { |
| if (adaptable != null) { |
| IToggleBreakpointsTarget adapter = (IToggleBreakpointsTarget) |
| adaptable.getAdapter(IToggleBreakpointsTarget.class); |
| if (adapter == null) { |
| IAdapterManager adapterManager = Platform.getAdapterManager(); |
| if (adapterManager.hasAdapter(adaptable, IToggleBreakpointsTarget.class.getName())) { |
| return true; |
| } |
| } else { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Finds the toggle breakpoints target for the active part and selection. |
| * It first looks for the target using the factories registered using an |
| * extension point. If not found it uses the <code>IAdaptable</code> |
| * mechanism. |
| * @param part active part |
| * @param selection active selection in part |
| * @return The toggle breakpoints target, or <code>null</code> if not found. |
| */ |
| private IToggleBreakpointsTarget getToggleBreakpointsTarget(IAdaptable adaptable) { |
| if (adaptable != null) { |
| IToggleBreakpointsTarget adapter = (IToggleBreakpointsTarget) |
| adaptable.getAdapter(IToggleBreakpointsTarget.class); |
| if (adapter == null) { |
| // attempt to force load adapter |
| IAdapterManager adapterManager = Platform.getAdapterManager(); |
| if (adapterManager.hasAdapter(adaptable, IToggleBreakpointsTarget.class.getName())) { |
| adapter = (IToggleBreakpointsTarget) |
| adapterManager.loadAdapter(adaptable, IToggleBreakpointsTarget.class.getName()); |
| } |
| } |
| return adapter; |
| } |
| return null; |
| } |
| |
| /** |
| * Checks if there is an adaptable object for the given part and |
| * selection, and if there is, it checks whether an |
| * <code>IToggleBreakpointsTarget</code> can be obtained as an adapter. |
| */ |
| public boolean isEnabled(IWorkbenchPart part, ISelection selection) { |
| IAdaptable adaptable = getAdaptable(part, selection); |
| return adaptable != null && canGetToggleBreakpointsTarget(adaptable); |
| } |
| |
| /** |
| * Not implemented use {@link #createDefaultToggleTarget(IWorkbenchPart, ISelection)} |
| * instead. |
| */ |
| public IToggleBreakpointsTarget createToggleTarget(String targetID) { |
| return null; |
| } |
| |
| /** |
| * Returns a toggle target for the given part and selection, obtained |
| * through the adapter mechanism. |
| */ |
| public IToggleBreakpointsTarget createDefaultToggleTarget(IWorkbenchPart part, ISelection selection) { |
| IAdaptable adaptable = getAdaptable(part, selection); |
| return getToggleBreakpointsTarget(adaptable); |
| } |
| |
| public Set getToggleTargets(IWorkbenchPart part, ISelection selection) { |
| IAdaptable adaptable = getAdaptable(part, selection); |
| if (canGetToggleBreakpointsTarget(adaptable)) { |
| return DEFAULT_TOGGLE_TARGET_ID_SET; |
| } |
| return Collections.EMPTY_SET; |
| } |
| |
| public String getToggleTargetName(String targetID) { |
| return ActionMessages.ToggleBreakpointsTargetManager_defaultToggleTarget_name; |
| } |
| |
| public String getToggleTargetDescription(String targetID) { |
| return ActionMessages.ToggleBreakpointsTargetManager_defaultToggleTarget_description; |
| } |
| |
| public String getDefaultToggleTarget(IWorkbenchPart part, ISelection selection) { |
| return DEFAULT_TOGGLE_TARGET_ID; |
| } |
| } |
| |
| |
| /** |
| * Preference key for storing the preferred targets map. |
| * @see {@link #storePreferredTargets()} |
| * @see {@link #loadPreferredTargets()} |
| */ |
| public static final String PREF_TARGETS = "preferredTargets"; //$NON-NLS-1$ |
| |
| |
| /** |
| * There should only ever be once instance of this manager for the workbench. |
| */ |
| private static ToggleBreakpointsTargetManager fgSingleton; |
| |
| public static ToggleBreakpointsTargetManager getDefault(){ |
| if (fgSingleton == null) fgSingleton = new ToggleBreakpointsTargetManager(); |
| return fgSingleton; |
| } |
| |
| /** |
| * Maps the IDs of toggle breakpoint targets to their instances. The target |
| * IDs must be unique. |
| */ |
| private Map fKnownFactories; |
| |
| /** |
| * Maps a Set of target id's to the one target id that is preferred. |
| */ |
| private Map fPreferredTargets; |
| |
| /** |
| * Maps the IDs of toggle targets to the factory that can create them. |
| * There can currently only be one factory for a given toggle target. |
| */ |
| private Map fFactoriesByTargetID = new HashMap(); |
| |
| /** |
| * List of listeners to changes in the preferred toggle targets list. |
| */ |
| private ListenerList fChangedListners = new ListenerList(); |
| |
| /** |
| * Initializes the collection of known factories from extension point contributions. |
| */ |
| private void initializeFactories() { |
| fKnownFactories = new LinkedHashMap(); |
| fKnownFactories.put(DEFAULT_TOGGLE_TARGET_ID, new ToggleBreakpointsTargetAdapterFactory()); |
| IExtensionPoint ep = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_TOGGLE_BREAKPOINTS_TARGET_FACTORIES); |
| IConfigurationElement[] elements = ep.getConfigurationElements(); |
| for (int i= 0; i < elements.length; i++) { |
| String id = elements[i].getAttribute(IConfigurationElementConstants.ID); |
| if (id != null && id.length() != 0) { |
| if (fKnownFactories.containsKey(id)) { |
| DebugUIPlugin.log(new Status(IStatus.ERROR, DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, "org.eclipse.debug.ui.toggleBreakpointsTargetFactory extension failed to load breakpoint toggle target because the specified id is already registered. Specified ID is: " + id, null)); //$NON-NLS-1$ |
| } else { |
| fKnownFactories.put(id, new ToggleTargetFactory(elements[i])); |
| } |
| } else { |
| DebugUIPlugin.log(new Status(IStatus.ERROR, DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, "org.eclipse.debug.ui.toggleBreakpointsTargetFactory extension failed to load breakpoint toggle target because the specified id is empty.", null)); //$NON-NLS-1$ |
| } |
| } |
| |
| // If there are any factories contributed through the extension point, |
| // set a system property for use in enabling actions. |
| System.setProperty(IDebugUIConstants.SYS_PROP_BREAKPOINT_TOGGLE_FACTORIES_USED, |
| fKnownFactories.size() > 1 ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| /** |
| * Returns the set of IToggleBreakpointsTargetFactory objects (they will be |
| * ToggleTargetFactory) that were contributed to the extension point and |
| * are enabled for the given part and selection (enabled if the factory |
| * does not have an enablement expression or if the enablement expression |
| * evaluates to true). |
| * |
| * @param part active part |
| * @param selection active selection in part |
| * @return The factories enabled for the part and selection or an empty |
| * collection. |
| */ |
| private Set getEnabledFactories(IWorkbenchPart part, ISelection selection) { |
| if (fKnownFactories == null) initializeFactories(); |
| |
| Set set = new LinkedHashSet(); |
| for (Iterator itr = fKnownFactories.keySet().iterator(); itr.hasNext(); ) { |
| String id = (String)itr.next(); |
| IToggleBreakpointsTargetFactory factory = (IToggleBreakpointsTargetFactory)fKnownFactories.get(id); |
| if (factory instanceof ToggleTargetFactory && |
| ((ToggleTargetFactory)factory).isEnabled(part, selection)) { |
| set.add(factory); |
| } else if (factory instanceof ToggleBreakpointsTargetAdapterFactory && |
| ((ToggleBreakpointsTargetAdapterFactory)factory).isEnabled(part, selection)) { |
| set.add(factory); |
| } |
| } |
| return set; |
| } |
| |
| /** |
| * Produces the set of IDs for all possible toggle targets that can be used for |
| * the given part and selection. |
| * |
| * @param factoriesToQuery The collection of factories to check |
| * @param part active part |
| * @param selection active selection in part |
| * @return Set of toggle target IDs or an empty set |
| */ |
| private Set getEnabledTargetIDs(Collection factoriesToQuery, IWorkbenchPart part, ISelection selection){ |
| Set idsForSelection = new LinkedHashSet(); |
| Iterator factoriesItr = factoriesToQuery.iterator(); |
| while (factoriesItr.hasNext()) { |
| IToggleBreakpointsTargetFactory factory = (IToggleBreakpointsTargetFactory) factoriesItr.next(); |
| Iterator targetIDsItr = factory.getToggleTargets(part, selection).iterator(); |
| while (targetIDsItr.hasNext()) { |
| String targetID = (String) targetIDsItr.next(); |
| fFactoriesByTargetID.put(targetID, factory); |
| idsForSelection.add(targetID); |
| } |
| } |
| return idsForSelection; |
| } |
| |
| /** |
| * Returns the set of <code>String</code> IDs of toggle breakpoint targets, |
| * which are enabled for the given active part and selection. The IDs can be used |
| * to create the {@link IToggleBreakpointsTarget} instance. |
| * @param part active part |
| * @param selection active selection in part |
| * @return Set of toggle target IDs or an empty set |
| */ |
| public Set getEnabledToggleBreakpointsTargetIDs(IWorkbenchPart part, ISelection selection) { |
| return getEnabledTargetIDs(getEnabledFactories(part, selection), part, selection); |
| } |
| |
| /** |
| * Returns the ID of the calculated preferred toggle breakpoints target for the |
| * given active part and selection. The returned ID is chosen based on factory |
| * enablement, whether the target is a default one, and on user choice. |
| * @param part active part |
| * @param selection active selection in part |
| * @return The toggle target IDs or null if none. |
| */ |
| public String getPreferredToggleBreakpointsTargetID(IWorkbenchPart part, ISelection selection) { |
| Set factories = getEnabledFactories(part, selection); |
| Set possibleIDs = getEnabledTargetIDs(factories, part, selection); |
| return chooseToggleTargetIDInSet(possibleIDs, factories, part, selection); |
| } |
| |
| /** |
| * Given the ID of toggle breakpoint target, this method will try to find the factory |
| * that creates it and return an instance of it. |
| * |
| * @param ID The ID of the requested toggle breakpoint target. |
| * @return The instantiated target or null |
| */ |
| public IToggleBreakpointsTarget getToggleBreakpointsTarget(IWorkbenchPart part, ISelection selection) { |
| String id = getPreferredToggleBreakpointsTargetID(part, selection); |
| IToggleBreakpointsTargetFactory factory = (IToggleBreakpointsTargetFactory)fFactoriesByTargetID.get(id); |
| if (factory != null) { |
| if (DEFAULT_TOGGLE_TARGET_ID.equals(id)) { |
| return ((ToggleBreakpointsTargetAdapterFactory)factory).createDefaultToggleTarget(part, selection); |
| } else { |
| return factory.createToggleTarget(id); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Given the ID of a toggle breakpoints target, this method will try |
| * to find the factory that creates it and ask it for the name of it. |
| * |
| * @param ID The ID of the requested toggle breakpoint target. |
| * @return The name of the target. |
| */ |
| public String getToggleBreakpointsTargetName(String id) { |
| IToggleBreakpointsTargetFactory factory = (IToggleBreakpointsTargetFactory)fFactoriesByTargetID.get(id); |
| if (factory != null) { |
| return factory.getToggleTargetName(id); |
| } |
| return null; |
| } |
| |
| /** |
| * Given the ID of a toggle breakpoints target, this method will try |
| * to find the factory that creates it and ask it for the description of it. |
| * |
| * @param ID The ID of the requested toggle breakpoint target. |
| * @return The description of the target or null. |
| */ |
| public String getToggleBreakpointsTargetDescription(String id) { |
| IToggleBreakpointsTargetFactory factory = (IToggleBreakpointsTargetFactory)fFactoriesByTargetID.get(id); |
| if (factory != null) { |
| return factory.getToggleTargetDescription(id); |
| } |
| return null; |
| } |
| |
| /** |
| * Adds the given listener to the list of listeners notified when the preferred |
| * toggle breakpoints targets change. |
| * @param listener The listener to add. |
| */ |
| public void addChangedListener(IToggleBreakpointsTargetManagerListener listener) { |
| fChangedListners.add(listener); |
| } |
| |
| /** |
| * Removes the given listener from the list of listeners notified when the preferred |
| * toggle breakpoints targets change. |
| * @param listener The listener to add. |
| */ |
| public void removeChangedListener(IToggleBreakpointsTargetManagerListener listener) { |
| fChangedListners.remove(listener); |
| } |
| |
| /** |
| * Stores the map of preferred target IDs to the preference store in the format: |
| * |
| * Key1A,Key1B:Value1|Key2A,Key2B,Key2C:Value2| |
| * |
| * Where the sub keys (Key1A, Key1B, etc.) are the elements of the set used at the |
| * key in the mapping and the values are the associated String value in the mapping. |
| */ |
| private void storePreferredTargets() { |
| StringBuffer buffer= new StringBuffer(); |
| Iterator iter = fPreferredTargets.entrySet().iterator(); |
| while (iter.hasNext()) { |
| Entry entry = (Entry) iter.next(); |
| Iterator setIter = ((Set)entry.getKey()).iterator(); |
| while (setIter.hasNext()) { |
| String currentID = (String) setIter.next(); |
| buffer.append(currentID); |
| buffer.append(','); |
| } |
| buffer.deleteCharAt(buffer.length()-1); |
| buffer.append(':'); |
| buffer.append(entry.getValue()); |
| buffer.append('|'); |
| } |
| DebugUIPlugin.getDefault().getPluginPreferences().setValue(PREF_TARGETS, buffer.toString()); |
| } |
| |
| /** |
| * Loads the map of preferred target IDs from the preference store. |
| * |
| * @see #storePreferredTargets() |
| */ |
| private void loadPreferredTargets() { |
| fPreferredTargets = new HashMap(); |
| String preferenceValue = DebugUIPlugin.getDefault().getPluginPreferences().getString(PREF_TARGETS); |
| StringTokenizer entryTokenizer = new StringTokenizer(preferenceValue,"|"); //$NON-NLS-1$ |
| while (entryTokenizer.hasMoreTokens()){ |
| String token = entryTokenizer.nextToken(); |
| int valueStart = token.indexOf(':'); |
| StringTokenizer keyTokenizer = new StringTokenizer(token.substring(0,valueStart),","); //$NON-NLS-1$ |
| Set keys = new LinkedHashSet(); |
| while (keyTokenizer.hasMoreTokens()){ |
| keys.add(keyTokenizer.nextToken()); |
| } |
| fPreferredTargets.put(keys, token.substring(valueStart+1)); |
| } |
| } |
| |
| /** |
| * Adds or updates the mapping to set which target ID is preferred for a certain |
| * set of possible IDs. |
| * |
| * @param possibleIDs The set of possible IDs |
| * @param preferredID The preferred ID in the set. |
| */ |
| public void setPreferredTarget(Set possibleIDs, String preferredID) { |
| if (possibleIDs == null) return; |
| |
| if (fKnownFactories == null) initializeFactories(); |
| |
| if (fPreferredTargets == null){ |
| loadPreferredTargets(); |
| } |
| String currentKey = (String)fPreferredTargets.get(possibleIDs); |
| if (currentKey == null || !currentKey.equals(preferredID)){ |
| fPreferredTargets.put(possibleIDs, preferredID); |
| storePreferredTargets(); |
| firePreferredTargetsChanged(); |
| } |
| } |
| |
| /** |
| * Returns the preferred pane ID from the given set if the mapping has been set. |
| * |
| * @param possibleDetailsAreaIDs Set of possible pane IDs |
| * @return The preferred ID or null |
| */ |
| private String getUserPreferredTarget(Set possibleTargetIDs){ |
| if (fPreferredTargets == null){ |
| loadPreferredTargets(); |
| } |
| return (String)fPreferredTargets.get(possibleTargetIDs); |
| } |
| |
| /** |
| * Given a set of possible detail pane IDs, this method will determine which pane is |
| * preferred and should be used to display the selection. This method chooses a pane |
| * by storing previous choices and can be set using a context menu. |
| * |
| * @param possiblePaneIDs The set of possible detail pane IDs |
| * @return The preferred detail pane ID or null |
| */ |
| private String chooseToggleTargetIDInSet(Set possibleTargetIDs, Collection enabledFactories, IWorkbenchPart part, ISelection selection){ |
| if (possibleTargetIDs == null || possibleTargetIDs.isEmpty()){ |
| return null; |
| } |
| |
| String preferredID = getUserPreferredTarget(possibleTargetIDs); |
| |
| if (preferredID == null){ |
| // If there is no preferred pane already set, check the factories to see there is a default target |
| Iterator factoryIterator = enabledFactories.iterator(); |
| while (preferredID == null && factoryIterator.hasNext()) { |
| IToggleBreakpointsTargetFactory currentFactory = (IToggleBreakpointsTargetFactory) factoryIterator.next(); |
| preferredID = currentFactory.getDefaultToggleTarget(part, selection); |
| } |
| // If the factories don't have a default, just pick the first one. |
| if (preferredID == null) { |
| preferredID= (String)possibleTargetIDs.iterator().next(); |
| } |
| setPreferredTarget(possibleTargetIDs, preferredID); |
| } |
| |
| return preferredID; |
| } |
| |
| /** |
| * Notifies the change listeners that the preferred targets changed. |
| */ |
| private void firePreferredTargetsChanged() { |
| Object[] listeners = fChangedListners.getListeners(); |
| for (int i = 0; i < listeners.length; i++) { |
| ((IToggleBreakpointsTargetManagerListener)listeners[i]).preferredTargetsChanged(); |
| } |
| } |
| |
| } |
