| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2007 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 implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.authoring.ui.views; |
| |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.command.BasicCommandStack; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.IdentityCommand; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.IDisposable; |
| import org.eclipse.emf.edit.ui.action.CopyAction; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.epf.authoring.ui.AuthoringUIExtensionManager; |
| import org.eclipse.epf.authoring.ui.AuthoringUIHelpContexts; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.PerspectiveListUtil; |
| import org.eclipse.epf.authoring.ui.UIActionDispatcher; |
| import org.eclipse.epf.authoring.ui.actions.ConfigurationViewEditAction; |
| import org.eclipse.epf.authoring.ui.actions.ILibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.IMenuAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewCopyAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewFindElementAction; |
| import org.eclipse.epf.authoring.ui.dnd.LibraryViewerDragAdapter; |
| import org.eclipse.epf.authoring.ui.providers.ConfigurationDecoratingLabelProvider; |
| import org.eclipse.epf.authoring.ui.providers.IContentProviderFactory; |
| import org.eclipse.epf.common.ui.util.ClipboardUtil; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.library.ILibraryManager; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.LibraryServiceUtil; |
| import org.eclipse.epf.library.configuration.ConfigurationHelper; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.util.ExtensionManager; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.events.ILibraryChangeListener; |
| import org.eclipse.epf.library.ui.LibraryUIManager; |
| import org.eclipse.epf.library.ui.actions.ConfigurationContributionItem; |
| import org.eclipse.epf.library.util.ResourceHelper; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ActionContributionItem; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IBaseLabelProvider; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.HTMLTransfer; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| 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.ui.IActionBars; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionFactory; |
| |
| /** |
| * Displays the content of the current method configuration. |
| * <p> |
| * The current configuration is set via the Configuration combobox in the system |
| * toolbar. |
| * |
| * @author Jinhua Xi |
| * @author Phong Nguyen Le |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class ConfigurationView extends AbstractBaseView implements |
| ILibraryChangeListener { |
| |
| /** |
| * The view ID. |
| */ |
| public static final String VIEW_ID = ConfigurationView.class.getName(); |
| |
| private String configName; |
| |
| private TreeViewer treeViewer; |
| |
| private IDoubleClickListener doubleClickListener; |
| |
| private IFilter configFilter; |
| |
| private List<Action> menuActionProviders; |
| |
| |
| /** |
| * Creates a new instance. |
| */ |
| public ConfigurationView() { |
| extender = AuthoringUIExtensionManager.getInstance().createConfigurationViewExtender(this); |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.ViewPart#init(IViewSite) |
| */ |
| public void init(IViewSite site) throws PartInitException { |
| super.init(site); |
| createActions(site); |
| LibraryUIManager.getInstance(); |
| } |
| |
| private IAction collapseViewAction; |
| public IAction getCollapseViewAction() { |
| if (collapseViewAction == null) { |
| collapseViewAction = new Action() { |
| public void run() { |
| PlatformUI.getWorkbench().getDisplay().syncExec( |
| new Runnable() { |
| public void run() { |
| if (getViewer() instanceof TreeViewer) { |
| ((TreeViewer) getViewer()) |
| .collapseAll(); |
| } |
| } |
| }); |
| } |
| }; |
| } |
| return collapseViewAction; |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, |
| AuthoringUIHelpContexts.CONFIGURATION_VIEW_CONTEXT); |
| |
| // editingDomain = new AdapterFactoryEditingDomain(adapterFactory, |
| // new BasicCommandStack()); |
| editingDomain = newEditingDomain(); |
| |
| adapterFactory = (ComposedAdapterFactory) editingDomain |
| .getAdapterFactory(); |
| |
| // Open the current configuration. |
| setConfiguration(null); |
| |
| loadMenuActionProviders(); |
| IToolBarManager mgr= getViewSite().getActionBars().getToolBarManager(); |
| |
| for (int i = 0; i < menuActionProviders.size(); i++) { |
| try { |
| Object actionProvider = menuActionProviders.get(i); |
| if (actionProvider instanceof Action) { |
| mgr.add((Action)actionProvider); |
| if (actionProvider instanceof IMenuAction) |
| ((IMenuAction) actionProvider).init(this); |
| } |
| |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| } |
| |
| protected AdapterFactoryEditingDomain newEditingDomain() { |
| return new AdapterFactoryEditingDomain(adapterFactory, |
| new BasicCommandStack()); |
| } |
| |
| /** |
| * Get all menu providers |
| * @return |
| */ |
| private List<Action> loadMenuActionProviders() { |
| if (menuActionProviders == null) { |
| menuActionProviders = ExtensionManager.getExtensions(AuthoringUIPlugin.getDefault().getId(), "configurationViewMenuProvider", Action.class); //$NON-NLS-1$ |
| } |
| return menuActionProviders; |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#libraryCreated(MethodLibrary) |
| */ |
| public void libraryCreated(MethodLibrary library) { |
| } |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#libraryOpened(MethodLibrary) |
| */ |
| public void libraryOpened(MethodLibrary library) { |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#libraryClosed(MethodLibrary) |
| */ |
| public void libraryClosed(MethodLibrary library) { |
| setInputForViewer(null); |
| if (adapterFactory instanceof ComposedAdapterFactory) { |
| ((ComposedAdapterFactory) adapterFactory).dispose(); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#librarySet(MethodLibrary) |
| */ |
| public void librarySet(MethodLibrary library) { |
| MethodConfiguration config = LibraryService.getInstance().getCurrentMethodConfiguration(); |
| if(config != null && config.eContainer() != library) { |
| setMethodConfiguration(null); |
| } |
| // Add a library change listener. |
| ILibraryManager manager = LibraryService.getInstance() |
| .getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.addListener(this); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.events.ILibraryChangeListener#libraryChanged(int, |
| * Collection) |
| */ |
| public void libraryChanged(int option, Collection changedItems) { |
| switch (option) { |
| case ILibraryChangeListener.OPTION_DELETED: |
| if (changedItems != null) { |
| for (Iterator it = changedItems.iterator(); it.hasNext();) { |
| Object element = it.next(); |
| if (element instanceof MethodConfiguration) { |
| if (((MethodConfiguration) element).getName().equals( |
| getCurrentConfig())) { |
| setMethodConfiguration(null); |
| } |
| } |
| } |
| } |
| break; |
| // Bugzilla defect 164739 |
| case ILibraryChangeListener.OPTION_CHANGED: |
| if (changedItems != null) { |
| for (Iterator it = changedItems.iterator(); it.hasNext();) { |
| Object element = it.next(); |
| if (element instanceof MethodConfiguration) { |
| if (((MethodConfiguration) element) |
| .equals(LibraryService.getInstance() |
| .getCurrentMethodConfiguration())) { |
| setContentDescription(((MethodConfiguration) element) |
| .getName()); |
| } |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#configurationSet(MethodConfiguration) |
| */ |
| public void configurationSet(MethodConfiguration config) { |
| setMethodConfiguration(config); |
| ConfigurationContributionItem configCombo = LibraryUIManager.getInstance().getConfigCombo(); |
| if (configCombo != null) { |
| configCombo.setCollapseConfigViewAction(getCollapseViewAction()); |
| } |
| } |
| |
| /** |
| * @return the name of the currently viewed configuration |
| */ |
| public String getCurrentConfig() { |
| return configName; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#setFocus() |
| */ |
| public void setFocus() { |
| actionBarContributor.setActiveView(this); |
| |
| IStructuredSelection selected = (IStructuredSelection) getSelection(); |
| if (selected.isEmpty()) |
| actionBarContributor.disableGlobalEditMenu(); |
| else |
| actionBarContributor.enableGlobalEditMenu(); |
| |
| if (treeViewer != null) { |
| treeViewer.getControl().setFocus(); |
| } |
| } |
| |
| /** |
| * Creates the viewer. |
| */ |
| public void createViewer(Composite parent) { |
| // Create the controls. |
| Composite content = new Composite(parent, SWT.NONE); |
| content.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| GridLayout layout = new GridLayout(); |
| content.setLayout(layout); |
| |
| treeViewer = new TreeViewer(content); |
| treeViewer.setUseHashlookup(true); |
| treeViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // Add drag-and-drop support. |
| int dndOperations = DND.DROP_COPY | DND.DROP_MOVE ; |
| Transfer[] transfers = new Transfer[] { HTMLTransfer.getInstance(), TextTransfer.getInstance(), |
| LocalTransfer.getInstance() }; |
| treeViewer.addDragSupport(dndOperations, transfers, |
| new LibraryViewerDragAdapter(treeViewer)); |
| |
| // Add a double click listener. |
| doubleClickListener = new IDoubleClickListener() { |
| public void doubleClick(DoubleClickEvent event) { |
| UIActionDispatcher.getInstance().handleDoubleClickEvent(event); |
| } |
| }; |
| treeViewer.addDoubleClickListener(doubleClickListener); |
| |
| createContextMenuFor(treeViewer); |
| } |
| |
| /** |
| * Creates the actions. |
| */ |
| public void createActions(IViewSite viewSite) { |
| IAction editAction = new Action(AuthoringUIResources.actionLabel_edit) { |
| public void run() { |
| UIActionDispatcher.editConfiguration(configName); |
| } |
| }; |
| editAction |
| .setToolTipText(AuthoringUIResources.editConfiguration_tooltip); |
| } |
| |
| private void reset() { |
| // Prevent memory leak. |
| configName = null; |
| if (adapterFactory != null) { |
| if (adapterFactory instanceof IDisposable) { |
| ((IDisposable) adapterFactory).dispose(); |
| } |
| adapterFactory = null; |
| } |
| editingDomain.setAdapterFactory(null); |
| IContentProvider contentProvider = treeViewer.getContentProvider(); |
| if (contentProvider != null) { |
| contentProvider.dispose(); |
| } |
| IBaseLabelProvider labelProvider = treeViewer.getLabelProvider(); |
| if (labelProvider != null) { |
| labelProvider.dispose(); |
| } |
| StructuredSelection emptySelection = new StructuredSelection(); |
| actionDispatcher.setSelection(emptySelection); |
| UIActionDispatcher.getInstance().setSelection(emptySelection); |
| } |
| |
| private IFilter createFilter(MethodConfiguration config) { |
| IContentProviderFactory cpFactory = getContentProviderFactory(); |
| IFilter filter = null; |
| if(cpFactory != null) { |
| filter = cpFactory.createFilter(config, treeViewer); |
| } |
| return filter != null ? filter : new ConfigurationViewFilter(config, treeViewer); |
| } |
| |
| /** |
| * Sets the given Method Configuration as this viewer's input |
| * |
| * @param config |
| */ |
| public void setMethodConfiguration(MethodConfiguration config) { |
| Control ctrl = this.getViewer().getControl(); |
| if (ctrl == null || ctrl.isDisposed()) { |
| return; |
| } |
| |
| if (treeViewer.getInput() == config) |
| return; |
| String title = ""; //$NON-NLS-1$ |
| |
| if (config != null) { |
| this.configName = config.getName(); |
| configFilter = createFilter(config); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getConfigurationView_AdapterFactory(configFilter); |
| editingDomain.setAdapterFactory(adapterFactory); |
| AdapterFactoryContentProvider contentProvider = (AdapterFactoryContentProvider) treeViewer.getContentProvider(); |
| if(contentProvider == null) { |
| contentProvider = createContentProvider(); |
| } |
| else { |
| contentProvider.setAdapterFactory(adapterFactory); |
| } |
| treeViewer.setContentProvider(contentProvider); |
| treeViewer.setLabelProvider(new ConfigurationDecoratingLabelProvider(config, |
| adapterFactory)); |
| title = config.getName(); |
| } else { |
| // Prevent memory leak. |
| configName = null; |
| if (adapterFactory != null) { |
| if (adapterFactory instanceof IDisposable) { |
| ((IDisposable) adapterFactory).dispose(); |
| } |
| adapterFactory = null; |
| } |
| editingDomain.setAdapterFactory(null); |
| IContentProvider contentProvider = treeViewer.getContentProvider(); |
| if (contentProvider != null) { |
| contentProvider.dispose(); |
| } |
| IBaseLabelProvider labelProvider = treeViewer.getLabelProvider(); |
| if (labelProvider != null) { |
| labelProvider.dispose(); |
| } |
| StructuredSelection emptySelection = new StructuredSelection(); |
| actionDispatcher.setSelection(emptySelection); |
| UIActionDispatcher.getInstance().setSelection(emptySelection); |
| } |
| |
| treeViewer.setInput(config); |
| setContentDescription(title); |
| } |
| |
| /** |
| * Sets this viewer's input to the Method Configuration with the given name |
| * |
| * @param name |
| */ |
| public void setConfiguration(String name) { |
| configName = name; |
| |
| if (name == null) { |
| MethodConfiguration config = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| if (config != null) { |
| configName = config.getName(); |
| } |
| } |
| |
| if (configName != null) { |
| MethodConfiguration config = LibraryServiceUtil |
| .getMethodConfiguration(LibraryService.getInstance() |
| .getCurrentMethodLibrary(), configName); |
| if (config != null) { |
| setMethodConfiguration(config); |
| return; |
| } |
| } |
| |
| this.configName = null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#dispose() |
| */ |
| public void dispose() { |
| super.dispose(); |
| if (doubleClickListener != null) { |
| treeViewer.removeDoubleClickListener(doubleClickListener); |
| } |
| } |
| |
| /** |
| * @return the ConfigurationView object |
| */ |
| public static ConfigurationView getView() { |
| // try { |
| // IWorkbenchPage activePage = PlatformUI.getWorkbench() |
| // .getActiveWorkbenchWindow().getActivePage(); |
| // if (activePage != null) { |
| // IViewPart view = activePage.findView(VIEW_ID); |
| // if (view == null) { |
| // view = activePage.showView(VIEW_ID); |
| // } |
| // return (ConfigurationView) view; |
| // } |
| // |
| // } catch (Exception e) { |
| // AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| // } |
| // |
| // return null; |
| |
| boolean show = ViewHelper.isViewInCurrentPerspective(VIEW_ID); |
| return (ConfigurationView)ViewHelper.findView(VIEW_ID, show); |
| } |
| |
| public static ConfigurationView getView(String viewId) { |
| boolean show = ViewHelper.isViewInCurrentPerspective(viewId); |
| return (ConfigurationView)ViewHelper.findView(viewId, show); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#getViewer() |
| */ |
| public Viewer getViewer() { |
| return treeViewer; |
| } |
| |
| private class ConfigurationViewActionBarContributor extends |
| LibraryActionBarContributor { |
| |
| private LibraryViewFindElementAction libraryViewFindElementAction; |
| |
| public ConfigurationViewActionBarContributor(EditingDomain editingDomain) { |
| super(editingDomain); |
| |
| // don't show validate action |
| // |
| validateAction = null; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#init(IActionBars) |
| */ |
| public void init(IActionBars actionBars) { |
| ISharedImages sharedImages = PlatformUI.getWorkbench() |
| .getSharedImages(); |
| copyAction = createCopyAction(); |
| copyAction.setImageDescriptor(sharedImages |
| .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); |
| actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(), |
| copyAction); |
| |
| viewActionBars = actionBars; |
| configViewEditAction = new ConfigurationViewEditAction( |
| AuthoringUIResources.actionLabel_edit); |
| actionBars.setGlobalActionHandler( |
| "org.eclipse.epf.authoring.ui.actions.openElement", //$NON-NLS-1$ |
| configViewEditAction); |
| libraryViewFindElementAction = new LibraryViewFindElementAction( |
| AuthoringUIResources.actionLabel_findElementInLibNav); |
| actionBars.setGlobalActionHandler( |
| LibraryViewFindElementAction.ACTION_ID, |
| libraryViewFindElementAction); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#activate() |
| */ |
| public void activate() { |
| activeViewPart.addPropertyListener(this); |
| ISelectionProvider selectionProvider = activeViewPart instanceof ISelectionProvider ? (ISelectionProvider) activeViewPart |
| : activeViewPart.getSite().getSelectionProvider(); |
| selectionProvider.addSelectionChangedListener(configViewEditAction); |
| selectionProvider |
| .addSelectionChangedListener(libraryViewFindElementAction); |
| copyAction.setEditingDomain(editingDomain); |
| selectionProvider.addSelectionChangedListener(copyAction); |
| update(); |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#deactivate() |
| */ |
| public void deactivate() { |
| activeViewPart.removePropertyListener(this); |
| ISelectionProvider selectionProvider = activeViewPart instanceof ISelectionProvider ? (ISelectionProvider) activeViewPart |
| : activeViewPart.getSite().getSelectionProvider(); |
| selectionProvider |
| .removeSelectionChangedListener(configViewEditAction); |
| selectionProvider |
| .removeSelectionChangedListener(libraryViewFindElementAction); |
| copyAction.setEditingDomain(null); |
| selectionProvider.removeSelectionChangedListener(copyAction); |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#update() |
| */ |
| public void update() { |
| ISelectionProvider selectionProvider = activeViewPart instanceof ISelectionProvider ? (ISelectionProvider) activeViewPart |
| : activeViewPart.getSite().getSelectionProvider(); |
| ISelection selection = selectionProvider.getSelection(); |
| IStructuredSelection structuredSelection = selection instanceof IStructuredSelection ? (IStructuredSelection) selection |
| : StructuredSelection.EMPTY; |
| configViewEditAction.selectionChanged(structuredSelection); |
| libraryViewFindElementAction.selectionChanged(structuredSelection); |
| copyAction.updateSelection(structuredSelection); |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#selectionChanged(SelectionChangedEvent) |
| */ |
| public void selectionChanged(SelectionChangedEvent event) { |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#disableGlobalEditMenu() |
| */ |
| public void disableGlobalEditMenu() { |
| configViewEditAction.setEnabled(false); |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#enableGlobalEditMenu() |
| */ |
| public void enableGlobalEditMenu() { |
| configViewEditAction.setEnabled(true); |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#menuAboutToShow(IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| menuAboutToShow_(menuManager); |
| getExtender().getActionBarExtender().menuAboutToShow(menuManager); |
| } |
| |
| private void menuAboutToShow_(IMenuManager menuManager) { |
| // Add our standard markers. |
| menuManager.add(new Separator("additions")); //$NON-NLS-1$ |
| menuManager.add(new Separator("edit")); //$NON-NLS-1$ |
| |
| // Add our other standard marker. |
| menuManager.add(new Separator("additions-end")); //$NON-NLS-1$ |
| |
| addGlobalActions(menuManager); |
| |
| menuManager.add(new Separator()); |
| menuManager.add(new ActionContributionItem(configViewEditAction)); |
| if (PerspectiveListUtil.isAuthoringPerspective()) { |
| menuManager.add(new ActionContributionItem( |
| libraryViewFindElementAction)); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createCopyAction() |
| */ |
| protected CopyAction createCopyAction() { |
| return new LibraryViewCopyAction() { |
| @Override |
| public Command createCommand(Collection selection) { |
| return new IdentityCommand(selection); |
| } |
| |
| @Override |
| public void run() { |
| String links = ""; //$NON-NLS-1$ |
| for (Iterator iter = ((IdentityCommand) command) |
| .getResult().iterator(); iter.hasNext();) { |
| Object item = TngUtil.unwrap(iter.next()); |
| if (item instanceof MethodElement) { |
| MethodElement e = (MethodElement) item; |
| String href = ResourceHelper |
| .getUrl(e, null, "html"); //$NON-NLS-1$ |
| if (links.length() > 0) { |
| links += StrUtil.LINE_FEED; |
| } |
| links += ResourceHelper.getElementLink(e, true, |
| "file://" + href); //$NON-NLS-1$ |
| } |
| } |
| if (links.length() > 0) { |
| ClipboardUtil.copyTextHTMLToClipboard(links); |
| } |
| } |
| }; |
| } |
| |
| @Override |
| protected void refreshViewer(Viewer viewer) { |
| refresh(); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#createActionBarContributor() |
| */ |
| public ILibraryActionBarContributor createActionBarContributor() { |
| return new ConfigurationViewActionBarContributor(editingDomain); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#setInputForViewer(Object) |
| */ |
| public void setInputForViewer(Object model) { |
| if ((model == null) || (model instanceof MethodConfiguration)) { |
| setMethodConfiguration((MethodConfiguration) model); |
| } else { |
| reset(); |
| } |
| } |
| |
| public void refresh() { |
| ConfigurationHelper.getDelegate().configViewRefreshNotified(); |
| |
| if(configFilter instanceof ConfigurationViewFilter) { |
| ((ConfigurationViewFilter)configFilter).refreshViewer(); |
| } |
| else { |
| getViewer().refresh(); |
| } |
| } |
| |
| @Override |
| public String getViewId() { |
| return VIEW_ID; |
| } |
| |
| private ConfigurationViewExtender extender; |
| protected ConfigurationViewExtender getExtender() { |
| return extender; |
| } |
| |
| @Override |
| public void setSelection(ISelection selection) { |
| getExtender().getActionBarExtender().updateSelection(selection); |
| super.setSelection(selection); |
| } |
| |
| //temp code |
| public void setDiffName(String name) { |
| setPartName(name); |
| } |
| |
| } |