| /******************************************************************************* |
| * Copyright (c) 2000, 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 |
| * Sebastian Davids <sdavids@gmx.de> - Fix for bug 19346 - Dialog font should be |
| * activated and used by other components. |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.ide.misc; |
| |
| import java.text.Collator; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.Map; |
| |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; |
| import org.eclipse.jface.viewers.CheckboxTableViewer; |
| import org.eclipse.jface.viewers.ICheckStateListener; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.ListViewer; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.internal.ide.Category; |
| import org.eclipse.ui.internal.ide.IDEWorkbenchMessages; |
| import org.eclipse.ui.internal.ide.registry.Capability; |
| import org.eclipse.ui.internal.ide.registry.CapabilityRegistry; |
| import org.eclipse.ui.model.WorkbenchContentProvider; |
| import org.eclipse.ui.model.WorkbenchLabelProvider; |
| |
| /** |
| * A group of controls used to view and modify the |
| * set of capabilities on a project. |
| */ |
| public class ProjectCapabilitySelectionGroup { |
| private static final String EMPTY_DESCRIPTION = "\n\n\n"; //$NON-NLS-1$ |
| |
| private CapabilityRegistry registry; |
| |
| private Category[] initialCategories; |
| |
| private Capability[] initialCapabilities; |
| |
| private Capability[] disabledCapabilities; |
| |
| private boolean modified = false; |
| |
| private Text descriptionText; |
| |
| private CheckboxTableViewer checkboxViewer; |
| |
| private ICheckStateListener checkStateListener; |
| |
| private ArrayList visibleCapabilities = new ArrayList(); |
| |
| private ArrayList checkedCapabilities = new ArrayList(); |
| |
| private Collection disabledCaps; |
| |
| // For a given capability as key, the value will be a list of |
| // other capabilities that require the capability. Also, |
| // it may include the capability key if it was selected by the |
| // user before being required by other capabilities. |
| private HashMap dependents = new HashMap(); |
| |
| // For a given membership set id as key, the value is |
| // a checked capability |
| private HashMap memberships = new HashMap(); |
| |
| // Sort categories |
| private Comparator categoryComparator = new Comparator() { |
| private Collator collator = Collator.getInstance(); |
| |
| public int compare(Object ob1, Object ob2) { |
| Category c1 = (Category) ob1; |
| Category c2 = (Category) ob2; |
| return collator.compare(c1.getLabel(), c2.getLabel()); |
| } |
| }; |
| |
| // Sort capabilities |
| private Comparator capabilityComparator = new Comparator() { |
| private Collator collator = Collator.getInstance(); |
| |
| public int compare(Object ob1, Object ob2) { |
| Capability c1 = (Capability) ob1; |
| Capability c2 = (Capability) ob2; |
| return collator.compare(c1.getName(), c2.getName()); |
| } |
| }; |
| |
| /** |
| * Creates a new instance of the <code>ProjectCapabilitySelectionGroup</code> |
| * |
| * @param categories the initial collection of valid categories to select |
| * @param capabilities the intial collection of valid capabilities to select |
| * @param registry all available capabilities registered by plug-ins |
| */ |
| public ProjectCapabilitySelectionGroup(Category[] categories, |
| Capability[] capabilities, CapabilityRegistry registry) { |
| this(categories, capabilities, null, registry); |
| } |
| |
| /** |
| * Creates a new instance of the <code>ProjectCapabilitySelectionGroup</code> |
| * |
| * @param categories the initial collection of valid categories to select |
| * @param capabilities the intial collection of valid capabilities to select |
| * @param disabledCapabilities the collection of capabilities to show as disabled |
| * @param registry all available capabilities registered by plug-ins |
| */ |
| public ProjectCapabilitySelectionGroup(Category[] categories, |
| Capability[] capabilities, Capability[] disabledCapabilities, |
| CapabilityRegistry registry) { |
| super(); |
| this.initialCategories = categories; |
| this.initialCapabilities = capabilities; |
| this.disabledCapabilities = disabledCapabilities; |
| this.registry = registry; |
| } |
| |
| /** |
| * Create the contents of this group. The basic layout is a checkbox |
| * list with a text field at the bottom to display the capability |
| * description. |
| */ |
| public Control createContents(Composite parent) { |
| Font font = parent.getFont(); |
| // Create the main composite for the other controls |
| Composite composite = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| composite.setLayout(layout); |
| composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // Composite for category label and list... |
| Composite catComposite = new Composite(composite, SWT.NONE); |
| catComposite.setLayout(new GridLayout()); |
| catComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // Add a label to identify the list viewer of categories |
| Label categoryLabel = new Label(catComposite, SWT.LEFT); |
| categoryLabel.setText(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_categories); |
| GridData data = new GridData(); |
| data.verticalAlignment = SWT.TOP; |
| categoryLabel.setLayoutData(data); |
| categoryLabel.setFont(font); |
| |
| // List viewer of all available categories |
| ListViewer listViewer = new ListViewer(catComposite); |
| listViewer.getList().setLayoutData(new GridData(GridData.FILL_BOTH)); |
| listViewer.getList().setFont(font); |
| listViewer.setLabelProvider(new WorkbenchLabelProvider()); |
| listViewer.setContentProvider(getContentProvider()); |
| listViewer.setInput(getAvailableCategories()); |
| |
| // Composite for capability label and table... |
| Composite capComposite = new Composite(composite, SWT.NONE); |
| capComposite.setLayout(new GridLayout()); |
| capComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // Add a label to identify the checkbox tree viewer of capabilities |
| Label capabilityLabel = new Label(capComposite, SWT.LEFT); |
| capabilityLabel.setText(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_capabilities); |
| data = new GridData(); |
| data.verticalAlignment = SWT.TOP; |
| capabilityLabel.setLayoutData(data); |
| capabilityLabel.setFont(font); |
| |
| // Checkbox tree viewer of capabilities in selected categories |
| checkboxViewer = CheckboxTableViewer.newCheckList(capComposite, |
| SWT.SINGLE | SWT.TOP | SWT.BORDER); |
| checkboxViewer.getTable().setLayoutData( |
| new GridData(GridData.FILL_BOTH)); |
| checkboxViewer.getTable().setFont(font); |
| checkboxViewer.setLabelProvider(new CapabilityLabelProvider()); |
| checkboxViewer.setContentProvider(getContentProvider()); |
| checkboxViewer.setInput(visibleCapabilities); |
| |
| // Add a label to identify the text field of capability's description |
| Label descLabel = new Label(composite, SWT.LEFT); |
| descLabel.setText(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_description); |
| data = new GridData(); |
| data.verticalAlignment = SWT.TOP; |
| data.horizontalSpan = 2; |
| descLabel.setLayoutData(data); |
| descLabel.setFont(font); |
| |
| // Text field to display the capability's description |
| descriptionText = new Text(composite, SWT.WRAP | SWT.MULTI |
| | SWT.V_SCROLL | SWT.BORDER); |
| descriptionText.setText(EMPTY_DESCRIPTION); |
| descriptionText.setEditable(false); |
| data = new GridData(); |
| data.horizontalAlignment = GridData.FILL; |
| data.grabExcessHorizontalSpace = true; |
| data.horizontalSpan = 2; |
| descriptionText.setLayoutData(data); |
| descriptionText.setFont(font); |
| |
| // Add a text field to explain grayed out items |
| Label grayLabel = new Label(composite, SWT.LEFT); |
| grayLabel.setText(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_grayItems); |
| data = new GridData(); |
| data.verticalAlignment = SWT.TOP; |
| data.horizontalSpan = 2; |
| grayLabel.setLayoutData(data); |
| grayLabel.setFont(font); |
| |
| // Setup initial context |
| populateDependents(); |
| populateMemberships(); |
| |
| // Listen for selection changes to update the description field |
| checkboxViewer |
| .addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| updateDescription(event.getSelection()); |
| } |
| }); |
| |
| // Properly handle user checking and unchecking project features |
| checkboxViewer.addCheckStateListener(new ICheckStateListener() { |
| public void checkStateChanged(CheckStateChangedEvent event) { |
| Capability cap = (Capability) event.getElement(); |
| if (event.getChecked()) |
| handleCapabilityChecked(cap); |
| else |
| handleCapabilityUnchecked(cap); |
| checkboxViewer.setSelection(new StructuredSelection(cap)); |
| } |
| }); |
| |
| // Listen for category selection and update the list of capabilities |
| listViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| if (event.getSelection() instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection) event |
| .getSelection(); |
| visibleCapabilities.clear(); |
| Iterator itr = sel.iterator(); |
| while (itr.hasNext()) { |
| Category cat = (Category) itr.next(); |
| visibleCapabilities.addAll(cat.getElements()); |
| } |
| Collections.sort(visibleCapabilities, capabilityComparator); |
| checkboxViewer.refresh(); |
| itr = visibleCapabilities.iterator(); |
| while (itr.hasNext()) { |
| Capability cap = (Capability) itr.next(); |
| if (hasDependency(cap)) |
| checkboxViewer.setGrayed(cap, true); |
| if (checkedCapabilities.contains(cap)) |
| checkboxViewer.setChecked(cap, true); |
| } |
| updateDescription(checkboxViewer.getSelection()); |
| } |
| } |
| }); |
| |
| // initialize |
| if (initialCapabilities != null) |
| checkedCapabilities.addAll(Arrays.asList(initialCapabilities)); |
| if (initialCategories != null) |
| listViewer.setSelection(new StructuredSelection(initialCategories)); |
| |
| return composite; |
| } |
| |
| /** |
| * Marks the capability as being checked. |
| */ |
| private void markCapabilityChecked(Capability target, Capability dependent) { |
| // Check the target capability |
| if (!checkedCapabilities.contains(target)) |
| checkedCapabilities.add(target); |
| checkboxViewer.setChecked(target, true); |
| |
| // Gray the target to show the user its required |
| // by another capability. |
| if (target != dependent) |
| checkboxViewer.setGrayed(target, true); |
| |
| // Update the dependent map for the target capability |
| addDependency(target, dependent); |
| |
| // Update the membership set for the target capability |
| String[] ids = registry.getMembershipSetIds(target); |
| for (int j = 0; j < ids.length; j++) |
| memberships.put(ids[j], target); |
| } |
| |
| /** |
| * Marks the capability as being unchecked. |
| */ |
| private void markCapabilityUnchecked(Capability target) { |
| // Uncheck the target capability |
| checkedCapabilities.remove(target); |
| checkboxViewer.setChecked(target, false); |
| |
| // Ungray the target as there is no dependency on it |
| checkboxViewer.setGrayed(target, false); |
| |
| // Remove the dependency entry |
| dependents.remove(target); |
| |
| // Update the membership set for the target capability |
| String[] ids = registry.getMembershipSetIds(target); |
| for (int j = 0; j < ids.length; j++) { |
| if (memberships.get(ids[j]) == target) |
| memberships.remove(ids[j]); |
| } |
| } |
| |
| /** |
| * Returns the list of categories that have capabilities |
| * registered against it. |
| */ |
| private ArrayList getAvailableCategories() { |
| ArrayList results = registry.getUsedCategories(); |
| Collections.sort(results, categoryComparator); |
| if (registry.getMiscCategory() != null) |
| results.add(registry.getMiscCategory()); |
| return results; |
| } |
| |
| /** |
| * Return <code>true</code> if the user may have made changes |
| * to the capabilities of the project. Otherwise <code>false</code> |
| * if no changes were made. |
| * |
| * @return <code>true</true> when possible changes may have been made, |
| * <code>false</code> otherwise |
| */ |
| public boolean getCapabilitiesModified() { |
| return modified; |
| } |
| |
| /** |
| * Returns the content provider for the viewers |
| */ |
| private IContentProvider getContentProvider() { |
| return new WorkbenchContentProvider() { |
| public Object[] getChildren(Object parentElement) { |
| if (parentElement instanceof ArrayList) |
| return ((ArrayList) parentElement).toArray(); |
| else |
| return null; |
| } |
| }; |
| } |
| |
| /** |
| * The user has changed the project capability selection. |
| * Set the modified flag and clear the caches. |
| */ |
| private void capabilitiesModified() { |
| modified = true; |
| } |
| |
| /** |
| * Add a dependency between the target and dependent |
| * capabilities |
| */ |
| private void addDependency(Capability target, Capability dependent) { |
| ArrayList descriptors = (ArrayList) dependents.get(target); |
| if (descriptors == null) { |
| descriptors = new ArrayList(); |
| descriptors.add(dependent); |
| dependents.put(target, descriptors); |
| } else if (!descriptors.contains(dependent)) { |
| descriptors.add(dependent); |
| } |
| } |
| |
| /** |
| * Returns true if the capability has any |
| * dependencies on it. |
| */ |
| private boolean hasDependency(Capability capability) { |
| ArrayList descriptors = (ArrayList) dependents.get(capability); |
| if (descriptors == null) |
| return false; |
| if (descriptors.size() == 1 && descriptors.get(0) == capability) |
| return false; |
| return true; |
| } |
| |
| /** |
| * Returns whether the category is considered disabled |
| */ |
| private boolean isDisabledCapability(Capability cap) { |
| if (disabledCaps == null) { |
| if (disabledCapabilities == null) |
| disabledCaps = new ArrayList(0); |
| else |
| disabledCaps = Arrays.asList(disabledCapabilities); |
| } |
| return disabledCaps.contains(cap); |
| } |
| |
| /** |
| * Populate the dependents map based on the |
| * current set of capabilities. |
| */ |
| private void populateDependents() { |
| if (initialCapabilities == null) |
| return; |
| |
| LinkedList capabilities = new LinkedList(); |
| capabilities.addAll(Arrays.asList(initialCapabilities)); |
| |
| while (!capabilities.isEmpty()) { |
| // Retrieve the target capability |
| Capability target; |
| target = (Capability) capabilities.removeFirst(); |
| // Add the capability as a dependent of itself. |
| // It will indicate to the uncheck handler to not uncheck this |
| // capability automatically even if a another capability which |
| // depended on it is unchecked. |
| addDependency(target, target); |
| |
| if (registry.hasPrerequisites(target)) { |
| // Retrieve the prerequisite capabilities... |
| String[] prereqIds = registry.getPrerequisiteIds(target); |
| Capability[] prereqCapabilities; |
| prereqCapabilities = registry.findCapabilities(prereqIds); |
| // For each prerequisite capability... |
| for (int i = 0; i < prereqCapabilities.length; i++) { |
| // Update the dependent map for the prerequisite capability |
| addDependency(prereqCapabilities[i], target); |
| // Recursive if prerequisite capability also has prerequisites |
| if (registry.hasPrerequisites(prereqCapabilities[i])) |
| capabilities.addLast(prereqCapabilities[i]); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Populate the memberships map based on the |
| * current set of capabilities. |
| */ |
| private void populateMemberships() { |
| if (initialCapabilities == null) |
| return; |
| |
| Iterator itr = (Arrays.asList(initialCapabilities)).iterator(); |
| while (itr.hasNext()) { |
| Capability cap = (Capability) itr.next(); |
| String[] ids = registry.getMembershipSetIds(cap); |
| for (int j = 0; j < ids.length; j++) { |
| memberships.put(ids[j], cap); |
| } |
| } |
| } |
| |
| /** |
| * Handle the case of a capability being checked |
| * by ensuring the action is allowed and the prerequisite |
| * capabilities are also checked. |
| */ |
| private void handleCapabilityChecked(Capability capability) { |
| // Cannot allow a disabled capability to be checked |
| if (isDisabledCapability(capability)) { |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_disabledCapability, capability.getName())); |
| checkboxViewer.setChecked(capability, false); |
| return; |
| } |
| |
| // Cannot allow an invalid capability to be checked |
| if (!capability.isValid()) { |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_invalidCapability, capability.getName())); |
| checkboxViewer.setChecked(capability, false); |
| return; |
| } |
| |
| // Is there a membership set problem... |
| String[] ids = registry.getMembershipSetIds(capability); |
| for (int i = 0; i < ids.length; i++) { |
| Capability member = (Capability) memberships.get(ids[i]); |
| if (member != null && member != capability) { |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_membershipConflict, capability.getName(), member.getName())); |
| checkboxViewer.setChecked(capability, false); |
| return; |
| } |
| } |
| |
| // Handle prerequisite by auto-checking them if possible |
| if (registry.hasPrerequisites(capability)) { |
| // Check for any prerequisite problems... |
| // Retrieve all the prerequisite capabilities, including |
| // any prerequisite of the prerequisites! |
| LinkedList capabilities = new LinkedList(); |
| capabilities.addLast(capability); |
| while (!capabilities.isEmpty()) { |
| Capability target; |
| target = (Capability) capabilities.removeFirst(); |
| // Retrieve the capability's immediate prerequisites |
| String[] prereqIds = registry.getPrerequisiteIds(target); |
| Capability[] prereqCapabilities; |
| prereqCapabilities = registry.findCapabilities(prereqIds); |
| for (int i = 0; i < prereqCapabilities.length; i++) { |
| // If the prerequisite is missing, warn the user and |
| // do not allow the check to proceed. |
| if (prereqCapabilities[i] == null |
| || isDisabledCapability(prereqCapabilities[i]) |
| || !prereqCapabilities[i].isValid()) { |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_missingPrereqs, capability.getName(), prereqIds[i])); |
| checkboxViewer.setChecked(capability, false); |
| return; |
| } |
| // If there is a membership problem, warn the user and |
| // do not allow the check to proceed |
| ids = registry.getMembershipSetIds(prereqCapabilities[i]); |
| for (int j = 0; j < ids.length; j++) { |
| Capability member = (Capability) memberships |
| .get(ids[j]); |
| if (member != null && member != prereqCapabilities[i]) { |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl() |
| .getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_membershipPrereqConflict, new Object[] {capability.getName(), prereqCapabilities[i].getName(), member.getName()})); |
| checkboxViewer.setChecked(capability, false); |
| return; |
| } |
| } |
| // If the prerequisite capability has prerequisites |
| // also, then add it to be processed. |
| if (registry.hasPrerequisites(prereqCapabilities[i])) |
| capabilities.addLast(prereqCapabilities[i]); |
| } |
| } |
| |
| // Auto-check all prerequisite capabilities |
| capabilities = new LinkedList(); |
| capabilities.addLast(capability); |
| // For each capability that has prerequisites... |
| while (!capabilities.isEmpty()) { |
| Capability target; |
| target = (Capability) capabilities.removeFirst(); |
| // Retrieve the prerequisite capabilities... |
| String[] prereqIds = registry.getPrerequisiteIds(target); |
| Capability[] prereqCapabilities; |
| prereqCapabilities = registry.findCapabilities(prereqIds); |
| // For each prerequisite capability... |
| for (int i = 0; i < prereqCapabilities.length; i++) { |
| // Mark it as being checked |
| markCapabilityChecked(prereqCapabilities[i], target); |
| // Recursive if prerequisite capability also has prerequisites |
| if (registry.hasPrerequisites(prereqCapabilities[i])) |
| capabilities.addLast(prereqCapabilities[i]); |
| } |
| } |
| } |
| |
| // Mark the capability as checked. Adds itself as a |
| // dependent - this will indicate to the uncheck handler |
| // to not uncheck this capability automatically even if |
| // another capability which depends on it is unchecked. |
| markCapabilityChecked(capability, capability); |
| |
| // Notify those interested |
| capabilitiesModified(); |
| notifyCheckStateListner(); |
| } |
| |
| /** |
| * Handle the case of a capability being unchecked |
| * by ensuring the action is allowed. |
| */ |
| private void handleCapabilityUnchecked(Capability capability) { |
| ArrayList descriptors = (ArrayList) dependents.get(capability); |
| |
| // Note, there is no need to handle the case where descriptors size |
| // is zero because it cannot happen. For this method to be called, the |
| // item must have been checked previously. If it was checked by the user, |
| // then the item itself would be a dependent. If the item was checked |
| // because it was required by another capability, then that other capability |
| // would be a dependent. |
| |
| if (descriptors.size() == 1 && descriptors.get(0) == capability) { |
| // If the only dependent is itself, then its ok to uncheck |
| capabilitiesModified(); |
| markCapabilityUnchecked(capability); |
| |
| // Remove this capability as a dependent on its prerequisite |
| // capabilities. Recursive if a prerequisite capability |
| // no longer has any dependents. |
| if (registry.hasPrerequisites(capability)) { |
| LinkedList capabilities = new LinkedList(); |
| capabilities.addLast(capability); |
| // For each capability that has prerequisite capabilities |
| while (!capabilities.isEmpty()) { |
| Capability target; |
| target = (Capability) capabilities.removeFirst(); |
| // Retrieve the prerequisite capabilities... |
| String[] prereqIds = registry.getPrerequisiteIds(target); |
| Capability[] prereqCapabilities; |
| prereqCapabilities = registry.findCapabilities(prereqIds); |
| // For each prerequisite capability... |
| for (int i = 0; i < prereqCapabilities.length; i++) { |
| // Retrieve the list of dependents on the prerequisite capability... |
| Capability prereqCap = prereqCapabilities[i]; |
| ArrayList prereqDependents = (ArrayList) dependents |
| .get(prereqCap); |
| // Remove the dependent target capability... |
| prereqDependents.remove(target); |
| if (prereqDependents.isEmpty()) { |
| // Unchecked the prerequisite capability |
| markCapabilityUnchecked(prereqCap); |
| // Recursive if prerequisite capability also has |
| // prerequisite capabilities |
| if (registry.hasPrerequisites(prereqCap)) |
| capabilities.addLast(prereqCap); |
| } else if (prereqDependents.size() == 1 |
| && prereqDependents.get(0) == prereqCap) { |
| // Only dependent is itself so ungray the item to let the |
| // user know no other capability is dependent on it |
| checkboxViewer.setGrayed(prereqCap, false); |
| } |
| } |
| } |
| } |
| |
| // Notify those interested |
| notifyCheckStateListner(); |
| } else { |
| // At least one other capability depends on it being checked |
| // so force it to remain checked and warn the user. |
| checkboxViewer.setChecked(capability, true); |
| // Get a copy and remove the target capability |
| ArrayList descCopy = (ArrayList) descriptors.clone(); |
| descCopy.remove(capability); |
| // Show the prereq problem to the user |
| if (descCopy.size() == 1) { |
| Capability cap = (Capability) descCopy.get(0); |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_requiredPrereq, capability.getName(), cap.getName())); |
| } else { |
| StringBuffer msg = new StringBuffer(); |
| Iterator itr = descCopy.iterator(); |
| while (itr.hasNext()) { |
| Capability cap = (Capability) itr.next(); |
| msg.append("\n "); //$NON-NLS-1$ |
| msg.append(cap.getName()); |
| } |
| MessageDialog |
| .openWarning( |
| checkboxViewer.getControl().getShell(), |
| IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_errorTitle, |
| NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_requiredPrereqs, capability.getName(), msg)); |
| } |
| } |
| } |
| |
| /** |
| * Returns the collection of capabilities selected |
| * by the user. The collection is not in prerequisite |
| * order. |
| * |
| * @return array of selected capabilities |
| */ |
| public Capability[] getSelectedCapabilities() { |
| Capability[] capabilities = new Capability[checkedCapabilities.size()]; |
| checkedCapabilities.toArray(capabilities); |
| return capabilities; |
| } |
| |
| /** |
| * Return the current listener interested when the check |
| * state of a capability actually changes. |
| * |
| * @return Returns a ICheckStateListener |
| */ |
| public ICheckStateListener getCheckStateListener() { |
| return checkStateListener; |
| } |
| |
| /** |
| * Set the current listener interested when the check |
| * state of a capability actually changes. |
| * |
| * @param checkStateListener The checkStateListener to set |
| */ |
| public void setCheckStateListener(ICheckStateListener checkStateListener) { |
| this.checkStateListener = checkStateListener; |
| } |
| |
| /** |
| * Notify the check state listener that a capability |
| * check state has changed. The event past will |
| * always be <code>null</code> as it could be |
| * triggered by code instead of user input. |
| */ |
| private void notifyCheckStateListner() { |
| if (checkStateListener != null) |
| checkStateListener.checkStateChanged(null); |
| } |
| |
| /** |
| * Updates the description field for the selected capability |
| */ |
| private void updateDescription(ISelection selection) { |
| String text = EMPTY_DESCRIPTION; |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| Capability cap = (Capability) sel.getFirstElement(); |
| if (cap != null) |
| text = cap.getDescription(); |
| } |
| descriptionText.setText(text); |
| } |
| |
| class CapabilityLabelProvider extends LabelProvider { |
| private Map imageTable; |
| |
| public void dispose() { |
| if (imageTable != null) { |
| Iterator itr = imageTable.values().iterator(); |
| while (itr.hasNext()) |
| ((Image) itr.next()).dispose(); |
| imageTable = null; |
| } |
| } |
| |
| public Image getImage(Object element) { |
| ImageDescriptor descriptor = ((Capability) element) |
| .getIconDescriptor(); |
| if (descriptor == null) |
| return null; |
| |
| //obtain the cached image corresponding to the descriptor |
| if (imageTable == null) { |
| imageTable = new Hashtable(40); |
| } |
| Image image = (Image) imageTable.get(descriptor); |
| if (image == null) { |
| image = descriptor.createImage(); |
| imageTable.put(descriptor, image); |
| } |
| return image; |
| } |
| |
| public String getText(Object element) { |
| Capability cap = (Capability) element; |
| String text = cap.getName(); |
| if (isDisabledCapability(cap)) |
| text = NLS.bind(IDEWorkbenchMessages.ProjectCapabilitySelectionGroup_disabledLabel, text ); |
| return text; |
| } |
| } |
| } |
| |
