| // IdentifiablePluginView.java |
| package org.eclipse.stem.ui.views; |
| |
| /******************************************************************************* |
| * Copyright (c) 2006, 2008 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 |
| *******************************************************************************/ |
| |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtensionRegistry; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.util.LocalSelectionTransfer; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.stem.core.Constants; |
| import org.eclipse.stem.core.common.DublinCore; |
| import org.eclipse.stem.core.common.Identifiable; |
| import org.eclipse.stem.data.geography.GeographicNames; |
| import org.eclipse.stem.jobs.execution.IExecutable; |
| import org.eclipse.stem.ui.Activator; |
| import org.eclipse.stem.ui.perspectives.Simulation; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.DragSourceEvent; |
| import org.eclipse.swt.dnd.DragSourceListener; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.MouseTrackAdapter; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| 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.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.part.ViewPart; |
| |
| /** |
| * This class represents an eclipse view of the {@link Identifiable} resources |
| * of a particular type that have been imported into eclipse as plug-ins. |
| * |
| * @see Identifiable |
| * @see GraphsView |
| * @see ModelsView |
| * @see ScenariosView |
| */ |
| public abstract class IdentifiablePluginView extends ViewPart { |
| |
| protected TreeViewer treeViewer; |
| |
| private DublinCoreToolTipHandler dcTTipHandler; |
| |
| /** |
| * This is the selection that is in effect at the start of a drag operation |
| */ |
| protected ISelection selection; |
| |
| /** |
| * This map keeps track of the {@link Identifiable} that we've deserialized |
| * so we don't need to do that more than once. |
| * |
| * @see #getIdentifiable(URI) |
| */ |
| protected Map<URI, Identifiable> deserializedIdentifiablesMap = new HashMap<URI, Identifiable>(); |
| |
| /** |
| * Constructor |
| */ |
| public IdentifiablePluginView() { |
| super(); |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| public void createPartControl(final Composite parent) { |
| dcTTipHandler = new DublinCoreToolTipHandler(parent.getShell()); |
| |
| treeViewer = new TreeViewer(parent); |
| treeViewer |
| .setContentProvider(new IdentifiablePluginViewTreeContentProvider()); |
| treeViewer |
| .setLabelProvider(getIdentifiablePluginViewLabelContentProvider()); |
| treeViewer.setUseHashlookup(true); |
| treeViewer.setInput(getInput()); |
| |
| // Hook up the dublin core tool tip handler |
| dcTTipHandler.addDCToolTipHelp(treeViewer.getTree()); |
| |
| // We become a selection provider too |
| getSite().setSelectionProvider(treeViewer); |
| |
| // Context Menu |
| final MenuManager contextMenuManager = new MenuManager(); |
| // Place Holder for Menu Additions |
| contextMenuManager.add(new Separator("execution")); |
| |
| // Set the context menu for the viewer |
| treeViewer.getControl().setMenu( |
| contextMenuManager.createContextMenu(treeViewer.getControl())); |
| getSite().registerContextMenu(contextMenuManager, treeViewer); |
| |
| // Listen for double-clicks on Executables |
| treeViewer.addDoubleClickListener(new IDoubleClickListener() { |
| public void doubleClick(final DoubleClickEvent event) { |
| final IExecutable executable = (IExecutable) Platform.getAdapterManager().getAdapter(((StructuredSelection) event.getSelection()).toList().get(0), IExecutable.class); |
| |
| // Were we successful in adapting? |
| if (executable != null) { |
| // Yes |
| executable.run(); |
| |
| // Only switch to the Simulation Persepctive when the executable is a standard |
| // run (scenario). For other executables we may want to stay in other special |
| // perspectives |
| if(executable instanceof Adapter) { |
| Adapter a = (Adapter) executable; |
| Object obj = a.getTarget(); |
| if( obj instanceof org.eclipse.stem.core.scenario.impl.ScenarioImpl ) { |
| Activator.switchToPerspective(Simulation.ID_STEM_SIMULATION_PERSPECTIVE); |
| } |
| } // if adapter (usually true) |
| |
| } // if |
| } // doubleClick |
| }); |
| |
| // Set up drag support |
| final int ops = DND.DROP_LINK | DND.DROP_COPY | DND.DROP_MOVE; |
| final Transfer[] transfers = new Transfer[] { |
| LocalSelectionTransfer.getTransfer(), |
| LocalTransfer.getInstance() }; |
| treeViewer.addDragSupport(ops, transfers, new DragSourceListener() { |
| |
| /** |
| * @see org.eclipse.swt.dnd.DragSourceListener#dragStart(org.eclipse.swt.dnd.DragSourceEvent) |
| */ |
| public void dragStart(final DragSourceEvent event) { |
| // We need to figure out when the drag can start here |
| // Just say "yes" right now |
| event.doit = true; |
| selection = treeViewer.getSelection(); |
| // LocalSelectionTransfer.getTransfer().setSelection(selection); |
| } // dragStart |
| |
| /** |
| * @see org.eclipse.swt.dnd.DragSourceListener#dragSetData(org.eclipse.swt.dnd.DragSourceEvent) |
| */ |
| public void dragSetData(final DragSourceEvent event) { |
| |
| if (LocalSelectionTransfer.getTransfer().isSupportedType( |
| event.dataType)) { |
| // Yes |
| event.data = extractURIStringsFromIdentifiableDelegates((IStructuredSelection) selection); |
| LocalSelectionTransfer.getTransfer().setSelection( |
| (IStructuredSelection) event.data); |
| } // if |
| else if (LocalTransfer.getInstance().isSupportedType( |
| event.dataType)) { |
| // Yes |
| event.data = extractURIStringsFromIdentifiableDelegates((IStructuredSelection) selection); |
| } // if |
| |
| } // dragSetData |
| |
| private IStructuredSelection extractURIStringsFromIdentifiableDelegates( |
| final IStructuredSelection selectedDelegates) { |
| final List<String> collection = new ArrayList<String>(); |
| for (final Iterator selectionIter = selectedDelegates |
| .iterator(); selectionIter.hasNext();) { |
| final Object element = selectionIter.next(); |
| // Was an Identifiable Delegate selected? |
| if (element instanceof IdentifiableDelegate) { |
| // Yes |
| // It has a URI that specifies the serialized |
| // representation of the Identifiable |
| final String uriString = ((IdentifiableDelegate) element) |
| .getDublinCore().getIdentifier(); |
| // Were we successful in getting the uri string? |
| if (uriString != null) { |
| // Yes |
| collection.add(uriString); |
| } |
| } // if |
| } // for each selection |
| |
| return new IStructuredSelection() { |
| |
| final List<String> list; |
| { |
| list = collection; |
| } |
| |
| public Object getFirstElement() { |
| return list.get(0); |
| } |
| |
| public Iterator<String> iterator() { |
| return list.iterator(); |
| } |
| |
| public int size() { |
| return list.size(); |
| } |
| |
| public Object[] toArray() { |
| return list.toArray(); |
| } |
| |
| public List<String> toList() { |
| return list; |
| } |
| |
| public boolean isEmpty() { |
| return list.isEmpty(); |
| } |
| }; |
| } // extractURIStrings |
| |
| /** |
| * @see org.eclipse.swt.dnd.DragSourceListener#dragFinished(org.eclipse.swt.dnd.DragSourceEvent) |
| */ |
| public void dragFinished( |
| @SuppressWarnings("unused") final DragSourceEvent event) { |
| selection = null; |
| LocalTransfer.getInstance().javaToNative(null, null); |
| } // dragFinished |
| |
| }); |
| } // createPartControl |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#setFocus() |
| */ |
| @Override |
| public void setFocus() { |
| // Nothing |
| } |
| |
| /** |
| * @return the input model specific to this view |
| */ |
| protected abstract IdentifiableViewModel getInput(); |
| |
| /** |
| * @return the {@link IdentifiablePluginViewLabelContentProvider} |
| * appropriate for the model |
| */ |
| protected abstract IdentifiablePluginViewLabelContentProvider getIdentifiablePluginViewLabelContentProvider(); |
| |
| /** |
| * This class represents the model of the {@link Identifiable}'s that extend |
| * a particular extension point. |
| */ |
| protected abstract static class IdentifiableViewModel { |
| // The root of the tree of categories and identifiables |
| private final Category root; |
| |
| // Mapping between a category id and a category |
| private final Map<String, Category> categoryMap; |
| |
| /** |
| * @param extensionPointID |
| * the identifier of the extension point that Identifiables |
| * use to plug-in. |
| */ |
| public IdentifiableViewModel(final String extensionPointID) { |
| root = new Category(Constants.IDENTIFIABLE_ROOT_CATEGORY_NAME, |
| Constants.IDENTIFIABLE_ROOT_CATEGORY_ID, ""); //$NON-NLS-1$ |
| categoryMap = new HashMap<String, Category>(); |
| categoryMap.put(root.getCategoryId(), root); |
| |
| // Get the configuration elements for this extension point |
| final IExtensionRegistry registry = Platform.getExtensionRegistry(); |
| final IConfigurationElement[] configElements = registry |
| .getConfigurationElementsFor(extensionPointID); |
| |
| // Make a first pass through the elements looking for categories |
| for (final IConfigurationElement element : configElements) { |
| // Is this a Category? |
| if (Constants.CATEGORY_ELEMENT.equals(element.getName())) { |
| // Yes |
| if(element.getAttribute(Constants.CATEGORY_NAME_ATTRIBUTE).startsWith("%")) |
| continue; // Skip untranslated categories |
| addCategory(element); |
| } |
| } // for each configuration element |
| |
| // Resolve the connections between parent and child categories |
| resolveCategories(); |
| |
| // Iterate through the elements. Processing the identifiables |
| for (final IConfigurationElement element : configElements) { |
| // Is this a Category? |
| if (Constants.CATEGORY_ELEMENT.equals(element.getName())) { |
| // Yes |
| continue; |
| } |
| // Is this a dublin core element? |
| else if (Constants.DUBLIN_CORE_ELEMENT |
| .equals(element.getName())) { |
| // Yes |
| // Was a category id specified in the element? |
| Category category = root; |
| final String categoryId = element |
| .getAttribute("category_id"); //$NON-NLS-1$ |
| if (categoryId != null) { |
| // Yes |
| category = categoryMap.get(categoryId); |
| // Did we find the category? |
| if (category == null) { |
| // No |
| Activator.logError(MessageFormat.format(Messages |
| .getString("IPView.No_Category"), //$NON-NLS-1$ |
| categoryId), null); |
| category = root; |
| } |
| |
| category = category == null ? root : category; |
| } |
| addIdentifiableDelegate(category, element); |
| } // if dublin core |
| // Is it an element with a "name" attribute? |
| else if (element.getAttribute("name") != null) { |
| // Yes |
| addIdentifiableDelegate(root, element); |
| } // if |
| else { |
| Activator.logError(MessageFormat.format(Messages |
| .getString("IPView.Unexpected_Element"), element |
| .getName(), extensionPointID), null); |
| } // else |
| } // for each configuration element |
| |
| } // IdentifiableViewModel |
| |
| /** |
| * Add an {@link IdentifiableDelegate} to the model. |
| * |
| * @param category |
| * the {@link Category} to add the delegate to |
| * |
| * @param element |
| * the {@link DublinCore} element that defines the delegate |
| */ |
| private void addIdentifiableDelegate(final Category category, |
| final IConfigurationElement element) { |
| final IdentifiableDelegate identifiableDelegate = new IdentifiableDelegate( |
| element); |
| category.addIdentifiableDelegate(identifiableDelegate); |
| } // addIdentifiableDelegate |
| |
| /** |
| * Add a {@link Category} to the model. |
| * |
| * @param element |
| * the category element that defines the category |
| */ |
| private Category addCategory(final IConfigurationElement element) { |
| final Category category = new Category(element); |
| // Does the category already exist? |
| Category retValue = categoryMap.get(category.getCategoryId()); |
| |
| if (retValue == null) { |
| // No |
| // It's new |
| retValue = category; |
| categoryMap.put(category.getCategoryId(), category); |
| } |
| |
| return retValue; |
| } // addCategory |
| |
| /** |
| * Hook up parent and child categories. |
| */ |
| private void resolveCategories() { |
| // Go through each of the categories hooking up parent with child |
| for (final Category category : categoryMap.values()) { |
| // Is this the root category? |
| if (category == root) { |
| // Yes |
| continue; |
| } |
| |
| // Does it's parent exist? |
| Category parentCategory = categoryMap.get(category |
| .getParentId()); |
| if (parentCategory == null) { |
| // No |
| Activator |
| .logInformation( |
| "When organizing categories, the specified parent category \"" //$NON-NLS-1$ |
| + category.getParentId() |
| + "\" for the category \"" //$NON-NLS-1$ |
| + category.getCategoryId() |
| + "\" could not be found. Using \"/\" instead.", //$NON-NLS-1$ |
| null); |
| parentCategory = root; |
| } // if parent exists |
| |
| category.setParent(parentCategory); |
| parentCategory.addChildCategory(category); |
| |
| } // for each category |
| } // resolveCategories |
| |
| /** |
| * @return the root |
| */ |
| protected final Category getRoot() { |
| return root; |
| } |
| |
| } // IdentifiableViewModel |
| |
| /** |
| * This class represents an element in the tree that is the model of the |
| * plugged in graphs. |
| */ |
| protected static class Category implements Comparable<Object> { |
| Category parent; |
| |
| String parentId; |
| |
| String categoryId; |
| |
| String categoryName; |
| |
| List<Category> childCategories; |
| |
| List<IdentifiableDelegate> childIdentifiables; |
| |
| protected Category(final String categoryName, final String categoryId, |
| final String parentId) { |
| this.categoryName = categoryName; |
| this.categoryId = categoryId; |
| this.parentId = parentId; |
| this.parent = null; |
| this.childCategories = new ArrayList<Category>(); |
| this.childIdentifiables = new ArrayList<IdentifiableDelegate>(); |
| } |
| |
| protected Category(final IConfigurationElement element) { |
| this(getNLSCatagoryName(element |
| .getAttribute(Constants.CATEGORY_NAME_ATTRIBUTE)), element |
| .getAttribute(Constants.CATEGORY_ID_ATTRIBUTE), element |
| .getAttribute(Constants.PARENT_ID_ATTRIBUTE)); |
| } |
| |
| /** |
| * @param category |
| * a child {@link Category} to add to this parent |
| */ |
| public void addChildCategory(final Category category) { |
| childCategories.add(category); |
| } |
| |
| /** |
| * @param identifiableDelegate |
| * the {@link IdentifiableDelegate} to add to the category |
| */ |
| public void addIdentifiableDelegate( |
| final IdentifiableDelegate identifiableDelegate) { |
| childIdentifiables.add(identifiableDelegate); |
| } |
| |
| /** |
| * @param attribute |
| * the value of {@link Constants#CATEGORY_NAME_ATTRIBUTE} |
| * @return the NLS'd version of the category name |
| */ |
| private static String getNLSCatagoryName(final String attribute) { |
| final String name = GeographicNames.getName(attribute); |
| return name.startsWith("!") ? attribute : name; |
| } // getNLSCatagoryName |
| |
| /** |
| * @return the categoryId of this {@link Category} |
| */ |
| protected final String getCategoryId() { |
| return categoryId; |
| } |
| |
| /** |
| * @return the parentId |
| */ |
| protected final String getParentId() { |
| return parentId; |
| } |
| |
| /** |
| * @return the parent |
| */ |
| protected final Category getParent() { |
| return parent; |
| } |
| |
| /** |
| * @param parent |
| * the parent to set |
| */ |
| protected final void setParent(final Category parent) { |
| this.parent = parent; |
| } |
| |
| /** |
| * @return the children of the {@link Category} |
| */ |
| public Object[] getChildren() { |
| final List<Object> kidList = new ArrayList<Object>(); |
| Collections.sort(childCategories); |
| Collections.sort(childIdentifiables); |
| kidList.addAll(childCategories); |
| kidList.addAll(childIdentifiables); |
| return kidList.toArray(); |
| } // getChildren |
| |
| /** |
| * @see java.lang.Object#toString() |
| */ |
| @Override |
| public String toString() { |
| final StringBuilder retValue = new StringBuilder(categoryName); |
| retValue.append(", "); //$NON-NLS-1$ |
| retValue.append(categoryId); |
| retValue.append(", "); //$NON-NLS-1$ |
| retValue.append(parentId); |
| return retValue.toString(); |
| } |
| |
| /** |
| * @see java.lang.Object#hashCode() |
| */ |
| @Override |
| public int hashCode() { |
| final int PRIME = 31; |
| int result = 1; |
| result = PRIME * result |
| + ((categoryId == null) ? 0 : categoryId.hashCode()); |
| return result; |
| } |
| |
| /** |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| @Override |
| public boolean equals(final Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (obj == null) { |
| return false; |
| } |
| if (getClass() != obj.getClass()) { |
| return false; |
| } |
| final Category other = (Category) obj; |
| if (categoryId == null) { |
| if (other.categoryId != null) { |
| return false; |
| } |
| } else if (!categoryId.equals(other.categoryId)) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * @param o |
| * @return the value of the compare |
| * @see java.lang.Comparable#compareTo(java.lang.Object) |
| */ |
| public int compareTo(final Object o) { |
| int retValue = 0; |
| if (o instanceof Category) { |
| // Yes |
| final Category category = (Category) o; |
| retValue = categoryName.compareTo(category.categoryName); |
| } // if Category |
| else if (o instanceof IdentifiableDelegate) { |
| // Yes |
| // In a tree listing that mixes categories and |
| // IdentifiableDelegates we want the categories to appear first, |
| // so we always return the same value. |
| retValue = 1; |
| } // if IdentifiableDelegate |
| return retValue; |
| } // compareTo |
| |
| } // Category |
| |
| /** |
| * This class provides content for the tree view of the {@link Identifiable} |
| * s that are available as parts of plug-ins. |
| */ |
| protected static class IdentifiablePluginViewTreeContentProvider implements |
| ITreeContentProvider { |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) |
| */ |
| public Object[] getChildren(final Object parentElement) { |
| Object[] retValue = null; |
| if (parentElement instanceof Category) { |
| final Category category = (Category) parentElement; |
| final List<Object> kidList = new ArrayList<Object>(); |
| Collections.sort(category.childCategories); |
| Collections.sort(category.childIdentifiables); |
| kidList.addAll(category.childCategories); |
| kidList.addAll(category.childIdentifiables); |
| retValue = kidList.toArray(); |
| } |
| return retValue; |
| } // getChildren |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) |
| */ |
| public Object getParent(final Object element) { |
| Object retValue = null; |
| if (element instanceof Category) { |
| retValue = ((Category) element).parent; |
| } else { |
| retValue = ((IdentifiableDelegate) element).getParent(); |
| } |
| return retValue; |
| } // getParent |
| |
| /** |
| * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) |
| */ |
| public boolean hasChildren(final Object element) { |
| boolean retValue = false; |
| if (element instanceof Category) { |
| final Category cagatory = (Category) element; |
| retValue = cagatory.childCategories.size() > 0 |
| || cagatory.childIdentifiables.size() > 0; |
| } |
| return retValue; |
| } // hasChildren |
| |
| /** |
| * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) |
| */ |
| public Object[] getElements(final Object inputElement) { |
| final IdentifiableViewModel model = (IdentifiableViewModel) inputElement; |
| // return new Object[] { model.getRoot() }; |
| Arrays.sort(model.getRoot().getChildren()); |
| return model.getRoot().getChildren(); |
| } // getElements |
| |
| /** |
| * @see org.eclipse.jface.viewers.IContentProvider#dispose() |
| */ |
| public void dispose() { |
| // Nothing to dispose |
| } // dispose |
| |
| /** |
| * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, |
| * java.lang.Object, java.lang.Object) |
| */ |
| public void inputChanged( |
| @SuppressWarnings("unused") final Viewer viewer, |
| @SuppressWarnings("unused") final Object oldInput, |
| @SuppressWarnings("unused") final Object newInput) { |
| // Nothing to do right now |
| } // inputChanged |
| |
| } // IdentifiablePluginViewTreeContentProvider |
| |
| /** |
| * This class provides labels the describe the {@link Identifiable}s |
| * available as part of plug-ins. |
| */ |
| protected static abstract class IdentifiablePluginViewLabelContentProvider |
| implements ILabelProvider { |
| |
| private static Image categoryIcon = null; |
| |
| // If true then we've never tried to get the icon |
| static boolean categoryIconFirstTime = true; |
| |
| private final List<ILabelProviderListener> listeners; |
| |
| /** |
| * Constructor |
| */ |
| public IdentifiablePluginViewLabelContentProvider() { |
| listeners = new ArrayList<ILabelProviderListener>(); |
| } // IdentifiablePluginViewLabelContentProvider |
| |
| /** |
| * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object) |
| */ |
| public Image getImage(final Object element) { |
| Image retValue = null; |
| if (element instanceof Category) { |
| retValue = getCategoryIcon(); |
| } |
| return retValue; |
| } // getImage |
| |
| /** |
| * @return the icon to be used to represent {@link Category}s, or |
| * <code>null</code> if it can't be loaded. |
| */ |
| protected Image getCategoryIcon() { |
| // Should we try to load the icon? |
| if (categoryIconFirstTime && categoryIcon == null) { |
| // Yes |
| categoryIconFirstTime = false; |
| categoryIcon = PlatformUI.getWorkbench().getSharedImages() |
| .getImage(ISharedImages.IMG_OBJ_FOLDER); |
| } // if we should load the icon |
| return categoryIcon; |
| } // getCategoryIcon |
| |
| /** |
| * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object) |
| */ |
| public String getText(final Object element) { |
| String retValue = ""; //$NON-NLS-1$ |
| if (element instanceof Category) { |
| final Category category = (Category) element; |
| retValue = category.categoryName; |
| } else if (element instanceof IdentifiableDelegate) { |
| final IdentifiableDelegate identifiableDelegate = (IdentifiableDelegate) element; |
| retValue = identifiableDelegate.toString(); |
| } |
| return retValue; |
| } // getText |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener) |
| */ |
| public void addListener(final ILabelProviderListener listener) { |
| listeners.add(listener); |
| } // addListener |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose() |
| */ |
| public void dispose() { |
| // Nothing to do. The images are disposed of elsewhere, |
| } // dispose |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, |
| * java.lang.String) |
| */ |
| public boolean isLabelProperty( |
| @SuppressWarnings("unused") final Object element, |
| @SuppressWarnings("unused") final String property) { |
| return false; |
| } // isLabelProperty |
| |
| /** |
| * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener) |
| */ |
| public void removeListener(final ILabelProviderListener listener) { |
| listeners.remove(listener); |
| } // removeListener |
| |
| } // IdentifiablePluginViewLabelContentProvider |
| |
| /** |
| * This class displays the {@link DublinCore} metadata of |
| * {@link Identifiable}s when the mouse hovers over it. |
| */ |
| private static class DublinCoreToolTipHandler { |
| // This is the number of pixels below the current mouse position at |
| // which to position the dublin core |
| protected static final int Y_OFFSET = 16; |
| |
| protected Shell dcTipShell; |
| |
| Label dcDescriptionText; |
| |
| Label dcCreatorText; |
| |
| Label dcValidText; |
| |
| Label dcSourceText; |
| |
| DublinCoreToolTipHandler(final Shell parent) { |
| final Display display = parent.getDisplay(); |
| |
| dcTipShell = new Shell(parent, SWT.ON_TOP | SWT.TOOL); |
| final GridLayout gridLayout = new GridLayout(); |
| gridLayout.numColumns = 1; |
| dcTipShell.setLayout(gridLayout); |
| |
| final Color backgroundColor = display |
| .getSystemColor(SWT.COLOR_INFO_BACKGROUND); |
| final Color foregroundColor = display |
| .getSystemColor(SWT.COLOR_INFO_FOREGROUND); |
| |
| dcTipShell.setBackground(backgroundColor); |
| |
| dcDescriptionText = createDCAttributeLabel(dcTipShell, |
| backgroundColor, foregroundColor); |
| |
| dcCreatorText = createDCAttributeLabel(dcTipShell, backgroundColor, |
| foregroundColor); |
| |
| dcValidText = createDCAttributeLabel(dcTipShell, backgroundColor, |
| foregroundColor); |
| dcSourceText = createDCAttributeLabel(dcTipShell, backgroundColor, |
| foregroundColor); |
| |
| dcTipShell.pack(); |
| } // DublinCoreToolTipHandler |
| |
| private Label createDCAttributeLabel(final Shell parent, |
| final Color backgroundColor, final Color foregroundColor) { |
| final Label retValue = new Label(parent, SWT.NONE); |
| retValue.setBackground(backgroundColor); |
| retValue.setForeground(foregroundColor); |
| retValue.setLayoutData(new GridData(GridData.FILL_HORIZONTAL |
| | GridData.VERTICAL_ALIGN_CENTER)); |
| return retValue; |
| } // createDCAttributeLabel |
| |
| /** |
| * Add the necessary listeners to the {@link Control} to catch the mouse |
| * events and pop the tool tip up. |
| * |
| * @param control |
| */ |
| public void addDCToolTipHelp(final Control control) { |
| // If the user clicks with the mouse we want to get rid of the |
| // dublin core |
| control.addMouseListener(new MouseAdapter() { |
| |
| /** |
| * @see org.eclipse.swt.events.MouseAdapter#mouseDown(org.eclipse.swt.events.MouseEvent) |
| */ |
| @Override |
| public void mouseDown( |
| @SuppressWarnings("unused") final MouseEvent e) { |
| // Is the dublin core visible? |
| if (dcTipShell.isVisible()) { |
| // Yes |
| // Not any more |
| dcTipShell.setVisible(false); |
| } // if visible |
| } // mouseDown |
| |
| }); |
| |
| // If the mouse hovers we want to pop up the dublin core, but if it |
| // exits we want to get right of it. |
| control.addMouseTrackListener(new MouseTrackAdapter() { |
| |
| /** |
| * @see org.eclipse.swt.events.MouseTrackAdapter#mouseHover(org.eclipse.swt.events.MouseEvent) |
| */ |
| @Override |
| public void mouseHover(final MouseEvent e) { |
| final Point pt = new Point(e.x, e.y); |
| // Is the event's Widget a Tree (it should be)? |
| if (e.widget instanceof Tree) { |
| // Yes |
| final Tree tree = (Tree) e.widget; |
| final TreeItem treeItem = tree.getItem(pt); |
| // Are we over anything? |
| if (treeItem != null) { |
| // Yes |
| final Object obj = treeItem.getData(); |
| |
| // Does it have DC meta data? |
| if (obj instanceof IdentifiableDelegate) { |
| // Yes |
| final IdentifiableDelegate id = (IdentifiableDelegate) obj; |
| final DublinCore dc = id.getDublinCore(); |
| |
| final String description = dc.getDescription(); |
| final String creator = dc.getCreator(); |
| final String valid = dc.getValid(); |
| final String source = dc.getSource(); |
| |
| // Is there a description? |
| if (description != null |
| && !description.equals("")) { |
| // Yes |
| dcDescriptionText.setText(description); |
| dcDescriptionText.setVisible(true); |
| } // if |
| else { |
| // No |
| dcDescriptionText.setVisible(false); |
| } |
| |
| // Is there a creator? |
| if (creator != null && !creator.equals("")) { |
| // Yes |
| dcCreatorText.setText(creator); |
| dcCreatorText.setVisible(true); |
| } // if |
| else { |
| // No |
| dcCreatorText.setVisible(false); |
| } |
| // Is there a valid range? |
| if (valid != null && !valid.equals("")) { |
| // Yes |
| dcValidText.setText(valid); |
| dcValidText.setVisible(true); |
| } // if |
| else { |
| // No |
| dcValidText.setVisible(false); |
| } |
| |
| // Is there a source? |
| if (source != null && !source.equals("")) { |
| // Yes |
| dcSourceText.setText(source); |
| dcSourceText.setVisible(true); |
| } // if |
| else { |
| // No |
| dcSourceText.setVisible(false); |
| } |
| |
| dcTipShell.pack(); |
| |
| // Now we need to figure out where to position |
| // the shell containing the dublin core tool tip |
| // given the size of the tool tip and the bounds |
| // of the Display. |
| dcTipShell.setBounds(computeHoverLocation( |
| dcTipShell, control.toDisplay(pt))); |
| |
| // Make the Dublin Core tool tip visible |
| dcTipShell.setVisible(true); |
| } // if IConfigurationElement |
| |
| else { |
| // No |
| dcTipShell.setVisible(false); |
| } |
| } // if display DC |
| else { |
| // No |
| dcTipShell.setVisible(false); |
| } |
| |
| } // if Tree |
| |
| } // mouseHover |
| |
| /** |
| * Figure out where to position the tool tip |
| * |
| * @param dcTipShell |
| * the {@link Shell} that contains the dublin core |
| * @param mousePosition |
| * the current position of the Mouse relative to the |
| * Display |
| */ |
| private Rectangle computeHoverLocation(final Shell dcTipShell, |
| final Point mousePosition) { |
| // Get the current bounds of the toolTip |
| final Rectangle retValue = dcTipShell.getBounds(); |
| |
| final Rectangle displayBounds = dcTipShell.getDisplay() |
| .getBounds(); |
| // The x position is either the current mouse position if |
| // the dublin core can be displayed entirely to the right of |
| // that, or a value to the left of that that allows it to be |
| // displayed, with 0 being the limit. |
| retValue.x = Math.max(Math.min(mousePosition.x, |
| displayBounds.width - retValue.width), 0); |
| |
| // The y position is Y_OFFSET pixels below the current mouse |
| // position, or if the entire dublin core won't fit in the |
| // window at that position, then the lowest position above |
| // that where it can, with 0 (the top of the Display) being |
| // the limit |
| retValue.y = Math.max(Math.min(mousePosition.y + Y_OFFSET, |
| displayBounds.height - retValue.height), 0); |
| |
| return retValue; |
| } // computeHoverLocation |
| |
| /** |
| * @see org.eclipse.swt.events.MouseTrackAdapter#mouseExit(org.eclipse.swt.events.MouseEvent) |
| */ |
| @Override |
| public void mouseExit( |
| @SuppressWarnings("unused") final MouseEvent e) { |
| // Is the dublin core visible? |
| if (dcTipShell.isVisible()) { |
| // Yes |
| // Not any more |
| dcTipShell.setVisible(false); |
| } // if visible |
| } // mouseExit |
| }); |
| } // addDCToolTipHelp |
| } // DublinCoreToolTipHandler |
| } // IdentifiablePluginView |
