| //------------------------------------------------------------------------------ |
| // 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; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.epf.authoring.ui.dialogs.ContributionSelection; |
| import org.eclipse.epf.authoring.ui.editors.EditorChooser; |
| import org.eclipse.epf.authoring.ui.views.ConfigurationView; |
| import org.eclipse.epf.authoring.ui.views.LibraryView; |
| import org.eclipse.epf.common.ui.util.PerspectiveUtil; |
| import org.eclipse.epf.library.configuration.ConfigurationHelper; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.Milestone; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| 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.ui.IPerspectiveDescriptor; |
| import org.eclipse.ui.IPerspectiveListener; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * Handles UI actions in the workbench. |
| * |
| * @author Jinhua Xi |
| * @author Kelvin Low |
| * @author Shilpa Toraskar |
| * @since 1.0 |
| */ |
| public class UIActionDispatcher implements ISelectionProvider { |
| |
| private static UIActionDispatcher instance = null; |
| |
| protected List<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>(); |
| |
| protected List<IDoubleClickListener> doubleClickListeners = new ArrayList<IDoubleClickListener>(); |
| |
| private CurrentSelection currentSelection = new CurrentSelection(); |
| |
| private IDoubleClickListener doubleClickListener = null; |
| |
| /** |
| * Returns the singleton instance. |
| */ |
| public static UIActionDispatcher getInstance() { |
| if (instance == null) { |
| synchronized (UIActionDispatcher.class) { |
| if (instance == null) { |
| instance = new UIActionDispatcher(); |
| } |
| } |
| } |
| return instance; |
| } |
| |
| /** |
| * Private default constructor. |
| */ |
| private UIActionDispatcher() { |
| this(null); |
| } |
| |
| /** |
| * create an action dispatcher of my own |
| * |
| * @param owner |
| */ |
| public UIActionDispatcher(Object owner) { |
| // Create the double click listener used for launching the Method |
| // editors. |
| doubleClickListener = new IDoubleClickListener() { |
| public void doubleClick(DoubleClickEvent e) { |
| ISelection selection = e.getSelection(); |
| if (selection != null) { |
| IWorkbenchWindow window = PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow(); |
| IWorkbenchPartSite site = window.getActivePage() |
| .getActivePart().getSite(); |
| |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| Object[] selObjs = sel.toArray(); |
| Object selectedObject = null; |
| |
| if ((selObjs != null) && (selObjs.length > 0)) { |
| // Open the Authoring persepective. |
| UIActionDispatcher.openAuthoringPerspective(); |
| |
| // Locate the selected Method element. |
| Object obj = TngUtil.unwrap(selObjs[0]); |
| ConfigurationView view = ConfigurationView.getView(); |
| if ((view != null ) && site.equals(view.getSite()) ) { |
| // Double-click orginated from the Configuration |
| // view. |
| if (obj instanceof VariabilityElement) { |
| VariabilityElement element = (VariabilityElement) obj; |
| ContributionSelection contribSelection = new ContributionSelection(); |
| selectedObject = contribSelection |
| .getSelectedContributor(element); |
| } |
| else if (obj instanceof Milestone) { |
| selectedObject = TngUtil.getOwningProcess((BreakdownElement) obj); |
| } |
| } else { |
| selectedObject = obj; |
| } |
| |
| if (selectedObject != null) { |
| |
| EditorChooser.getInstance().openEditor( |
| selectedObject); |
| } |
| } |
| } |
| } |
| }; |
| |
| // Add a perspective listener to enable/disable double-click listening. |
| IWorkbenchWindow activeWorkbenchWindow = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow(); |
| if (activeWorkbenchWindow != null) { |
| activeWorkbenchWindow |
| .addPerspectiveListener(new IPerspectiveListener() { |
| public void perspectiveActivated(IWorkbenchPage page, |
| IPerspectiveDescriptor desc) { |
| if (desc.getId().equals( |
| AuthoringPerspective.PERSPECTIVE_ID)) { |
| addDoubleClickListener(doubleClickListener); |
| LibraryView.getViewInstance().registerChangeListeners(); |
| } else { |
| removeDoubleClickListener(doubleClickListener); |
| } |
| |
| ConfigurationHelper.getDelegate().setAuthoringPerspective( |
| AuthoringPerspective.PERSPECTIVE_ID.equals(desc.getId())); |
| } |
| |
| public void perspectiveChanged(IWorkbenchPage page, |
| IPerspectiveDescriptor desc, String id) { |
| |
| ConfigurationHelper.getDelegate().setAuthoringPerspective( |
| AuthoringPerspective.PERSPECTIVE_ID.equals(desc.getId())); |
| } |
| }); |
| } |
| |
| if (PerspectiveUtil |
| .isActivePerspective(AuthoringPerspective.PERSPECTIVE_ID)) { |
| addDoubleClickListener(doubleClickListener); |
| } |
| } |
| |
| public static void editConfiguration(String configName) { |
| } |
| |
| /** |
| * Open library perspective |
| * |
| */ |
| public static void openLibraryPerspective() { |
| PerspectiveUtil.openPerspective(BrowsingPerspective.PERSPECTIVE_ID); |
| IWorkbenchPage wkbPage = PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage(); |
| IViewPart viewPart = wkbPage.findView(LibraryView.VIEW_ID); |
| if (viewPart != null) |
| wkbPage.hideView(viewPart); |
| viewPart = wkbPage.findView(ConfigurationView.VIEW_ID); |
| wkbPage.activate(viewPart); |
| } |
| |
| /** |
| * Open authoring perspective |
| * |
| */ |
| public static void openAuthoringPerspective() { |
| PerspectiveUtil.openPerspective(AuthoringPerspective.PERSPECTIVE_ID); |
| IWorkbenchPage wkbPage = PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage(); |
| IViewPart viewPart = wkbPage.findView(LibraryView.VIEW_ID); |
| wkbPage.activate(viewPart); |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ISelectionProvider#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) |
| */ |
| public void addSelectionChangedListener(ISelectionChangedListener listener) { |
| if (!selectionChangedListeners.contains(listener)) { |
| selectionChangedListeners.add(listener); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ISelectionProvider#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener) |
| */ |
| public void removeSelectionChangedListener( |
| ISelectionChangedListener listener) { |
| selectionChangedListeners.remove(listener); |
| } |
| |
| /** |
| * Return current selection |
| */ |
| public ISelection getSelection() { |
| return currentSelection.selection; |
| } |
| |
| public ISelectionProvider getSelectionSource() { |
| return currentSelection.source; |
| } |
| |
| /** |
| * Sets current selection |
| */ |
| public void setSelection(ISelection selection) { |
| setSelection(this, selection); |
| } |
| |
| /** |
| * Sets current selection |
| */ |
| public void setSelection(ISelectionProvider source, ISelection selection) { |
| synchronized (this) { |
| currentSelection.selection = selection; |
| currentSelection.source = source; |
| |
| SelectionChangedEvent event = new SelectionChangedEvent(source, |
| selection); |
| |
| // Avoid concurrent error. |
| List<ISelectionChangedListener> processedItems = new ArrayList<ISelectionChangedListener>(); |
| while (selectionChangedListeners.size() > 0) { |
| ISelectionChangedListener listener = (ISelectionChangedListener) selectionChangedListeners |
| .remove(0); |
| if (listener != null) { |
| try { |
| listener.selectionChanged(event); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| processedItems.add(listener); |
| } |
| } |
| |
| selectionChangedListeners.addAll(processedItems); |
| } |
| } |
| |
| /** |
| * Add double click listener |
| * |
| * @param listener |
| */ |
| public void addDoubleClickListener(IDoubleClickListener listener) { |
| if (!doubleClickListeners.contains(listener)) { |
| doubleClickListeners.add(listener); |
| } |
| } |
| |
| /** |
| * Remove double click listener |
| * |
| * @param listener |
| */ |
| public void removeDoubleClickListener(IDoubleClickListener listener) { |
| doubleClickListeners.remove(listener); |
| } |
| |
| /** |
| * Handle double click event |
| * |
| * @param event |
| */ |
| public void handleDoubleClickEvent(DoubleClickEvent event) { |
| synchronized (this) { |
| // Avoid concurrent error. |
| List<IDoubleClickListener> processedItems = new ArrayList<IDoubleClickListener>(); |
| while (doubleClickListeners.size() > 0) { |
| IDoubleClickListener listener = (IDoubleClickListener) doubleClickListeners |
| .remove(0); |
| try { |
| listener.doubleClick(event); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| processedItems.add(listener); |
| } |
| doubleClickListeners.addAll(processedItems); |
| } |
| } |
| |
| public class CurrentSelection { |
| |
| public ISelectionProvider source = null; |
| |
| public ISelection selection = StructuredSelection.EMPTY; |
| |
| } |
| |
| } |