| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 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.editors; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.EventObject; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.common.CommonPlugin; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CommandStack; |
| import org.eclipse.emf.common.command.CommandStackListener; |
| import org.eclipse.emf.common.command.UnexecutableCommand; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.impl.AdapterImpl; |
| import org.eclipse.emf.common.notify.impl.NotificationImpl; |
| import org.eclipse.emf.common.ui.viewer.IViewerProvider; |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.edit.command.CommandParameter; |
| import org.eclipse.emf.edit.command.CreateChildCommand; |
| import org.eclipse.emf.edit.command.CutToClipboardCommand; |
| import org.eclipse.emf.edit.command.RemoveCommand; |
| import org.eclipse.emf.edit.command.SetCommand; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; |
| import org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.DelegatingWrapperItemProvider; |
| import org.eclipse.emf.edit.provider.IChangeNotifier; |
| import org.eclipse.emf.edit.provider.IEditingDomainItemProvider; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.provider.ViewerNotification; |
| import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory; |
| import org.eclipse.emf.edit.ui.action.CommandActionHandler; |
| import org.eclipse.emf.edit.ui.action.CopyAction; |
| import org.eclipse.emf.edit.ui.action.CutAction; |
| import org.eclipse.emf.edit.ui.action.DeleteAction; |
| import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor; |
| import org.eclipse.emf.edit.ui.action.PasteAction; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.actions.IWorkbenchPartAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryValidateAction; |
| import org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.ProcessAutoSynchronizeAction; |
| import org.eclipse.epf.authoring.ui.actions.SynchronizationAction; |
| import org.eclipse.epf.authoring.ui.actions.UpdateSuppressionFromBaseAction; |
| import org.eclipse.epf.authoring.ui.dialogs.DialogHelper; |
| import org.eclipse.epf.authoring.ui.dialogs.UserDefinedDiagramDialog; |
| import org.eclipse.epf.authoring.ui.dnd.EditingDomainTableTreeViewerDropAdapter; |
| import org.eclipse.epf.authoring.ui.forms.DeliveryProcessDescription; |
| import org.eclipse.epf.authoring.ui.forms.IExtensionFormPage; |
| import org.eclipse.epf.authoring.ui.forms.ProcessBreakdownStructureFormPage; |
| import org.eclipse.epf.authoring.ui.forms.ProcessDescription; |
| import org.eclipse.epf.authoring.ui.preferences.ApplicationPreferenceConstants; |
| import org.eclipse.epf.authoring.ui.properties.EPFPropertySheetPage; |
| import org.eclipse.epf.authoring.ui.providers.ProcessEditorPageProvider; |
| import org.eclipse.epf.authoring.ui.util.UIHelper; |
| import org.eclipse.epf.authoring.ui.views.LibraryView; |
| import org.eclipse.epf.authoring.ui.views.ProcessViewer; |
| import org.eclipse.epf.authoring.ui.views.ViewHelper; |
| import org.eclipse.epf.diagram.add.part.ActivityDetailDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInput; |
| import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil; |
| import org.eclipse.epf.diagram.core.services.DiagramHelper; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataHelper; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataManager; |
| import org.eclipse.epf.diagram.wpdd.part.WPDDiagramEditorPlugin; |
| import org.eclipse.epf.diagramming.part.EPFDiagramEditorPlugin; |
| import org.eclipse.epf.library.ILibraryManager; |
| import org.eclipse.epf.library.ILibraryServiceListener; |
| import org.eclipse.epf.library.LibraryPlugin; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.configuration.ProcessAuthoringConfigurator; |
| import org.eclipse.epf.library.edit.IAdapterFactoryProvider; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.LibraryEditResources; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.command.CommandStackChangedEvent; |
| import org.eclipse.epf.library.edit.command.IActionManager; |
| import org.eclipse.epf.library.edit.command.IResourceAwareCommand; |
| import org.eclipse.epf.library.edit.command.ResourceAwarePasteFromClipboardCommand; |
| import org.eclipse.epf.library.edit.process.ActivityWrapperItemProvider; |
| import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider; |
| import org.eclipse.epf.library.edit.process.IBSItemProvider; |
| import org.eclipse.epf.library.edit.process.command.ActivityDropCommand; |
| import org.eclipse.epf.library.edit.process.command.ContributeToActivityCommand; |
| import org.eclipse.epf.library.edit.process.command.LocallyReplaceAndDeepCopyCommand; |
| import org.eclipse.epf.library.edit.process.command.ReplaceActivityCommand; |
| import org.eclipse.epf.library.edit.ui.IActionTypeProvider; |
| import org.eclipse.epf.library.edit.ui.UserInteractionHelper; |
| import org.eclipse.epf.library.edit.util.ConfigurableComposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.EditingDomainComposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.ExposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.IDiagramManager; |
| import org.eclipse.epf.library.edit.util.ProcessUtil; |
| import org.eclipse.epf.library.edit.util.Suppression; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand; |
| import org.eclipse.epf.library.edit.validation.DependencyChecker; |
| import org.eclipse.epf.library.events.ILibraryChangeListener; |
| import org.eclipse.epf.library.prefs.PreferenceUtil; |
| import org.eclipse.epf.library.ui.LibraryUIImages; |
| import org.eclipse.epf.library.ui.actions.LibraryLockingOperationRunner; |
| import org.eclipse.epf.library.ui.actions.ProcessDeleteAction; |
| import org.eclipse.epf.library.util.ResourceUtil; |
| import org.eclipse.epf.persistence.FileManager; |
| import org.eclipse.epf.persistence.MultiFileXMIResourceImpl; |
| import org.eclipse.epf.persistence.refresh.RefreshJob; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.CapabilityPattern; |
| import org.eclipse.epf.uma.DeliveryProcess; |
| import org.eclipse.epf.uma.Descriptor; |
| import org.eclipse.epf.uma.Diagram; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.Milestone; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.RoleDescriptor; |
| import org.eclipse.epf.uma.TaskDescriptor; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.epf.uma.VariabilityType; |
| import org.eclipse.epf.uma.WorkBreakdownElement; |
| import org.eclipse.epf.uma.WorkProductDescriptor; |
| import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| import org.eclipse.epf.validation.LibraryEValidator; |
| import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.AbstractTreeViewer; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StructuredViewer; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.DropTargetEvent; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Widget; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.ui.actions.BaseSelectionListenerAction; |
| import org.eclipse.ui.dialogs.ListSelectionDialog; |
| import org.eclipse.ui.forms.editor.IFormPage; |
| import org.eclipse.ui.ide.IGotoMarker; |
| import org.eclipse.ui.views.properties.IPropertySheetPage; |
| import org.eclipse.ui.views.properties.PropertySheet; |
| import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor; |
| |
| import com.ibm.icu.util.StringTokenizer; |
| |
| /** |
| * Editor for process authoring. |
| * |
| * @author Phong Nguyen Le |
| * @author Shilpa Toraskar |
| * @author Jinhua Xi |
| * @since 1.0 |
| */ |
| public class ProcessEditor extends MethodElementEditor implements |
| IEditingDomainProvider, IMenuListener, ISelectionProvider, |
| IViewerProvider, ITabbedPropertySheetPageContributor { |
| |
| /** |
| * The editor ID. |
| */ |
| public static final String EDITOR_ID = ProcessEditor.class.getName(); |
| |
| public static final String WORKFLOW_EDITOR_ID = GraphicalWorkflowEditor.class |
| .getName(); |
| |
| public static final String ACTIVITY_DETAIL_DIAGRAM_EDITOR_ID = ActivityDetailDiagramEditor.class |
| .getName(); |
| |
| public static final String WPDEPENDENCY_EDITOR_ID = GraphicalWPDependencyEditor.class |
| .getName(); |
| |
| /** Column descriptor constants */ |
| public static final ColumnDescriptor COL_DESC_NAME = new ColumnDescriptor( |
| IBSItemProvider.COL_NAME, ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_NAME), |
| 3, 200, true, ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_ID = new ColumnDescriptor( |
| IBSItemProvider.COL_ID, ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_ID), |
| 0, 40, true, ColumnDescriptor.CELL_EDITOR_TYPE_NONE); |
| |
| public static final ColumnDescriptor COL_DESC_PREFIX = new ColumnDescriptor( |
| IBSItemProvider.COL_PREFIX, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_PREFIX), 0, 80, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_MODEL_INFO = new ColumnDescriptor( |
| IBSItemProvider.COL_MODEL_INFO, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_MODEL_INFO), 0, 120, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_NONE); |
| |
| public static final ColumnDescriptor COL_DESC_TYPE = new ColumnDescriptor( |
| IBSItemProvider.COL_TYPE, ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_TYPE), |
| 0, 80, true, ColumnDescriptor.CELL_EDITOR_TYPE_NONE); |
| |
| public static final ColumnDescriptor COL_DESC_PREDECESSORS = new ColumnDescriptor( |
| IBSItemProvider.COL_PREDECESSORS, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_PREDECESSORS), 2, 100, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_IS_REPEATABLE = new ColumnDescriptor( |
| IBSItemProvider.COL_IS_REPEATABLE, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_IS_REPEATABLE), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final ColumnDescriptor COL_DESC_IS_ONGOING = new ColumnDescriptor( |
| IBSItemProvider.COL_IS_ONGOING, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_IS_ONGOING), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final ColumnDescriptor COL_DESC_IS_EVENT_DRIVEN = new ColumnDescriptor( |
| IBSItemProvider.COL_IS_EVENT_DRIVEN, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_IS_EVENT_DRIVEN), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final ColumnDescriptor COL_DESC_TEAM = new ColumnDescriptor( |
| IBSItemProvider.COL_TEAMS, ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_TEAMS), |
| 1, 100, true, ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_ENTRY_STATE = new ColumnDescriptor( |
| IBSItemProvider.COL_ENTRY_STATE, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_ENTRY_STATE), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_EXIT_STATE = new ColumnDescriptor( |
| IBSItemProvider.COL_EXIT_STATE, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_EXIT_STATE), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_PRESENTATION_NAME = new ColumnDescriptor( |
| IBSItemProvider.COL_PRESENTATION_NAME, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_PRESENTATION_NAME), 3, 200, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_DELIVERABLE = new ColumnDescriptor( |
| IBSItemProvider.COL_DELIVERABLE, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_DELIVERABLE), 1, 100, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_TEXT); |
| |
| public static final ColumnDescriptor COL_DESC_IS_OPTIONAL = new ColumnDescriptor( |
| IBSItemProvider.COL_IS_OPTIONAL, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_IS_OPTIONAL), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final ColumnDescriptor COL_DESC_IS_PLANNED = new ColumnDescriptor( |
| IBSItemProvider.COL_IS_PLANNED, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_IS_PLANNED), 1, 60, true, |
| ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final ColumnDescriptor COL_DESC_HAS_MULTIPLE_OCCURRENCES = new ColumnDescriptor( |
| IBSItemProvider.COL_HAS_MULTIPLE_OCCURRENCES, |
| ProcessUtil.getColumnDisplayName(IBSItemProvider.COL_HAS_MULTIPLE_OCCURRENCES), 1, 60, |
| true, ColumnDescriptor.CELL_EDITOR_TYPE_CHECK_BOOLEAN); |
| |
| public static final String WBS_FORM_ID = "wbs"; //$NON-NLS-1$ |
| |
| public static final String TA_FORM_ID = "tbs"; //$NON-NLS-1$ |
| |
| public static final String WPBS_FORM_ID = "wpbs"; //$NON-NLS-1$ |
| |
| public static final String CONSOLIDATED_FORM_ID = "consolidated"; //$NON-NLS-1$ |
| |
| // change the default order based on 152867 - Publish option and prefrences |
| /* WBS: Presentation Name, Index, Predecessors, Model Info, Type, Planned, |
| Repeatable, Multiple Occurrences, Ongoing, Event-driven, Optional |
| TA: Presentation Name, Model Info, Team, Type, Planned, Multiple |
| Occurrences, Optional |
| Work Product Usage: Presentation Name, Model Info, Entry State, Exit State, |
| Deliverable, Type, Planned, Multiple Occurrences, Optional |
| */ |
| // Jinhua Xi, 08/21/2006 |
| |
| // the default list must be available in the library plugin as well. |
| // duplicate definition for now, will need to merge together later |
| // see PreferenceConstants.org.eclipse.epf.library.prefs |
| |
| public static final List DEFAULT_TBS_COLUMNS = Arrays |
| .asList(new ColumnDescriptor[] { |
| COL_DESC_PRESENTATION_NAME, |
| // COL_DESC_ID, |
| //COL_DESC_PREFIX, |
| COL_DESC_MODEL_INFO, COL_DESC_TEAM, COL_DESC_TYPE, |
| COL_DESC_IS_PLANNED, |
| COL_DESC_HAS_MULTIPLE_OCCURRENCES, COL_DESC_IS_OPTIONAL }); |
| |
| public static final List DEFAULT_WPBS_COLUMNS = Arrays |
| .asList(new ColumnDescriptor[] { |
| COL_DESC_PRESENTATION_NAME, |
| // COL_DESC_ID, |
| //COL_DESC_PREFIX, |
| COL_DESC_MODEL_INFO, COL_DESC_ENTRY_STATE, |
| COL_DESC_EXIT_STATE, |
| COL_DESC_DELIVERABLE, COL_DESC_TYPE, |
| COL_DESC_IS_PLANNED, COL_DESC_HAS_MULTIPLE_OCCURRENCES, COL_DESC_IS_OPTIONAL }); |
| |
| public static final List DEFAULT_WBS_COLUMNS = Arrays |
| .asList(new ColumnDescriptor[] { COL_DESC_PRESENTATION_NAME, |
| COL_DESC_ID, |
| //COL_DESC_PREFIX, |
| COL_DESC_PREDECESSORS, COL_DESC_MODEL_INFO, |
| COL_DESC_TYPE, COL_DESC_IS_PLANNED, |
| COL_DESC_IS_REPEATABLE, COL_DESC_HAS_MULTIPLE_OCCURRENCES, COL_DESC_IS_ONGOING, |
| COL_DESC_IS_EVENT_DRIVEN, COL_DESC_IS_OPTIONAL |
| }); |
| |
| |
| public static final List ALL_WBS_COLUMNS = new ArrayList( |
| DEFAULT_WBS_COLUMNS); |
| |
| public static final List ALL_TBS_COLUMNS = new ArrayList( |
| DEFAULT_TBS_COLUMNS); |
| |
| public static final List ALL_WPBS_COLUMNS = new ArrayList( |
| DEFAULT_WPBS_COLUMNS); |
| |
| public static final Map idToColumnDescriptorMap = new HashMap(); |
| static { |
| ALL_WBS_COLUMNS.add(COL_DESC_PREFIX); |
| ALL_TBS_COLUMNS.add(COL_DESC_PREFIX); |
| ALL_WPBS_COLUMNS.add(COL_DESC_PREFIX); |
| |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_NAME.id, |
| COL_DESC_NAME); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_ID.id, COL_DESC_ID); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_PREFIX.id, |
| COL_DESC_PREFIX); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_MODEL_INFO.id, |
| COL_DESC_MODEL_INFO); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_TYPE.id, |
| COL_DESC_TYPE); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_PREDECESSORS.id, |
| COL_DESC_PREDECESSORS); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_IS_REPEATABLE.id, |
| COL_DESC_IS_REPEATABLE); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_IS_ONGOING.id, |
| COL_DESC_IS_ONGOING); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_IS_EVENT_DRIVEN.id, |
| COL_DESC_IS_EVENT_DRIVEN); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_TEAM.id, |
| COL_DESC_TEAM); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_ENTRY_STATE.id, |
| COL_DESC_ENTRY_STATE); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_EXIT_STATE.id, |
| COL_DESC_EXIT_STATE); |
| ProcessEditor.idToColumnDescriptorMap.put( |
| COL_DESC_PRESENTATION_NAME.id, COL_DESC_PRESENTATION_NAME); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_DELIVERABLE.id, |
| COL_DESC_DELIVERABLE); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_IS_OPTIONAL.id, |
| COL_DESC_IS_OPTIONAL); |
| ProcessEditor.idToColumnDescriptorMap.put(COL_DESC_IS_PLANNED.id, |
| COL_DESC_IS_PLANNED); |
| ProcessEditor.idToColumnDescriptorMap.put( |
| COL_DESC_HAS_MULTIPLE_OCCURRENCES.id, |
| COL_DESC_HAS_MULTIPLE_OCCURRENCES); |
| |
| ALL_WBS_COLUMNS.add(COL_DESC_NAME); |
| ALL_TBS_COLUMNS.add(COL_DESC_NAME); |
| ALL_WPBS_COLUMNS.add(COL_DESC_NAME); |
| } |
| |
| private static boolean addAdapterFactoryListeners = false; |
| |
| /** |
| * Action bar contribtutor for process editor |
| * |
| * |
| */ |
| public static class BSActionBarContributor extends |
| MethodLibraryActionBarContributor { |
| private Collection registeredActions = new ArrayList(); |
| |
| private boolean locked; |
| |
| private IAction rollupAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_RollUp) { |
| |
| public void run() { |
| boolean wasRolledUp = bsItemProvider.isRolledUp(); |
| bsItemProvider.setRolledUp(!bsItemProvider.isRolledUp()); |
| ((IChangeNotifier) bsItemProvider) |
| .fireNotifyChanged(new ViewerNotification( |
| new ENotificationImpl( |
| (InternalEObject) selectedActivity, |
| Notification.ADD, null, null, null, |
| false), selectedActivity, true, false)); |
| |
| if (bsItemProvider instanceof DelegatingWrapperItemProvider) { |
| // Refreshing for green activities during rollup |
| DelegatingWrapperItemProvider provider = (DelegatingWrapperItemProvider) bsItemProvider; |
| provider.fireNotifyChanged(new ViewerNotification( |
| new NotificationImpl(Notification.SET, provider, |
| provider), provider, true, false)); |
| } |
| if (wasRolledUp) { |
| ProcessViewer viewer = (ProcessViewer) ((ProcessEditor) activeEditor).currentViewer; |
| viewer.expandToLevel(selectedActivity, |
| AbstractTreeViewer.ALL_LEVELS); |
| |
| // eventhough we switched off creating new activities in |
| // WBS, |
| // user can still create thru AD. Hence we need to update |
| // IDs |
| // afterwards |
| doRefresh(); |
| } |
| } |
| |
| }; |
| |
| private IAction moveUpAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_MoveUp, |
| AuthoringUIPlugin.getDefault().getImageDescriptor( |
| "full/etool16/move_up.gif")) { //$NON-NLS-1$ |
| public void run() { |
| bsItemProvider.moveUp(selectedBreakdownElement, |
| getActionManager()); |
| refreshMoveButtonActions(); |
| } |
| }; |
| |
| private IAction moveDownAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_MoveDown, |
| AuthoringUIPlugin.getDefault().getImageDescriptor( |
| "full/etool16/move_down.gif")) { //$NON-NLS-1$ |
| public void run() { |
| bsItemProvider.moveDown(selectedBreakdownElement, |
| getActionManager()); |
| refreshMoveButtonActions(); |
| } |
| }; |
| |
| private IAction preferenceAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Preferences) { |
| public void run() { |
| // open process preference page |
| org.eclipse.ui.dialogs.PreferencesUtil |
| .createPreferenceDialogOn( |
| getActiveEditor().getEditorSite().getShell(), |
| "org.eclipse.epf.authoring.ui.preferences.ProcessEditorPreferencePage", //$NON-NLS-1$ |
| null, null).open(); |
| } |
| }; |
| |
| |
| private IAction openBaseActivity = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenBaseActivity) { |
| public void run() { |
| VariabilityElement base = selectedActivity |
| .getVariabilityBasedOnElement(); |
| Process proc = TngUtil |
| .getOwningProcess((BreakdownElement) base); |
| try { |
| int id = ((ProcessEditor) activeEditor).getActivePage(); |
| ISelection selection = new StructuredSelection(base); |
| |
| // ProcessEditorInput input = new ProcessEditorInput( |
| // (MethodElement) proc.eContainer()); |
| // input.setInitialSelection(selection); |
| // input.setActivePage(id); |
| // |
| // ProcessEditor editor = (ProcessEditor) |
| // getPage().findEditor(input); |
| // if(editor != null) { |
| // // select the base activity after the editor is opened |
| // // |
| // Viewer viewer = editor.bsPages[id].getViewer(); |
| // getPage().activate(editor); |
| // editor.setActivePage(id); |
| // viewer.setSelection(selection, true); |
| // } |
| // else { |
| // editor = (ProcessEditor) getPage().openEditor(input, |
| // EDITOR_ID); |
| // } |
| |
| IEditorInput input = new MethodElementEditorInput( |
| (MethodElement) proc.eContainer()); |
| ProcessEditor editor = (ProcessEditor) getPage() |
| .openEditor(input, EDITOR_ID); |
| editor.setActivePage(id); |
| editor.bsPages[id - 1].getViewer().setSelection(selection, |
| true); |
| } catch (PartInitException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| }; |
| |
| private IAction openWorkflowEditorAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenActivityDiagram) { |
| public void run() { |
| try { |
| try { |
| IEditorPart parent = getPage().getActiveEditor(); |
| IEditorInput input = new GraphicalWorkflowEditor.EditorInput( |
| selectedObject, getSuppression()); |
| IEditorPart part = getPage().openEditor(input, |
| WORKFLOW_EDITOR_ID); |
| if (part instanceof AbstractDiagramEditor) { |
| AbstractDiagramEditor editor = (AbstractDiagramEditor) part; |
| editor.setParentEditor(parent); |
| } |
| } catch (PartInitException exception) { |
| AuthoringUIPlugin.getDefault().getLogger().logError( |
| exception); |
| } |
| } catch (RuntimeException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| }; |
| private IAction newActivityDiagramEditor = new Action(AuthoringUIResources. |
| ProcessEditor_Action_OpenActivityDiagram |
| ) { |
| public void run() { |
| openDiagram(IDiagramManager.ACTIVITY_DIAGRAM); |
| } |
| }; |
| |
| private IAction newActivityDetailDiagramEditor = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenActivityDetailDiagram) { |
| public void run() { |
| openDiagram(IDiagramManager.ACTIVITY_DETAIL_DIAGRAM); |
| } |
| }; |
| |
| private IAction newWPDiagramEditor = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenWorkProductDependencyDiagram) { |
| public void run() { |
| openDiagram(IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM); |
| } |
| }; |
| |
| // Open workflow detail action |
| // |
| private IAction openWorkflowDetailEditorAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenActivityDetailDiagram) { |
| public void run() { |
| try { |
| try { |
| IEditorPart parent = getPage().getActiveEditor(); |
| IEditorInput input = new ActivityDetailDiagramEditor.EditorInput( |
| selectedObject, getSuppression()); |
| IEditorPart part = getPage().openEditor(input, |
| ACTIVITY_DETAIL_DIAGRAM_EDITOR_ID); |
| if (part instanceof AbstractDiagramEditor) { |
| AbstractDiagramEditor editor = (AbstractDiagramEditor) part; |
| editor.setParentEditor(parent); |
| } |
| } catch (PartInitException exception) { |
| exception.printStackTrace(); |
| } |
| } catch (RuntimeException e) { |
| e.printStackTrace(); |
| } |
| |
| } |
| }; |
| |
| private IAction openWPDependencyEditorAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_OpenWorkProductDependencyDiagram) { |
| public void run() { |
| try { |
| try { |
| IEditorPart parent = getPage().getActiveEditor(); |
| MethodElementEditorInput input = new BreakdownElementEditorInput( |
| selectedObject, getSuppression()) { |
| }; |
| IEditorPart part = getPage().openEditor(input, |
| WPDEPENDENCY_EDITOR_ID); |
| if (part instanceof AbstractDiagramEditor) { |
| AbstractDiagramEditor editor = (AbstractDiagramEditor) part; |
| editor.setParentEditor(parent); |
| } |
| } catch (PartInitException exception) { |
| exception.printStackTrace(); |
| } |
| } catch (RuntimeException e) { |
| e.printStackTrace(); |
| } |
| } |
| }; |
| |
| private IAction replaceAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Replace) { |
| public void run() { |
| IResourceAwareCommand cmd = null; |
| try { |
| cmd = new ReplaceActivityCommand( |
| (BreakdownElementWrapperItemProvider) bsItemProvider); |
| getActionManager().execute(cmd); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } finally { |
| if (cmd != null) { |
| try { |
| cmd.dispose(); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } |
| } |
| } |
| } |
| }; |
| |
| private IAction localReplacementAndDeepCopy = new Action( |
| LibraryEditResources.localReplacementAndDeepCopy_text) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| Runnable runnable = new Runnable() { |
| |
| public void run() { |
| IResourceAwareCommand cmd = null; |
| try { |
| cmd = new LocallyReplaceAndDeepCopyCommand( |
| (BreakdownElementWrapperItemProvider) bsItemProvider); |
| getActionManager().execute(cmd); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } finally { |
| if (cmd != null) { |
| try { |
| cmd.dispose(); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } |
| } |
| } |
| } |
| |
| }; |
| |
| UserInteractionHelper.runInUI(runnable, getText()); |
| } |
| }; |
| |
| private IAction contributeAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Contribute) { |
| public void run() { |
| IResourceAwareCommand cmd = null; |
| try { |
| cmd = new ContributeToActivityCommand( |
| (BreakdownElementWrapperItemProvider) bsItemProvider); |
| getActionManager().execute(cmd); |
| // ProcessUtil.contributeToActivity((BreakdownElementWrapperItemProvider)bsItemProvider, |
| // ((ProcessFormEditor)activeEditor).editingDomain.getAdapterFactory()); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } finally { |
| if (cmd != null) { |
| try { |
| cmd.dispose(); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } |
| } |
| } |
| } |
| }; |
| |
| private class EditorSuppressionCommand extends SuppressionCommand { |
| EditorSuppressionCommand(Suppression suppression, List selection, |
| boolean suppressed) { |
| super(suppression, selection, suppressed); |
| } |
| |
| private void refresh() { |
| if (!getResult().isEmpty()) { |
| ProcessEditor editor = (ProcessEditor) getActiveEditor(); |
| if (isReadOnlyElementAffected()) { |
| if (hasInherited(selection)) { |
| editor.refreshAllProcessEditors(); |
| } else { |
| editor.doRefreshAll(false); |
| } |
| } |
| editor.firePropertyChange(PROP_DIRTY); |
| |
| // Do Diagram Editors refresh |
| List list = new ArrayList(); |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| UIHelper.closeDiagramEditors(element, list); |
| UIHelper.refreshOpenDiagramEditorsOfParent(element, list); |
| list.clear(); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand#didExecute() |
| */ |
| protected void didExecute() { |
| refresh(); |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand#didUndo() |
| */ |
| protected void didUndo() { |
| refresh(); |
| } |
| |
| } |
| |
| private IAction suppressTaskAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Suppress_Task) { |
| |
| public void run() { |
| // check if suppressing the selected elements will cause |
| // duplicate descriptors. |
| // If so, prompt user to delete the duplicates before |
| // continuing. |
| // |
| |
| final List taskDescriptors = ProcessUtil.getTaskDescriptors(selection); |
| Collection duplicates = ProcessUtil |
| .getDuplicateDescriptorsAfterSuppress(taskDescriptors); |
| if (!duplicates.isEmpty()) { |
| MultiStatus status = new MultiStatus(AuthoringUIPlugin |
| .getDefault().getId(), 0, "", null); //$NON-NLS-1$ |
| for (Iterator iter = duplicates.iterator(); iter.hasNext();) { |
| Descriptor desc = (Descriptor) iter.next(); |
| String descTxt = TngUtil.getTypeText(desc) |
| + ": " + desc.getPresentationName(); //$NON-NLS-1$ |
| status.add(new Status(IStatus.INFO, AuthoringUIPlugin |
| .getDefault().getId(), 0, descTxt, null)); |
| } |
| if (AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| getText(), |
| AuthoringUIResources.ProcessEditor_promptToDeleteBeforeSuppress, |
| status) == Dialog.CANCEL) { |
| return; |
| } |
| |
| // delete duplicate descriptors |
| Command cmd = null; |
| try { |
| cmd = ProcessDeleteAction.delete(duplicates); |
| } catch (OperationCanceledException e) { |
| return; |
| } |
| finally { |
| if(cmd != null) |
| try { cmd.dispose(); } catch(Exception e) {} |
| } |
| } |
| |
| BusyIndicator.showWhile(getActiveEditor().getEditorSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| EditorSuppressionCommand cmd = new EditorSuppressionCommand( |
| getSuppression(), taskDescriptors, true); |
| cmd.setLabel(getText()); |
| getActionManager().execute(cmd); |
| } |
| }); |
| |
| boolean show = true; |
| // update context bar menu after performing suppress |
| if (getAdapterFactory() == TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory()) { |
| for (int i = 0; i < selection.size(); i++) { |
| if (!(selection.get(i) instanceof Activity || selection |
| .get(i) instanceof ActivityWrapperItemProvider)) |
| show = false; |
| } |
| } else |
| show = false; |
| |
| revealTaskAction.setEnabled(show); |
| suppressTaskAction.setEnabled(show); |
| |
| // enable synchronize actions correctly |
| autoSynchronize.setEnabled(autoSynchronize |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| manualSynchronizeAction.setEnabled(manualSynchronizeAction |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| } |
| }; |
| |
| private IAction suppressAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Suppress) { |
| |
| public void run() { |
| // check if suppressing the selected elements will cause |
| // duplicate descriptors. |
| // If so, prompt user to delete the duplicates before |
| // continuing. |
| // |
| Collection duplicates = ProcessUtil |
| .getDuplicateDescriptorsAfterSuppress(selection); |
| if (!duplicates.isEmpty()) { |
| MultiStatus status = new MultiStatus(AuthoringUIPlugin |
| .getDefault().getId(), 0, "", null); //$NON-NLS-1$ |
| for (Iterator iter = duplicates.iterator(); iter.hasNext();) { |
| Descriptor desc = (Descriptor) iter.next(); |
| String descTxt = TngUtil.getTypeText(desc) |
| + ": " + desc.getPresentationName(); //$NON-NLS-1$ |
| status.add(new Status(IStatus.INFO, AuthoringUIPlugin |
| .getDefault().getId(), 0, descTxt, null)); |
| } |
| if (AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| getText(), |
| AuthoringUIResources.ProcessEditor_promptToDeleteBeforeSuppress, |
| status) == Dialog.CANCEL) { |
| return; |
| } |
| |
| // delete duplicate descriptors |
| Command cmd = null; |
| try { |
| cmd = ProcessDeleteAction.delete(duplicates); |
| } catch (OperationCanceledException e) { |
| return; |
| } |
| finally { |
| if(cmd != null) |
| try { cmd.dispose(); } catch(Exception e) {} |
| } |
| } |
| |
| // final ProcessEditor editor = (ProcessEditor) |
| // getActiveEditor(); |
| |
| BusyIndicator.showWhile(getActiveEditor().getEditorSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| // if (getSuppression().suppress(selection)) { |
| // if (hasInherited(selection)) { |
| // editor.refreshAllProcessEditors(); |
| // } else { |
| // editor.doRefreshAll(false); |
| // } |
| // } |
| // editor.firePropertyChange(PROP_DIRTY); |
| |
| EditorSuppressionCommand cmd = new EditorSuppressionCommand( |
| getSuppression(), selection, true); |
| cmd.setLabel(getText()); |
| getActionManager().execute(cmd); |
| } |
| |
| }); |
| |
| // update context bar menu after performing suppress |
| revealAction.setEnabled(getSuppression().canReveal(selection)); |
| suppressAction.setEnabled(getSuppression().canSuppress( |
| selection)); |
| |
| // enable synchronize actions correctly |
| autoSynchronize.setEnabled(autoSynchronize |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| manualSynchronizeAction.setEnabled(manualSynchronizeAction |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| } |
| }; |
| |
| private UpdateSuppressionFromBaseAction updateSuppressionFromBaseAction = new UpdateSuppressionFromBaseAction(); |
| |
| private IAction revealAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Reveal) { |
| |
| public void run() { |
| if (canReveal(selection, getAdapterFactory(), getSuppression())) { |
| // final ProcessEditor editor = (ProcessEditor) |
| // getActiveEditor(); |
| |
| BusyIndicator.showWhile(getActiveEditor().getEditorSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| // if (getSuppression().reveal(selection)) { |
| // if (hasInherited(selection)) { |
| // editor.refreshAllProcessEditors(); |
| // } else { |
| // editor.doRefreshAll(false); |
| // } |
| // } |
| // editor.firePropertyChange(PROP_DIRTY); |
| |
| EditorSuppressionCommand cmd = new EditorSuppressionCommand( |
| getSuppression(), selection, false); |
| cmd.setLabel(getText()); |
| getActionManager().execute(cmd); |
| } |
| |
| }); |
| // update context bar menu after performing reveal |
| revealAction.setEnabled(getSuppression().canReveal( |
| selection)); |
| suppressAction.setEnabled(getSuppression().canSuppress( |
| selection)); |
| // enable synchronize actions correctly |
| autoSynchronize.setEnabled(autoSynchronize |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| manualSynchronizeAction.setEnabled(manualSynchronizeAction |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| } |
| } |
| }; |
| |
| private IAction revealTaskAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Reveal_Task) { |
| |
| public void run() { |
| final List taskDescriptors = ProcessUtil.getTaskDescriptors(selection); |
| if (canReveal(taskDescriptors, getAdapterFactory(), getSuppression())) { |
| |
| BusyIndicator.showWhile(getActiveEditor().getEditorSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| EditorSuppressionCommand cmd = new EditorSuppressionCommand( |
| getSuppression(), taskDescriptors, false); |
| cmd.setLabel(getText()); |
| getActionManager().execute(cmd); |
| } |
| |
| }); |
| |
| // enable synchronize actions correctly |
| autoSynchronize.setEnabled(autoSynchronize |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| manualSynchronizeAction.setEnabled(manualSynchronizeAction |
| .updateSelection(new StructuredSelection(selection |
| .toArray()))); |
| } |
| } |
| }; |
| |
| private IBSItemProvider bsItemProvider = null; |
| |
| private Object selectedElement = null; |
| |
| private Activity selectedActivity = null; |
| |
| private BreakdownElement selectedBreakdownElement = null; |
| |
| private List selection; |
| |
| private IAction suppressDiagramAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Suppress2) { |
| public boolean isEnabled() { |
| if (!super.isEnabled()) { |
| return false; |
| } |
| return !(bsItemProvider instanceof BreakdownElementWrapperItemProvider && ((BreakdownElementWrapperItemProvider) bsItemProvider) |
| .isReadOnly()); |
| } |
| |
| public void run() { |
| if (!promptSaveActiveEditor()) { |
| return; |
| } |
| |
| IStructuredContentProvider contentProvider = new ArrayContentProvider(); |
| |
| ILabelProvider labelProvider = new AdapterFactoryLabelProvider( |
| TngUtil.umaItemProviderAdapterFactory) { |
| public String getColumnText(Object object, int columnIndex) { |
| return GraphicalDataHelper |
| .getDiagramTypeText((Diagram) object); |
| } |
| }; |
| |
| Collection diagrams = GraphicalDataHelper |
| .getDiagrams(selectedActivity); |
| ArrayList unsuppressedDiagrams = new ArrayList(); |
| for (Iterator iter = diagrams.iterator(); iter.hasNext();) { |
| Diagram diagram = (Diagram) iter.next(); |
| if (!diagram.getSuppressed().booleanValue()) { |
| unsuppressedDiagrams.add(diagram); |
| } |
| } |
| |
| ListSelectionDialog dlg = new ListSelectionDialog( |
| activeEditor.getEditorSite().getShell(), |
| diagrams, |
| contentProvider, |
| labelProvider, |
| AuthoringUIResources.ProcessEditor_SuppressDialog_Message); |
| dlg.setInitialElementSelections(unsuppressedDiagrams); |
| dlg |
| .setTitle(AuthoringUIResources.ProcessEditor_SuppressDialog_Title); |
| dlg.setBlockOnOpen(true); |
| dlg.open(); |
| |
| Object[] diagramsToReveal = dlg.getResult(); |
| |
| if (diagramsToReveal == null) { |
| return; |
| } |
| |
| boolean changed = true; |
| |
| // check if there is really any change |
| // |
| if (diagramsToReveal.length == unsuppressedDiagrams.size()) { |
| for (int i = 0; i < diagramsToReveal.length; i++) { |
| if (!unsuppressedDiagrams.contains(diagramsToReveal[i])) { |
| changed = false; |
| break; |
| } |
| } |
| } |
| |
| if (changed) { |
| for (Iterator iter = diagrams.iterator(); iter.hasNext();) { |
| Diagram diagram = (Diagram) iter.next(); |
| diagram.setSuppressed(Boolean.TRUE); |
| } |
| |
| for (int i = 0; i < diagramsToReveal.length; i++) { |
| Diagram diagram = (Diagram) diagramsToReveal[i]; |
| diagram.setSuppressed(Boolean.FALSE); |
| } |
| |
| // save the editor |
| // |
| saveActiveEditor(); |
| } |
| } |
| }; |
| |
| |
| |
| private IAction newSuppressDiagramAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Suppress2) { |
| public boolean isEnabled() { |
| if (!super.isEnabled()) { |
| return false; |
| } |
| return !(bsItemProvider instanceof BreakdownElementWrapperItemProvider && ((BreakdownElementWrapperItemProvider) bsItemProvider) |
| .isReadOnly()); |
| } |
| |
| public void run() { |
| if (!promptSaveActiveEditor()) { |
| return; |
| } |
| |
| IStructuredContentProvider contentProvider = new ArrayContentProvider(); |
| |
| ILabelProvider labelProvider = new AdapterFactoryLabelProvider( |
| TngUtil.umaItemProviderAdapterFactory) { |
| public String getColumnText(Object object, int columnIndex) { |
| //TODO: Change to exact string. |
| return DiagramHelper.getDiagramTypeString((org.eclipse.gmf.runtime.notation.Diagram)object); |
| } |
| }; |
| |
| Collection diagrams = DiagramHelper.getDiagrams(selectedActivity); |
| ArrayList unsuppressedDiagrams = new ArrayList(); |
| for (Iterator iter = diagrams.iterator(); iter.hasNext();) { |
| org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) iter.next(); |
| |
| //TODO: do get Unsuppressed list. |
| |
| // if (!diagram.getSuppressed().booleanValue()) { |
| // unsuppressedDiagrams.add(diagram); |
| // } |
| } |
| |
| ListSelectionDialog dlg = new ListSelectionDialog( |
| activeEditor.getEditorSite().getShell(), |
| diagrams, |
| contentProvider, |
| labelProvider, |
| AuthoringUIResources.ProcessEditor_SuppressDialog_Message); |
| dlg.setInitialElementSelections(unsuppressedDiagrams); |
| dlg |
| .setTitle(AuthoringUIResources.ProcessEditor_SuppressDialog_Title); |
| dlg.setBlockOnOpen(true); |
| dlg.open(); |
| |
| Object[] diagramsToReveal = dlg.getResult(); |
| |
| if (diagramsToReveal == null) { |
| return; |
| } |
| |
| boolean changed = true; |
| |
| // check if there is really any change |
| // |
| if (diagramsToReveal.length == unsuppressedDiagrams.size()) { |
| for (int i = 0; i < diagramsToReveal.length; i++) { |
| if (!unsuppressedDiagrams.contains(diagramsToReveal[i])) { |
| changed = false; |
| break; |
| } |
| } |
| } |
| |
| if (changed) { |
| for (Iterator iter = diagrams.iterator(); iter.hasNext();) { |
| org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) iter.next(); |
| //TODO: set Suppression. |
| //diagram.setSuppressed(Boolean.TRUE); |
| } |
| |
| for (int i = 0; i < diagramsToReveal.length; i++) { |
| org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) diagramsToReveal[i]; |
| //TODO: set Suppression. |
| //diagram.setSuppressed(Boolean.FALSE); |
| } |
| |
| // save the editor |
| // |
| saveActiveEditor(); |
| } |
| } |
| }; |
| |
| |
| private IAction newAssignUserDiagram = new Action( |
| AuthoringUIResources.ProcessEditor_Action_AssignUserDiagram) { |
| /** |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| //TODO: necessary changes UserDefinedDiagramDialog's DiagramInfo. |
| UserDefinedDiagramDialog dialog = new UserDefinedDiagramDialog( |
| Display.getCurrent().getActiveShell(), activeEditor, |
| selectedActivity, getProcess().getDefaultContext(), TngUtil.isWrapped(selectedObject)); |
| dialog.open(); |
| } |
| }; |
| |
| private IAction newSuppressAllDiagrams = new Action( |
| AuthoringUIResources.ProcessEditor_Action_SuppressAll) { |
| public void run() { |
| newSetAllDiagramSuppressed(true); |
| } |
| }; |
| |
| private IAction newRevealAllDiagrams = new Action( |
| AuthoringUIResources.ProcessEditor_Action_RevealAll) { |
| public void run() { |
| newSetAllDiagramSuppressed(false); |
| } |
| }; |
| |
| |
| |
| private IAction suppressAllDiagrams = new Action( |
| AuthoringUIResources.ProcessEditor_Action_SuppressAll) { |
| public void run() { |
| setAllDiagramSuppressed(true); |
| } |
| }; |
| |
| private IAction revealAllDiagrams = new Action( |
| AuthoringUIResources.ProcessEditor_Action_RevealAll) { |
| public void run() { |
| setAllDiagramSuppressed(false); |
| } |
| }; |
| |
| private IAction addAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Add) { |
| public void run() { |
| LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner(); |
| runner.run(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| AdapterFactory adapterFactory = getAdapterFactory(); |
| if (adapterFactory != null) { |
| MethodConfiguration config = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| if (config == null) { |
| config = TngUtil.getOwningProcess( |
| selectedBreakdownElement).getDefaultContext(); |
| } |
| List selection = DialogHelper.selectElementsFor( |
| selectedBreakdownElement, config, adapterFactory); |
| |
| if (selection == null || selection.isEmpty()) { |
| return; |
| } |
| |
| Object adapter = adapterFactory.adapt( |
| selectedBreakdownElement, |
| IEditingDomainItemProvider.class); |
| if (adapter instanceof IBSItemProvider) { |
| IResourceAwareCommand cmd = ((IBSItemProvider) adapter) |
| .createDropCommand(selectedBreakdownElement, |
| selection); |
| getActionManager().execute(cmd); |
| } |
| } |
| } |
| |
| }); |
| |
| } |
| }; |
| |
| private IAction copyActivityAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Copy) { |
| public void run() { |
| MethodConfiguration config = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| if (config == null) { |
| config = TngUtil.getOwningProcess(selectedActivity) |
| .getDefaultContext(); |
| } |
| List selection = DialogHelper.selectActivitiesFor( |
| selectedActivity, config, IActionTypeProvider.COPY); |
| |
| if (selection == null || selection.isEmpty()) { |
| return; |
| } else { |
| for (Iterator itor=selection.iterator(); itor.hasNext();) { |
| Object o = itor.next(); |
| |
| if (o instanceof Activity) { |
| Activity act = (Activity) o; |
| |
| // Process proc = TngUtil.getOwningProcess(selectedBreakdownElement); |
| // if (DependencyChecker.hasCyclicDependency(act, proc)) { |
| // Object[] args = { selectedActivity.getName(), |
| // act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.apply_pattern_error_msg, |
| // args); |
| // |
| // String title = AuthoringUIResources.apply_pattern_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // itor.remove(); |
| // } |
| // else if (ProcessUtil.hasContributorOrReplacer(act)) { |
| // Object[] args = { selectedActivity.getName(), |
| // act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.activity_variability_error_msg, |
| // args); |
| // |
| // String title = AuthoringUIResources.activity_variability_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // |
| // itor.remove(); |
| // return; |
| // } |
| |
| IStatus status = DependencyChecker.checkCircularDependency(act, selectedActivity); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, status.getMessage()); |
| itor.remove(); |
| } |
| } |
| if(selection.isEmpty()) { |
| return; |
| } |
| } |
| } |
| |
| ActivityDropCommand cmd = new ActivityDropCommand( |
| selectedActivity, selection, null, getAdapterFactory()); |
| IStatus status = cmd.checkCopy(); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, status.getMessage()); |
| return; |
| } |
| cmd.setType(IActionTypeProvider.COPY); |
| getActionManager().execute(cmd); |
| } |
| }; |
| |
| private IAction extendActivityAction = new Action( |
| AuthoringUIResources.ProcessEditor_Action_Extend) { |
| public void run() { |
| MethodConfiguration config = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| if (config == null) { |
| config = TngUtil.getOwningProcess(selectedActivity) |
| .getDefaultContext(); |
| } |
| List selection = DialogHelper.selectActivitiesFor( |
| selectedActivity, config, IActionTypeProvider.EXTEND); |
| |
| if (selection == null || selection.isEmpty()) { |
| return; |
| } |
| else { |
| for (Iterator itor=selection.iterator(); itor.hasNext();) { |
| Object o = itor.next(); |
| |
| if (o instanceof Activity) { |
| Activity act = (Activity) o; |
| |
| // Process proc = TngUtil.getOwningProcess(selectedBreakdownElement); |
| // if (DependencyChecker.hasCyclicDependency(act, proc)) { |
| // Object[] args = { selectedActivity.getName(), |
| // act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.apply_pattern_error_msg, |
| // args); |
| // |
| // String title = AuthoringUIResources.apply_pattern_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // itor.remove(); |
| // } |
| // else if (ProcessUtil.hasContributorOrReplacer(act)) { |
| // Object[] args = { selectedActivity.getName(), |
| // act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.activity_variability_error_msg, |
| // args); |
| // |
| // String title = AuthoringUIResources.activity_variability_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // |
| // itor.remove(); |
| // return; |
| // } |
| |
| IStatus status = DependencyChecker.newCheckAct ? |
| DependencyChecker.checkCircularDependencyAfterFilterSelection |
| (act, selectedActivity, VariabilityType.EXTENDS_LITERAL) |
| : DependencyChecker.checkCircularDependency(act, selectedActivity); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, status); |
| itor.remove(); |
| } |
| } |
| if(selection.isEmpty()) { |
| return; |
| } |
| } |
| } |
| ActivityDropCommand cmd = new ActivityDropCommand( |
| selectedActivity, selection, null, getAdapterFactory()); |
| IStatus status = cmd.checkExtend(); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, status.getMessage()); |
| return; |
| } |
| cmd.setType(IActionTypeProvider.EXTEND); |
| getActionManager().execute(cmd); |
| } |
| }; |
| |
| private IAction deepCopyActivityAction = new Action( |
| AuthoringUIResources.ProcessEditor_action_deepCopy) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner(); |
| runner.run(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| MethodConfiguration config = LibraryService |
| .getInstance().getCurrentMethodConfiguration(); |
| if (config == null) { |
| config = TngUtil.getOwningProcess(selectedActivity) |
| .getDefaultContext(); |
| } |
| List selection = DialogHelper.selectActivitiesFor( |
| selectedActivity, config, |
| IActionTypeProvider.DEEP_COPY); |
| |
| if (selection == null || selection.isEmpty()) { |
| return; |
| } |
| else { |
| for (Iterator itor=selection.iterator(); itor.hasNext();) { |
| Object o = itor.next(); |
| |
| if (o instanceof Activity) { |
| Activity act = (Activity) o; |
| |
| // Process proc = TngUtil.getOwningProcess(selectedBreakdownElement); |
| // if (ProcessUtil.hasCyclicDependency(act, proc)) { |
| // Object[] args = { selectedActivity.getName(), |
| // act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.apply_pattern_error_msg, |
| // args); |
| // |
| // String title = AuthoringUIResources.apply_pattern_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // itor.remove(); |
| // } |
| |
| IStatus status = DependencyChecker.checkCircularDependency(act, selectedActivity); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, status.getMessage()); |
| itor.remove(); |
| } |
| } |
| if(selection.isEmpty()) { |
| return; |
| } |
| } |
| } |
| |
| ActivityDropCommand cmd = new ActivityDropCommand( |
| selectedActivity, selection, null, |
| getAdapterFactory()); |
| cmd.setType(IActionTypeProvider.DEEP_COPY); |
| getActionManager().execute(cmd); |
| |
| } |
| }); |
| } |
| }; |
| |
| private Object selectedObject; |
| |
| private IAction expandAllAction = new Action( |
| AuthoringUIResources.ProcessFormEditor_expanAllActionLabel) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| Viewer viewer = ((ProcessEditor) activeEditor).currentViewer; |
| if (viewer instanceof TreeViewer) { |
| ((TreeViewer) viewer).expandToLevel(selectedObject, |
| AbstractTreeViewer.ALL_LEVELS); |
| } |
| } |
| }; |
| |
| private IAction collapseAllAction = new Action( |
| AuthoringUIResources.ProcessFormEditor_collapseAllActionLabel) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| Viewer viewer = ((ProcessEditor) activeEditor).currentViewer; |
| if (viewer instanceof TreeViewer) { |
| ((TreeViewer) viewer).collapseToLevel(selectedObject, |
| AbstractTreeViewer.ALL_LEVELS); |
| } |
| } |
| }; |
| |
| private SynchronizationAction manualSynchronizeAction = new SynchronizationAction() { |
| public void run() { |
| super.run(); |
| |
| // refresh properties view after synch |
| EPFPropertySheetPage page = (EPFPropertySheetPage) ((ProcessEditor) activeEditor) |
| .getPropertySheetPage(); |
| if (page != null) { |
| page.refresh(); |
| } |
| } |
| }; |
| |
| private ProcessAutoSynchronizeAction autoSynchronize = new ProcessAutoSynchronizeAction() { |
| private void superRun() { |
| super.run(); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.ProcessAutoSynchronizeAction#run() |
| */ |
| public void run() { |
| LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner(); |
| runner.run(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| if (!AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| AuthoringUIResources.ProcessEditor_defaultSynchronization, |
| AuthoringUIResources.ProcessEditor_confirmAutoSynch)) { |
| return; |
| } |
| // ((SynchronizeCommand)command).setUIContext(getActiveEditor().getSite().getShell()); |
| superRun(); |
| |
| // refresh properties view after synch |
| EPFPropertySheetPage page = (EPFPropertySheetPage)((ProcessEditor) activeEditor).getPropertySheetPage(); |
| if (page != null) { |
| page.refresh(); |
| } |
| } |
| }); |
| |
| } |
| }; |
| |
| private IAction showInLibraryView = new Action( |
| AuthoringUIResources.ProcessEditor_Action_ShowLinkedElementinLibraryView, |
| AuthoringUIPlugin.getDefault().getImageDescriptor( |
| "full/etool16/show_linked_element.gif")) { //$NON-NLS-1$ //) |
| |
| public void run() { |
| final Object linkedElement = ProcessUtil |
| .getAssociatedElement((Descriptor) selectedBreakdownElement); |
| if (linkedElement != null) { |
| Display.getCurrent().asyncExec(new Runnable() { |
| |
| public void run() { |
| LibraryView.getView().setSelectionToViewer( |
| linkedElement); |
| } |
| |
| }); |
| } |
| } |
| |
| }; |
| |
| private IAction assignUserDiagram = new Action( |
| AuthoringUIResources.ProcessEditor_Action_AssignUserDiagram) { |
| /** |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| UserDefinedDiagramDialog dialog = new UserDefinedDiagramDialog( |
| Display.getCurrent().getActiveShell(), activeEditor, |
| selectedActivity, getProcess().getDefaultContext(), TngUtil.isWrapped(selectedObject)); |
| |
| dialog.open(); |
| } |
| }; |
| |
| // private IAction activityDetailDiagramInfo = new ActivityDetailDiagramInfoAction(){ |
| // public Object getObject() { |
| // return selectedActivity; |
| // } |
| // public IWorkbenchPage getPagex() { |
| // // TODO Auto-generated method stub |
| // return getPage(); |
| // } |
| // }; |
| |
| private boolean oldLocked; |
| |
| public BSActionBarContributor() { |
| super(AuthoringUIResources.ProcessEditor); |
| |
| // don't show validate action |
| // |
| validateAction = null; |
| |
| // set disabled image descriptors |
| moveUpAction.setDisabledImageDescriptor(AuthoringUIPlugin |
| .getDefault().getImageDescriptor( |
| "full/etool16/move_up_disabled.gif")); //$NON-NLS-1$ |
| moveDownAction.setDisabledImageDescriptor(AuthoringUIPlugin |
| .getDefault().getImageDescriptor( |
| "full/etool16/move_down_disabled.gif")); //$NON-NLS-1$ |
| showInLibraryView.setDisabledImageDescriptor(AuthoringUIPlugin |
| .getDefault().getImageDescriptor( |
| "full/etool16/show_linked_element_disabled.gif")); //$NON-NLS-1$ |
| } |
| |
| private static PreferencesHint getDiagramPreferencesHint(int diagramType) { |
| switch(diagramType) { |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| return EPFDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM: |
| return ActivityDetailDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM: |
| return WPDDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| } |
| return null; |
| } |
| |
| protected void openDiagram(int diagramType) { |
| try { |
| DiagramEditorInput input = new org.eclipse.epf.diagram.core.part.DiagramEditorInput( |
| selectedObject, getSuppression(), diagramType); |
| DiagramEditorUtil.openDiagramEditor(getPage(), input, getDiagramPreferencesHint(diagramType), new NullProgressMonitor()); |
| } catch (RuntimeException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| protected void registerAction(IAction action) { |
| if (action != null && !registeredActions.contains(action)) { |
| registeredActions.add(action); |
| } |
| } |
| |
| private void registerActions() { |
| registerAction(autoSynchronize); |
| registerAction(manualSynchronizeAction); |
| registerAction(updateSuppressionFromBaseAction); |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#update() |
| */ |
| public void update() { |
| super.update(); |
| |
| ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor |
| : activeEditor.getEditorSite().getSelectionProvider(); |
| ISelection selection = selectionProvider.getSelection(); |
| IStructuredSelection structuredSelection = selection instanceof IStructuredSelection ? (IStructuredSelection) selection |
| : StructuredSelection.EMPTY; |
| |
| for (Iterator iter = registeredActions.iterator(); iter.hasNext();) { |
| Object action = (Object) iter.next(); |
| if (action instanceof CommandActionHandler) { |
| ((CommandActionHandler) action) |
| .updateSelection(structuredSelection); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#activate() |
| */ |
| public void activate() { |
| manualSynchronizeAction.setProcess(getProcess()); |
| ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor |
| : activeEditor.getEditorSite().getSelectionProvider(); |
| for (Iterator iter = registeredActions.iterator(); iter.hasNext();) { |
| Object action = (Object) iter.next(); |
| if (action instanceof IWorkbenchPartAction) { |
| ((IWorkbenchPartAction) action) |
| .setActiveWorkbenchPart(activeEditor); |
| } |
| if (action instanceof ISelectionChangedListener) { |
| selectionProvider |
| .addSelectionChangedListener((ISelectionChangedListener) action); |
| } |
| } |
| super.activate(); |
| |
| // call set Active page explicitly in order to get correct action |
| // bars |
| setActivePage(activeEditor); |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#deactivate() |
| */ |
| public void deactivate() { |
| super.deactivate(); |
| |
| ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor |
| : activeEditor.getEditorSite().getSelectionProvider(); |
| |
| for (Iterator iter = registeredActions.iterator(); iter.hasNext();) { |
| Object action = (Object) iter.next(); |
| if (action instanceof IWorkbenchPartAction) { |
| ((IWorkbenchPartAction) action) |
| .setActiveWorkbenchPart(null); |
| } |
| if (action instanceof ISelectionChangedListener) { |
| selectionProvider |
| .removeSelectionChangedListener((ISelectionChangedListener) action); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor#init(org.eclipse.ui.IActionBars) |
| */ |
| public void init(IActionBars actionBars) { |
| super.init(actionBars); |
| registerActions(); |
| contributeToToolBar(actionBars.getToolBarManager()); |
| } |
| |
| private IActionManager getActionManager() { |
| return ((MethodElementEditor) activeEditor).getActionManager(); |
| } |
| |
| private AdapterFactory getAdapterFactory() { |
| return ((ProcessEditor) activeEditor).getAdapterFactory(); |
| } |
| |
| private void setAllDiagramSuppressed(final boolean suppressed) { |
| String title = AuthoringUIResources.processFormEditorSaveDialog_title; |
| String message = AuthoringUIResources.processFormEditorSaveDialog_message1; |
| |
| if (!AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayConfirmation(title, message)) { |
| return; |
| } |
| |
| BusyIndicator.showWhile(activeEditor.getEditorSite().getShell() |
| .getDisplay(), new Runnable() { |
| |
| public void run() { |
| GraphicalDataHelper.setAllDiagramSuppressed(getProcess(), |
| suppressed); |
| doSaveActiveEditor(); |
| } |
| |
| }); |
| } |
| |
| private void newSetAllDiagramSuppressed(final boolean suppressed) { |
| String title = AuthoringUIResources.processFormEditorSaveDialog_title; |
| String message = AuthoringUIResources.processFormEditorSaveDialog_message1; |
| |
| if (!AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayConfirmation(title, message)) { |
| return; |
| } |
| |
| BusyIndicator.showWhile(activeEditor.getEditorSite().getShell() |
| .getDisplay(), new Runnable() { |
| |
| public void run() { |
| DiagramHelper.setAllDiagramSuppressed(getProcess(), |
| suppressed); |
| doSaveActiveEditor(); |
| } |
| |
| }); |
| } |
| |
| |
| private boolean promptSaveActiveEditor() { |
| String title = AuthoringUIResources.processFormEditorSaveDialog_title; |
| String message = AuthoringUIResources.processFormEditorSaveDialog_message2; |
| if (activeEditor.isDirty()) { |
| return AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayConfirmation(title, message); |
| } |
| return true; |
| } |
| |
| private void saveActiveEditor() { |
| // save the editor |
| // |
| BusyIndicator.showWhile(activeEditor.getEditorSite().getShell() |
| .getDisplay(), new Runnable() { |
| |
| public void run() { |
| doSaveActiveEditor(); |
| } |
| |
| }); |
| } |
| |
| private void doSaveActiveEditor() { |
| ((ProcessEditor) activeEditor).resourcesToSave.add(getProcess() |
| .eResource()); |
| activeEditor.doSave(new NullProgressMonitor()); |
| } |
| |
| protected DeleteAction createDeleteAction() { |
| return new ProcessDeleteAction() { |
| protected void saveCurrentEditor() { |
| if (activeEditor.isDirty()) { |
| BusyIndicator.showWhile(activeEditor.getEditorSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| activeEditor.doSave(new NullProgressMonitor()); |
| } |
| |
| }); |
| } |
| } |
| |
| public void run() { |
| IFormPage activePage = ((ProcessEditor) activeEditor) |
| .getActivePageInstance(); |
| if (activePage != null) { |
| String id = activePage.getId(); |
| if (id == ProcessEditor.WBS_FORM_ID |
| || id == ProcessEditor.TA_FORM_ID |
| || id == ProcessEditor.WPBS_FORM_ID |
| || id == ProcessEditor.CONSOLIDATED_FORM_ID) { |
| // for all other pages, disable DELETE |
| super.run(); |
| } |
| } |
| } |
| }; |
| } |
| |
| protected CutAction createCutAction() { |
| return new CutAction() { |
| public boolean updateSelection(IStructuredSelection selection) { |
| return super.updateSelection(ProcessDeleteAction |
| .filterSelection(selection)); |
| } |
| }; |
| } |
| |
| protected PasteAction createPasteAction() { |
| return new PasteAction() { |
| public boolean updateSelection(IStructuredSelection selection) { |
| return super.updateSelection(ProcessDeleteAction |
| .filterSelection(selection)); |
| } |
| |
| /** |
| * Overrided to use ResourceAwarePasteFromClipboardCommand |
| * |
| * @see org.eclipse.emf.edit.ui.action.PasteAction#createCommand(java.util.Collection) |
| * @see org.eclipse.epf.library.edit.command.ResourceAwarePasteFromClipboardCommand |
| */ |
| public Command createCommand(Collection selection) { |
| if (selection.size() == 1) |
| { |
| return new ResourceAwarePasteFromClipboardCommand(domain, selection.iterator().next(), null, CommandParameter.NO_INDEX); |
| } |
| else |
| { |
| return UnexecutableCommand.INSTANCE; |
| } |
| } |
| }; |
| } |
| |
| protected CopyAction createCopyAction() { |
| return new CopyAction() { |
| |
| public void run() { |
| if (domain instanceof TraceableAdapterFactoryEditingDomain) { |
| ((TraceableAdapterFactoryEditingDomain) domain) |
| .resetCopyMaps(); |
| } |
| super.run(); |
| } |
| |
| }; |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#addGlobalActions(org.eclipse.jface.action.IMenuManager) |
| */ |
| protected void addGlobalActions(IMenuManager menuManager) { |
| super.addGlobalActions(menuManager); |
| menuManager.insertAfter( |
| "additions", new Separator("fixed-additions")); //$NON-NLS-1$ //$NON-NLS-2$ |
| // menuManager.insertBefore("fixed-additions", |
| // insertNewPhaseAction); |
| } |
| |
| public void contributeToToolBar(IToolBarManager toolBarManager) { |
| super.contributeToToolBar(toolBarManager); |
| |
| moveUpAction |
| .setToolTipText(AuthoringUIResources.ProcessEditor_Action_MoveUp); |
| moveDownAction |
| .setToolTipText(AuthoringUIResources.ProcessEditor_Action_MoveDown); |
| showInLibraryView |
| .setToolTipText(AuthoringUIResources.ProcessEditor_Action_ShowLinkedElementinLibraryView); |
| toolBarManager.add(moveUpAction); |
| toolBarManager.add(moveDownAction); |
| toolBarManager.add(showInLibraryView); |
| } |
| |
| /** |
| * @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface.action.IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| IFormPage activePage = ((ProcessEditor) activeEditor) |
| .getActivePageInstance(); |
| if (activePage instanceof ProcessBreakdownStructureFormPage |
| && ((ProcessBreakdownStructureFormPage) activePage) |
| .basicIsReadOnly()) { |
| menuManager.add(new Separator( |
| IWorkbenchActionConstants.MB_ADDITIONS)); |
| menuManager.add(showInLibraryView); |
| if (bsItemProvider != null |
| // && ((ITreeItemContentProvider) |
| // bsItemProvider).hasChildren(selectedObject) |
| ) { |
| menuManager.add(expandAllAction); |
| menuManager.add(collapseAllAction); |
| } |
| menuManager.add(new Separator()); |
| refreshViewerAction.setEnabled(refreshViewerAction.isEnabled()); |
| menuManager.add(refreshViewerAction); |
| menuManager.add(showPropertiesViewAction); |
| return; |
| } |
| |
| ISelectionProvider selectionProvider = (ISelectionProvider) activeEditor; |
| |
| if (selectedActivity == null |
| && (selectionProvider.getSelection() == null || selectionProvider |
| .getSelection().isEmpty())) { |
| // fake a selection change event with the process selected if no |
| // element is selected yet. |
| // |
| selectionChanged(new SelectionChangedEvent(selectionProvider, |
| new StructuredSelection(getProcess()))); |
| } |
| // disable all new action if it's rolled up |
| boolean isRolledUP = bsItemProvider != null |
| && bsItemProvider.isRolledUp(); |
| super.setEnabled(!isRolledUP); |
| super.menuAboutToShow(menuManager); |
| |
| // add markers |
| // |
| menuManager.insertAfter("fixed-additions", new Separator("preference")); //$NON-NLS-1$ //$NON-NLS-2$ |
| menuManager.appendToGroup("preference", preferenceAction); //$NON-NLS-1$ |
| |
| menuManager.insertAfter("fixed-additions", new Separator("open")); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| if (bsItemProvider instanceof BreakdownElementWrapperItemProvider |
| && TngUtil.unwrap(bsItemProvider) instanceof Activity) { |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, contributeAction); |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, replaceAction); |
| menuManager.insertBefore( |
| IWorkbenchActionConstants.MB_ADDITIONS, localReplacementAndDeepCopy); |
| } |
| |
| if (!isRolledUP) { |
| if (createChildActions != null && !createChildActions.isEmpty()) { |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, addAction); |
| } |
| } |
| |
| suppressTaskAction.setEnabled(!isRolledUP && suppressTaskAction.isEnabled()); |
| revealTaskAction.setEnabled(!isRolledUP && revealTaskAction.isEnabled()); |
| if (revealAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", revealAction); //$NON-NLS-1$ |
| } |
| if (revealTaskAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", revealTaskAction); //$NON-NLS-1$ |
| } |
| if (suppressAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", suppressAction); //$NON-NLS-1$ |
| } |
| if (suppressTaskAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", suppressTaskAction); //$NON-NLS-1$ |
| } |
| if (updateSuppressionFromBaseAction.isEnabled()) { |
| menuManager.insertBefore( |
| "fixed-additions", updateSuppressionFromBaseAction); //$NON-NLS-1$ |
| } |
| |
| if ((selectedBreakdownElement != null) && (bsItemProvider != null)) { |
| if (moveUpAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", moveUpAction); //$NON-NLS-1$ |
| } |
| if (moveDownAction.isEnabled()) { |
| menuManager.insertBefore("fixed-additions", moveDownAction); //$NON-NLS-1$ |
| } |
| } |
| |
| menuManager.appendToGroup("open", showInLibraryView); //$NON-NLS-1$ |
| |
| if ((selectedActivity != null) && (bsItemProvider != null)) { |
| if (bsItemProvider.isRolledUp()) { |
| rollupAction |
| .setText(AuthoringUIResources.ProcessEditor_Action_RollDown); |
| } else { |
| rollupAction |
| .setText(AuthoringUIResources.ProcessEditor_Action_RollUp); |
| } |
| menuManager.appendToGroup("open", rollupAction); //$NON-NLS-1$ |
| } |
| |
| if (selectedObject instanceof Activity) { |
| // "Reuse" menu |
| // |
| MenuManager reuseSubMenu = new MenuManager( |
| AuthoringUIResources.ProcessEditor_Action_ApplyPattern); |
| reuseSubMenu.add(copyActivityAction); |
| reuseSubMenu.add(extendActivityAction); |
| reuseSubMenu.add(deepCopyActivityAction); |
| |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, reuseSubMenu); |
| } |
| |
| if (autoSynchronize.isEnabled()) { |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, autoSynchronize); |
| } |
| if (manualSynchronizeAction.isEnabled()) { |
| menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS, manualSynchronizeAction); |
| } |
| |
| if (!(selectedElement instanceof Milestone)) { |
| MenuManager diagramSubMenu = new MenuManager( |
| AuthoringUIResources.ProcessEditor_Action_Diagrams); |
| if (selectedActivity != null) { |
| if (selectedActivity.getVariabilityBasedOnElement() != null) { |
| menuManager.appendToGroup("open", openBaseActivity); //$NON-NLS-1$ |
| } |
| |
| diagramSubMenu.add(openWorkflowEditorAction); |
| diagramSubMenu.add(openWorkflowDetailEditorAction); |
| diagramSubMenu.add(openWPDependencyEditorAction); |
| diagramSubMenu.add(suppressDiagramAction); |
| diagramSubMenu.add(assignUserDiagram); |
| } |
| if (selectedActivity == getProcess()) { |
| diagramSubMenu.add(suppressAllDiagrams); |
| diagramSubMenu.add(revealAllDiagrams); |
| } |
| // Enable this code if ActivityDetailDiagramInfoDialog is need. |
| // if(selectedActivity != null){ |
| // diagramSubMenu.add(new Separator()); |
| // diagramSubMenu.add(activityDetailDiagramInfo); |
| // } |
| menuManager.appendToGroup("open", diagramSubMenu); //$NON-NLS-1$ |
| |
| MenuManager newDiagramSubMenu = new MenuManager( |
| "New Diagrams"); //$NON-NLS-1$ |
| if(selectedActivity != null){ |
| newDiagramSubMenu.add(newActivityDiagramEditor); |
| newDiagramSubMenu.add(newActivityDetailDiagramEditor); |
| newDiagramSubMenu.add(newWPDiagramEditor); |
| newDiagramSubMenu.add(newSuppressDiagramAction); |
| newDiagramSubMenu.add(newAssignUserDiagram); |
| |
| } |
| |
| if (selectedActivity == getProcess()) { |
| newDiagramSubMenu.add(newSuppressAllDiagrams); |
| newDiagramSubMenu.add(newRevealAllDiagrams); |
| } |
| menuManager.appendToGroup("open", newDiagramSubMenu); //$NON-NLS-1$ |
| } |
| |
| if (bsItemProvider != null |
| // this is an expensive check, removed it |
| // |
| // && ((ITreeItemContentProvider) |
| // bsItemProvider).hasChildren(selectedObject) |
| ) { |
| menuManager.appendToGroup("open", expandAllAction); //$NON-NLS-1$ |
| menuManager.appendToGroup("open", collapseAllAction); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @return |
| */ |
| private Process getProcess() { |
| return ((ProcessComponent) ((MethodElementEditorInput) activeEditor |
| .getEditorInput()).getMethodElement()).getProcess(); |
| } |
| |
| private Suppression getSuppression() { |
| return ((ProcessEditor) activeEditor).suppression; |
| } |
| |
| private void depopulateDynamicMenuItems() { |
| // Remove any menu items for old selection. |
| // |
| if (createChildMenuManager != null) { |
| depopulateManager(createChildMenuManager, createChildActions); |
| } |
| if (createSiblingMenuManager != null) { |
| depopulateManager(createSiblingMenuManager, |
| createSiblingActions); |
| } |
| createChildActions = null; |
| createSiblingActions = null; |
| } |
| |
| /** |
| * Set action state to enabled or disabled |
| * |
| * @param locked |
| */ |
| private void setActionState() { |
| if (locked) { |
| // disable modifying actions |
| pasteAction.setEnabled(false); |
| cutAction.setEnabled(false); |
| deleteAction.setEnabled(false); |
| autoSynchronize.setEnabled(false); |
| manualSynchronizeAction.setEnabled(false); |
| updateSuppressionFromBaseAction.setEnabled(false); |
| } else if (!oldLocked) { |
| // update state of modifying actions |
| // |
| IStructuredSelection selection = (IStructuredSelection) selectionProvider |
| .getSelection(); |
| cutAction.setEnabled(cutAction.updateSelection(selection)); |
| pasteAction.setEnabled(pasteAction.updateSelection(selection)); |
| deleteAction |
| .setEnabled(deleteAction.updateSelection(selection)); |
| autoSynchronize.setEnabled(autoSynchronize |
| .updateSelection(selection)); |
| manualSynchronizeAction.setEnabled(manualSynchronizeAction |
| .updateSelection(selection)); |
| updateSuppressionFromBaseAction |
| .setEnabled(updateSuppressionFromBaseAction |
| .updateSelection(selection)); |
| } |
| |
| boolean enabled = !locked; |
| |
| addAction.setEnabled(enabled); |
| contributeAction.setEnabled(enabled); |
| |
| // state of these actions is set in updateActions() |
| // |
| // moveDownAction.setEnabled(enabled); |
| // moveUpAction.setEnabled(enabled); |
| // revealAction.setEnabled(enabled); |
| // suppressAction.setEnabled(enabled); |
| replaceAction.setEnabled(enabled); |
| localReplacementAndDeepCopy.setEnabled(enabled); |
| revealAllDiagrams.setEnabled(enabled); |
| suppressAllDiagrams.setEnabled(enabled); |
| suppressDiagramAction.setEnabled(enabled); |
| copyActivityAction.setEnabled(enabled); |
| extendActivityAction.setEnabled(enabled); |
| deepCopyActivityAction.setEnabled(enabled); |
| } |
| |
| protected Collection generateCreateChildActions(Collection descriptors, |
| ISelection selection) { |
| if (locked) { |
| return null; |
| } |
| return super.generateCreateChildActions(descriptors, selection); |
| } |
| |
| protected Collection generateCreateSiblingActions( |
| Collection descriptors, ISelection selection) { |
| if (locked) { |
| return null; |
| } |
| return super.generateCreateSiblingActions(descriptors, selection); |
| } |
| |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent) |
| */ |
| public void selectionChanged(SelectionChangedEvent event) { |
| ISelection sel = event.getSelection(); |
| if (sel instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) sel; |
| oldLocked = locked; |
| locked = ViewHelper.isLocked(structuredSelection); |
| |
| selection = ((IStructuredSelection) sel).toList(); |
| if (selection.size() == 1) { |
| selectedObject = ((IStructuredSelection) sel) |
| .getFirstElement(); |
| Object obj = TngUtil.unwrap(selectedObject); |
| super.selectionChanged(event); |
| selectedElement = obj; |
| if (obj instanceof Activity) { |
| selectedActivity = (Activity) obj; |
| } else { |
| // depopulateDynamicMenuItems(); |
| // bsItemProvider = null; |
| selectedActivity = null; |
| } |
| AdapterFactoryEditingDomain domain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) activeEditorPart) |
| .getEditingDomain(); |
| Object providerObj = domain.getAdapterFactory().adapt( |
| selectedObject, ITreeItemContentProvider.class); |
| if (providerObj instanceof IBSItemProvider) |
| bsItemProvider = (IBSItemProvider) providerObj; |
| |
| if (obj instanceof BreakdownElement) { |
| selectedBreakdownElement = (BreakdownElement) obj; |
| } else { |
| selectedBreakdownElement = null; |
| } |
| } else { |
| depopulateDynamicMenuItems(); |
| bsItemProvider = null; |
| selectedElement = null; |
| selectedActivity = null; |
| selectedBreakdownElement = null; |
| selectedObject = null; |
| } |
| |
| updateActions(); |
| |
| } else { |
| depopulateDynamicMenuItems(); |
| bsItemProvider = null; |
| selectedElement = null; |
| selectedActivity = null; |
| selectedBreakdownElement = null; |
| } |
| |
| // // test code |
| // // |
| // if(selectedActivity != null) { |
| // for (Iterator iter = |
| // selectedActivity.eClass().getEAllAttributes().iterator(); |
| // iter.hasNext();) { |
| // EAttribute attrib = (EAttribute) iter.next(); |
| // if(String.class.isAssignableFrom(attrib.getEAttributeType().getInstanceClass())) |
| // { |
| // List values = |
| // ConfigurationHelper.getStringAttribute(selectedActivity, attrib); |
| // System.out.println(); |
| // System.out.println(attrib.getName() + ": " + values); |
| // } |
| // } |
| // } |
| } |
| |
| /** |
| * Updates actions including enabling/disabling them based on selection |
| */ |
| private void updateActions() { |
| showInLibraryView |
| .setEnabled(selectedBreakdownElement instanceof Descriptor |
| && ProcessUtil |
| .getAssociatedElement((Descriptor) selectedBreakdownElement) != null); |
| |
| if (!locked && selection != null && !selection.isEmpty()) { |
| if (selection.size() == 1) { |
| if (getSuppression().canReveal(selection)) { |
| revealAction.setEnabled(true); |
| suppressAction.setEnabled(false); |
| } else if (getSuppression().canSuppress(selection)) { |
| suppressAction.setEnabled(true); |
| revealAction.setEnabled(false); |
| } else { |
| revealAction.setEnabled(false); |
| suppressAction.setEnabled(false); |
| } |
| } else { |
| revealAction.setEnabled(getSuppression().canReveal( |
| selection)); |
| suppressAction.setEnabled(getSuppression().canSuppress( |
| selection)); |
| } |
| |
| // Action Enable/Disable for Suppress Task/Reveal Task context menu |
| boolean show = true; |
| for (int i = 0; i < selection.size(); i++) { |
| if (getAdapterFactory() == TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory()) { |
| |
| if (!(selection.get(i) instanceof Activity || selection |
| .get(i) instanceof ActivityWrapperItemProvider)) { |
| show = false; |
| break; |
| } |
| } else |
| show = false; |
| } |
| if (show) { |
| List taskDescriptors = ProcessUtil.getTaskDescriptors(selection); |
| suppressTaskAction.setEnabled(getSuppression().canSuppress(taskDescriptors)); |
| revealTaskAction.setEnabled(getSuppression().canReveal(taskDescriptors)); |
| } |
| else { |
| suppressTaskAction.setEnabled(false); |
| revealTaskAction.setEnabled(false); |
| } |
| |
| // boolean hasInherited = false; |
| // for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| // Object item = iter.next(); |
| // if (item instanceof BreakdownElementWrapperItemProvider |
| // && ((BreakdownElementWrapperItemProvider) item) |
| // .isReadOnly()) { |
| // hasInherited = true; |
| // break; |
| // } |
| // } |
| // updateSuppressionFromBaseAction.setEnabled(hasInherited); |
| } else { |
| revealAction.setEnabled(false); |
| suppressAction.setEnabled(false); |
| suppressTaskAction.setEnabled(false); |
| revealTaskAction.setEnabled(false); |
| } |
| |
| if (!locked) { |
| refreshMoveButtonActions(); |
| } else { |
| moveUpAction.setEnabled(false); |
| moveDownAction.setEnabled(false); |
| } |
| |
| // Set Activity Detail Diagram Action enable state. |
| if (selectedObject instanceof Activity |
| || selectedObject instanceof ActivityWrapperItemProvider) |
| setActionStateForADD(); |
| |
| // change action state for locked plugin |
| setActionState(); |
| } |
| |
| public void setActivePage(IEditorPart part) { |
| if (this.activeEditor != null) { |
| int page = ((ProcessEditor) this.activeEditor).getActivePage(); |
| IActionBars actionBars = this.activeEditor.getEditorSite() |
| .getActionBars(); |
| |
| if (page == 0) { |
| actionBars.setGlobalActionHandler(ActionFactory.DELETE |
| .getId(), null); |
| actionBars.setGlobalActionHandler( |
| ActionFactory.CUT.getId(), null); |
| actionBars.setGlobalActionHandler(ActionFactory.COPY |
| .getId(), null); |
| actionBars.setGlobalActionHandler(ActionFactory.PASTE |
| .getId(), null); |
| actionBars.setGlobalActionHandler(ActionFactory.UNDO |
| .getId(), null); |
| actionBars.setGlobalActionHandler(ActionFactory.REDO |
| .getId(), null); |
| } else { |
| actionBars.setGlobalActionHandler(ActionFactory.DELETE |
| .getId(), deleteAction); |
| actionBars.setGlobalActionHandler( |
| ActionFactory.CUT.getId(), cutAction); |
| actionBars.setGlobalActionHandler(ActionFactory.COPY |
| .getId(), copyAction); |
| actionBars.setGlobalActionHandler(ActionFactory.PASTE |
| .getId(), pasteAction); |
| actionBars.setGlobalActionHandler(ActionFactory.UNDO |
| .getId(), undoAction); |
| actionBars.setGlobalActionHandler(ActionFactory.REDO |
| .getId(), redoAction); |
| } |
| actionBars.updateActionBars(); |
| } |
| } |
| |
| protected void doRefresh() { |
| // update IDs |
| // |
| AdapterFactory adapterFactory = getAdapterFactory(); |
| if (adapterFactory == TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory() |
| || adapterFactory == TngAdapterFactory.INSTANCE |
| .getProcessComposedAdapterFactory()) { |
| Process proc = getProcess(); |
| ProcessUtil.updateIDs(adapterFactory, proc); |
| ProcessUtil.refreshPredeccessorLists(adapterFactory, proc); |
| } |
| |
| super.doRefresh(); |
| } |
| |
| private void refreshMoveButtonActions() { |
| if ((selectedBreakdownElement != null) && (bsItemProvider != null)) { |
| moveUpAction.setEnabled(!bsItemProvider.isFirstElement(selectedBreakdownElement)); |
| moveDownAction.setEnabled(!bsItemProvider.isLastElement(selectedBreakdownElement)); |
| } |
| } |
| |
| /* |
| * Set Action state for Activity Detail Diagram in Context Menu on |
| * selection of Activity. If an Activity consist atleast one |
| * taskdescriptor and its primary performer in current configuration, |
| * then state is enabled else state is disabled in context menu (process |
| * editor). |
| */ |
| private void setActionStateForADD() { |
| |
| // set ADD Action state false |
| openWorkflowDetailEditorAction.setEnabled(false); |
| |
| // set AD Action state true always |
| openWorkflowEditorAction.setEnabled(true); |
| |
| // set WPD Diagram Menu Action state tru always |
| openWPDependencyEditorAction.setEnabled(true); |
| |
| if (selectedObject != null) { |
| |
| if (getSuppression().isSuppressed(selectedObject)) { |
| openWorkflowDetailEditorAction.setEnabled(false); |
| openWorkflowEditorAction.setEnabled(false); |
| openWPDependencyEditorAction.setEnabled(false); |
| return; |
| } |
| |
| Activity activity = null; |
| List list = new ArrayList(); |
| |
| if (selectedObject instanceof Activity) { |
| activity = selectedActivity; |
| } else if (selectedObject instanceof ActivityWrapperItemProvider) { |
| activity = (Activity) ((ActivityWrapperItemProvider) selectedObject) |
| .getValue(); |
| } |
| if (activity == null) |
| return; |
| |
| while (!activity.getVariabilityType().equals( |
| VariabilityType.NA_LITERAL)) { |
| |
| VariabilityElement ve = activity |
| .getVariabilityBasedOnElement(); |
| // If Activity is set to local contribution, |
| // need to get breakdown elements of local contributed |
| // activity + base activity. And base activity breakdown |
| // elements |
| // are collected after while loop ends) |
| // if (VariabilityType.CONTRIBUTES_LITERAL.equals(activity |
| // .getVariabilityType())) { |
| // list.addAll(activity.getBreakdownElements()); |
| // } |
| list.addAll(activity.getBreakdownElements()); |
| |
| if ((ve != null) && (ve instanceof Activity)) { |
| activity = (Activity) ve; |
| } else { |
| break; |
| } |
| } |
| |
| // For AD diagram menu option, if Base Activity donot have any |
| // AD diagram, donot show AD diagram option in context menu for |
| // readonly activity. |
| Diagram diagram = GraphicalDataManager.getInstance() |
| .getUMADiagram(activity, |
| GraphicalDataHelper.ACTIVITY_DIAGRAM, false); |
| if (diagram == null |
| && selectedObject instanceof ActivityWrapperItemProvider) { |
| openWorkflowEditorAction.setEnabled(false); |
| } |
| |
| // For WPD diagram menu option, if Base Activity donot have any |
| // WPD diagram, donot show WPD diagram option in context menu |
| // for readonly activity. |
| diagram = GraphicalDataManager.getInstance().getUMADiagram( |
| activity, |
| GraphicalDataHelper.WORK_PRODUCT_DEPENDENCY_DIAGRAM, |
| false); |
| if (diagram == null |
| && selectedObject instanceof ActivityWrapperItemProvider) { |
| openWPDependencyEditorAction.setEnabled(false); |
| } |
| |
| // Collect the breakdown elements to verifty taskdescriptors are |
| // not. |
| list.addAll(activity.getBreakdownElements()); |
| |
| // For ADD diagram menu option, if Base Activity donot have any |
| // ADD diagram, donot show ADD diagram option in context menu |
| // for |
| // readonly activity. |
| diagram = GraphicalDataManager.getInstance().getUMADiagram( |
| activity, GraphicalDataHelper.ACTIVITY_DETAIL_DIAGRAM, |
| false); |
| if (diagram == null |
| && selectedObject instanceof ActivityWrapperItemProvider) { |
| openWorkflowDetailEditorAction.setEnabled(false); |
| } else { |
| // Iterate through the List, to find taskdescriptor and has |
| // primary role within current configuration. |
| // then enable the action. |
| for (Iterator iterator = list.iterator(); iterator |
| .hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof TaskDescriptor) { |
| if (!getSuppression().isSuppressed(obj)) { |
| Object e = ((TaskDescriptor) obj) |
| .getPerformedPrimarilyBy(); |
| AdapterFactoryEditingDomain domain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) activeEditorPart) |
| .getEditingDomain(); |
| AdapterFactory factory = domain |
| .getAdapterFactory(); |
| if (factory instanceof ExposedAdapterFactory) { |
| IFilter filter = ((ExposedAdapterFactory) factory) |
| .getFilter(); |
| if (filter != null |
| && filter.accept(e) |
| && !getSuppression() |
| .isSuppressed(e)) { |
| openWorkflowDetailEditorAction |
| .setEnabled(true); |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private class ProcessEditorDropAdapter extends |
| EditingDomainTableTreeViewerDropAdapter { |
| |
| /** |
| * @param domain |
| * @param viewer |
| */ |
| public ProcessEditorDropAdapter(EditingDomain domain, Viewer viewer) { |
| super(domain, viewer); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.dnd.EditingDomainTableTreeViewerDropAdapter#getDropTarget(org.eclipse.swt.widgets.Widget) |
| */ |
| protected Object getDropTarget(Widget item) { |
| Object target = super.getDropTarget(item); |
| if (target == null && selectedProcessComponent != null) { |
| target = selectedProcessComponent.getProcess(); |
| } |
| return target; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.dnd.EditingDomainTableTreeViewerDropAdapter#drop(org.eclipse.swt.dnd.DropTargetEvent) |
| */ |
| public void drop(DropTargetEvent event) { |
| if (currentViewer instanceof IActionTypeProvider) { |
| ((IActionTypeProvider) currentViewer).setInputData(new Point( |
| event.x, event.y)); |
| } |
| super.drop(event); |
| } |
| } |
| |
| private ComposedAdapterFactory adapterFactory; |
| |
| private AdapterFactoryEditingDomain editingDomain; |
| |
| private Viewer currentViewer; |
| |
| private ISelectionChangedListener selectionChangedListener; |
| |
| private Collection selectionChangedListeners = new ArrayList(); |
| |
| private ISelection viewSelection; |
| |
| private ProcessComponent selectedProcessComponent; |
| |
| private Process selectedProcess; |
| |
| private Adapter processComponentListener = new AdapterImpl() { |
| /** |
| * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification) |
| */ |
| public void notifyChanged(Notification msg) { |
| switch (msg.getFeatureID(ProcessComponent.class)) { |
| case UmaPackage.PROCESS_COMPONENT__NAME: |
| String name = msg.getNewStringValue(); |
| if (name == null) |
| name = ""; //$NON-NLS-1$ |
| setPartName(name); |
| |
| if (pages != null) { |
| for (Iterator iter = pages.iterator(); iter.hasNext();) { |
| Object page = iter.next(); |
| if (page instanceof ProcessDescription) { |
| ((ProcessDescription) page) |
| .refreshElementName(name); |
| } |
| |
| } |
| } |
| |
| break; |
| } |
| } |
| }; |
| |
| private AdapterFactoryContentProvider propContentProvider; |
| |
| private MethodConfiguration currentConfig; |
| |
| private ILibraryChangeListener libraryListener = new ILibraryChangeListener() { |
| |
| public void libraryChanged(int option, Collection collection) { |
| switch (option) { |
| // case ILibraryChangeListener.OPTION_LOADED: |
| // // close all open diagram editors |
| // // |
| // IEditorReference[] editorRefs = |
| // getSite().getPage().getEditorReferences(); |
| // for (int i = 0; i < editorRefs.length; i++) { |
| // IEditorPart editorPart = editorRefs[i].getEditor(false); |
| // if(editorPart instanceof GraphicalWorkflowEditor |
| // || editorPart instanceof ProcessFormEditor) { |
| // getSite().getPage().closeEditor(editorPart, true); |
| // } |
| // } |
| // getSite().getPage().closeEditor(ProcessFormEditor.this, true); |
| case ILibraryChangeListener.OPTION_CHANGED: { |
| if (collection != null && collection.contains(currentConfig)) { |
| MethodConfiguration config = ProcessAuthoringConfigurator.INSTANCE |
| .getMethodConfiguration(); |
| try { |
| ProcessAuthoringConfigurator.INSTANCE |
| .setMethodConfiguration(currentConfig); |
| refreshAll(); |
| } finally { |
| ProcessAuthoringConfigurator.INSTANCE |
| .setMethodConfiguration(config); |
| } |
| } |
| break; |
| } |
| // handled by libSvcListener |
| // case ILibraryChangeListener.OPTION_CONFIGURATION_SELECTED: { |
| // configChanged(); |
| // break; |
| // } |
| |
| } |
| |
| } |
| |
| }; |
| |
| private ILibraryServiceListener libSvcListener = new ILibraryServiceListener() { |
| |
| public void configurationSet(MethodConfiguration config) { |
| configChanged(); |
| } |
| |
| public void libraryClosed(MethodLibrary library) { |
| } |
| |
| public void libraryCreated(MethodLibrary library) { |
| } |
| |
| public void libraryOpened(MethodLibrary library) { |
| } |
| |
| public void libraryReopened(MethodLibrary library) { |
| } |
| |
| public void librarySet(MethodLibrary library) { |
| } |
| |
| }; |
| |
| private ProcessBreakdownStructureFormPage WBSTab; |
| |
| private ProcessBreakdownStructureFormPage OBSTab; |
| |
| private ProcessBreakdownStructureFormPage PBSTab; |
| |
| private ProcessBreakdownStructureFormPage procTab; |
| |
| private ProcessBreakdownStructureFormPage[] extensionTabs = null; |
| |
| private ProcessBreakdownStructureFormPage[] bsPages; |
| |
| private EPFPropertySheetPage propertySheetPage; |
| |
| public Collection resourcesToSave = new ArrayList(); |
| |
| // private boolean firstExpanded = false; |
| |
| /** |
| * a listener that is interested in part activation events. |
| */ |
| private IPartListener partActivationListener = new IPartListener() { |
| |
| public void partActivated(IWorkbenchPart part) { |
| if (part instanceof PropertySheet) { |
| removePropertiesDropDownMenu(part); |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart part) { |
| // if(!firstExpanded) { |
| // synchronized(ProcessFormEditor.this) { |
| // if(firstExpanded) { |
| // ((AbstractTreeViewer) WBSTab.getViewer()).expandAll(); |
| // ((AbstractTreeViewer) OBSTab.getViewer()).expandAll(); |
| // ((AbstractTreeViewer) PBSTab.getViewer()).expandAll(); |
| // firstExpanded = true; |
| // } |
| // } |
| // } |
| } |
| |
| public void partClosed(IWorkbenchPart part) { |
| if (part instanceof PropertySheet) { |
| propertySheetPage = null; |
| } |
| } |
| |
| public void partDeactivated(IWorkbenchPart part) { |
| } |
| |
| public void partOpened(IWorkbenchPart part) { |
| if (part instanceof PropertySheet) { |
| removePropertiesDropDownMenu(part); |
| } |
| } |
| }; |
| |
| private IPropertyChangeListener prefStoreListener; |
| |
| // private ProcessConfigurator configurator; |
| |
| private Suppression suppression; |
| |
| private boolean synchronizingSelection; |
| |
| private boolean inputChanged; |
| |
| public static final IAdapterFactoryProvider adapterFactoryProvider = new IAdapterFactoryProvider() { |
| |
| public AdapterFactory getCBSAdapterFactory() { |
| return TngAdapterFactory.INSTANCE.getProcessComposedAdapterFactory(); |
| } |
| |
| public AdapterFactory getTBSAdapterFactory() { |
| return TngAdapterFactory.INSTANCE.getOBS_ComposedAdapterFactory(); |
| } |
| |
| public AdapterFactory getWBSAdapterFactory() { |
| return TngAdapterFactory.INSTANCE.getWBS_ComposedAdapterFactory(); |
| } |
| |
| public AdapterFactory getWPBSAdapterFactory() { |
| return TngAdapterFactory.INSTANCE.getPBS_ComposedAdapterFactory(); |
| } |
| }; |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#isValidateResourcesBeforeSaveRequired() |
| */ |
| protected boolean isValidateResourcesBeforeSaveRequired() { |
| return true; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#createValidateResourceAction() |
| */ |
| protected LibraryValidateAction createValidateResourceAction() { |
| LibraryValidateAction validateAction = super.createValidateResourceAction(); |
| validateAction.putContextData(LibraryEValidator.CTX_ADAPTER_FACTORY_PROVIDER, |
| adapterFactoryProvider); |
| return validateAction; |
| } |
| |
| protected void inputChanged(Object newInput) { |
| inputChanged = false; |
| if (!(newInput instanceof MethodElementEditorInput)) |
| return; |
| MethodElementEditorInput methodElementInput = (MethodElementEditorInput) newInput; |
| |
| Object obj = methodElementInput.getMethodElement(); |
| if (obj instanceof ProcessComponent) { |
| selectedProcessComponent = (ProcessComponent) obj; |
| selectedProcess = (Process) ProcessUtil |
| .getTopBreakdownElement(selectedProcessComponent); |
| suppression = Suppression.getSuppression(selectedProcess); |
| |
| // for (Iterator iter = pages.iterator(); iter.hasNext();) { |
| // Object page = iter.next(); |
| // if(page instanceof ProcessBreakdownStructureFormPage) { |
| // ((ProcessBreakdownStructureFormPage)page).setProcess(proc); |
| // } |
| // } |
| |
| WBSTab.setProcess(selectedProcess); |
| OBSTab.setProcess(selectedProcess); |
| PBSTab.setProcess(selectedProcess); |
| procTab.setProcess(selectedProcess); |
| if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| if (extensionTabs[i] != null) { |
| extensionTabs[i].setProcess(selectedProcess); |
| } |
| } |
| } |
| |
| } |
| } |
| |
| // private String getTitlePrefix() { |
| // IEditorInput input = getEditorInput(); |
| // if (input instanceof MethodElementEditorInput) { |
| // Object obj = ((MethodElementEditorInput) input).getMethodElement(); |
| // if (obj instanceof ProcessComponent) { |
| // ProcessComponent pc = (ProcessComponent) obj; |
| // Process proc = pc.getProcess(); |
| // if (proc instanceof CapabilityPattern) { |
| // return LibraryUIText.TEXT_CAPABILITY_PATTERN; |
| // } else if (proc instanceof DeliveryProcess) { |
| // return LibraryUIText.TEXT_DELIVERY_PROCESS; |
| // } else if (proc instanceof ProcessContribution) { |
| // return LibraryUIText.TEXT_PROCESS_CONTRIBUTION; |
| // } |
| // } |
| // } |
| // return AuthoringUIResources |
| // .getString("AuthoringUI.ProcessEditor.Title"); //$NON-NLS-1$ |
| // } |
| |
| private Image getProcTitleImage() { |
| IEditorInput input = getEditorInput(); |
| if (input instanceof MethodElementEditorInput) { |
| Object obj = ((MethodElementEditorInput) input).getMethodElement(); |
| if (obj instanceof ProcessComponent) { |
| ProcessComponent pc = (ProcessComponent) obj; |
| Process proc = pc.getProcess(); |
| if (proc instanceof CapabilityPattern) { |
| return LibraryUIImages.IMG_CAPABILITY_PATTERN; |
| } else if (proc instanceof DeliveryProcess) { |
| return LibraryUIImages.IMG_DELIVERY_PROCESS; |
| } |
| } |
| } |
| return LibraryUIImages.IMG_PROCESS; |
| } |
| |
| /** |
| * Remove Properties view drop down menu |
| * |
| * @param part |
| */ |
| private void removePropertiesDropDownMenu(IWorkbenchPart part) { |
| if (part instanceof PropertySheet) { |
| IViewSite view = ((PropertySheet) part).getViewSite(); |
| |
| IMenuManager menuMgr = view.getActionBars().getMenuManager(); |
| // IContributionItem[] items = menuMgr.getItems(); |
| // for (int i=0; i < items.length; i++) |
| // { |
| // System.out.println("Id =" + i + " " + items[i].getId() + "$"); |
| // } |
| menuMgr.removeAll(); |
| menuMgr.updateAll(true); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.ui.forms.editor.FormEditor#init(org.eclipse.ui.IEditorSite, |
| * org.eclipse.ui.IEditorInput) |
| */ |
| public void init(IEditorSite site, IEditorInput input) |
| throws PartInitException { |
| super.init(site, input); |
| |
| // TODO: need revisit |
| // site.setSelectionProvider(new FormEditorSelectionProvider(this)); |
| // actionManager = getActionManager(); |
| |
| List factories = new ArrayList(); |
| factories.add(new ResourceItemProviderAdapterFactory()); |
| factories.add(new ReflectiveItemProviderAdapterFactory()); |
| |
| adapterFactory = new ComposedAdapterFactory(factories); |
| |
| // Create the command stack that will notify this editor as commands are |
| // executed. |
| // |
| CommandStack commandStack = actionMgr.getCommandStack(); // new |
| // BasicCommandStack(); |
| |
| // Add a listener to set the most recent command's affected objects to |
| // be the selection of the viewer with focus. |
| // |
| commandStack.addCommandStackListener(new CommandStackListener() { |
| public void commandStackChanged(final EventObject event) { |
| boolean run = false; |
| if (event instanceof CommandStackChangedEvent) { |
| switch (((CommandStackChangedEvent) event).getType()) { |
| case CommandStackChangedEvent.EXECUTED: |
| case CommandStackChangedEvent.UNDO: |
| run = true; |
| break; |
| } |
| } else { |
| run = true; |
| } |
| if (run) { |
| Display.getCurrent().asyncExec(new Runnable() { |
| public void run() { |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| |
| // Try to select the affected objects. |
| // |
| Command mostRecentCommand = ((CommandStack) event |
| .getSource()).getMostRecentCommand(); |
| if (mostRecentCommand != null) { |
| if (mostRecentCommand instanceof CreateChildCommand |
| && currentViewer instanceof ProcessViewer) { |
| Object[] arr = mostRecentCommand |
| .getAffectedObjects().toArray(); |
| if (arr.length == 1) { |
| ProcessViewer viewer = (ProcessViewer) currentViewer; |
| viewer.editElement(arr[0], 0); |
| } |
| } else { |
| if (!(TngUtil.unwrap(mostRecentCommand) instanceof SetCommand)) { |
| setSelectionToViewer(mostRecentCommand |
| .getAffectedObjects()); |
| } |
| |
| } |
| } |
| // if (propertySheetPage != null) { |
| // propertySheetPage.refresh(); |
| // } |
| } |
| }); |
| } |
| } |
| }); |
| |
| // Create the editing domain with a special command stack. |
| editingDomain = new TraceableAdapterFactoryEditingDomain( |
| adapterFactory, commandStack); |
| |
| LibraryService.getInstance().addListener(libSvcListener); |
| ILibraryManager manager = (ILibraryManager) LibraryService |
| .getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.addListener(libraryListener); |
| manager.startListeningTo(actionMgr.getCommandStack()); |
| |
| // TODO: need to revisit this code |
| if (!addAdapterFactoryListeners) { |
| addAdapterFactoryListeners = true; |
| manager.startListeningTo(TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory()); |
| manager.startListeningTo(TngAdapterFactory.INSTANCE |
| .getOBS_ComposedAdapterFactory()); |
| manager.startListeningTo(TngAdapterFactory.INSTANCE |
| .getPBS_ComposedAdapterFactory()); |
| } |
| } |
| |
| setPartName(input.getName()); |
| setTitleImage(getProcTitleImage()); |
| |
| // get method element object from Editor input |
| MethodElementEditorInput methodElementInput = (MethodElementEditorInput) input; |
| elementObj = methodElementInput.getMethodElement(); |
| |
| if (elementObj instanceof ProcessComponent) { |
| selectedProcessComponent = ((ProcessComponent) elementObj); |
| selectedProcess = selectedProcessComponent.getProcess(); |
| } |
| |
| if (selectedProcessComponent != null) { |
| selectedProcessComponent.eAdapters().add(processComponentListener); |
| } |
| |
| // listen to resource change to update dirty flag |
| // |
| // addResourceChangedListener(); |
| |
| // add part listener to listen to propertySheet close event |
| getSite().getWorkbenchWindow().getPartService().addPartListener( |
| partActivationListener); |
| |
| // inputChanged(input); |
| |
| // listen to the change of column list in preference store |
| // |
| if (prefStoreListener == null) { |
| prefStoreListener = new IPropertyChangeListener() { |
| |
| public void propertyChange(PropertyChangeEvent event) { |
| ProcessBreakdownStructureFormPage page = null; |
| if (event.getProperty().equals( |
| ApplicationPreferenceConstants.PREF_WBS_COLUMNS)) { |
| page = WBSTab; |
| } else if (event.getProperty().equals( |
| ApplicationPreferenceConstants.PREF_TBS_COLUMNS)) { |
| page = OBSTab; |
| } else if (event.getProperty().equals( |
| ApplicationPreferenceConstants.PREF_WPBS_COLUMNS)) { |
| page = PBSTab; |
| } |
| if (page != null) { |
| ColumnDescriptor[] cols = toColumnDescriptors(getPreferenceStore().getString( |
| event.getProperty())); |
| page.updateColumns(cols); |
| if (page == WBSTab || page == OBSTab) { |
| // update consolidated view as well |
| // |
| // get WBS columns |
| List list = toColumnDescriptorList(getPreferenceStore() |
| .getString(ApplicationPreferenceConstants.PREF_WBS_COLUMNS)); |
| |
| // get TBS columns |
| ColumnDescriptor[] teamColumnDescriptors = toColumnDescriptors(getPreferenceStore() |
| .getString(ApplicationPreferenceConstants.PREF_TBS_COLUMNS)); |
| |
| // if TBS columns has TEAM column then add to consolidated view |
| for (int i = 0; i < teamColumnDescriptors.length; i++) { |
| ColumnDescriptor colDesc = teamColumnDescriptors[i]; |
| if (colDesc == COL_DESC_TEAM) { |
| list.add(colDesc); |
| break; |
| } |
| } |
| |
| ColumnDescriptor[] columns = new ColumnDescriptor[list.size()]; |
| list.toArray(columns); |
| procTab.updateColumns(columns); |
| } |
| } |
| } |
| |
| }; |
| } |
| |
| getPreferenceStore() |
| .addPropertyChangeListener(prefStoreListener); |
| |
| } |
| |
| /** |
| * This sets the selection into whichever viewer is active. |
| * |
| */ |
| public void setSelectionToViewer(Collection collection) { |
| // System.out.println(getClass().getName() + ".setSelectionToViewer: |
| // selection="+collection); |
| final Collection theSelection = collection; |
| // Make sure it's okay. |
| // |
| if (theSelection != null && !theSelection.isEmpty()) { |
| // I don't know if this should be run this deferred |
| // because we might have to give the editor a chance to process the |
| // viewer update events |
| // and hence to update the views first. |
| // |
| // |
| Runnable runnable = new Runnable() { |
| public void run() { |
| // Try to select the items in the current content viewer of |
| // the editor. |
| // |
| if (currentViewer != null) { |
| currentViewer.setSelection(new StructuredSelection( |
| theSelection.toArray()), true); |
| |
| } |
| } |
| }; |
| runnable.run(); |
| } |
| } |
| |
| public EditingDomainActionBarContributor getActionBarContributor() { |
| return (EditingDomainActionBarContributor) getEditorSite() |
| .getActionBarContributor(); |
| } |
| |
| public void dispose() { |
| getPreferenceStore() |
| .removePropertyChangeListener(prefStoreListener); |
| |
| // ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceChangeListener); |
| // |
| // getSite().getPage().removePartListener(partListener); |
| |
| adapterFactory.dispose(); |
| |
| if (getActionBarContributor().getActiveEditor() == this) { |
| getActionBarContributor().setActiveEditor(null); |
| } |
| |
| if (propertySheetPage != null) { |
| propertySheetPage.dispose(); |
| } |
| |
| ILibraryManager manager = LibraryService.getInstance() |
| .getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.removeListener(libraryListener); |
| manager.stopListeningTo(editingDomain.getCommandStack()); |
| } |
| LibraryService.getInstance().removeListener(libSvcListener); |
| |
| if (selectedProcessComponent != null) { |
| selectedProcessComponent.eAdapters().remove( |
| processComponentListener); |
| } |
| |
| // removeResourceChangedListener(); |
| |
| getSite().getWorkbenchWindow().getPartService().removePartListener( |
| partActivationListener); |
| |
| boolean saveNeeded = isDirty(); |
| |
| super.dispose(); |
| |
| // call this to set modified flag of suppression to false |
| // |
| suppression.saveIsDone(); |
| |
| if (saveNeeded) { |
| // user discarded all the changes, save the resources after changes |
| // are undone. |
| // TODO: reload the process component resource instead since it is |
| // not shared. |
| // |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // Resource resource = (Resource) iter.next(); |
| // saveResource(resource); |
| // } |
| } |
| } |
| |
| private void addDescriptionPage() throws PartInitException { |
| if (selectedProcess instanceof DeliveryProcess) { |
| // Delivery Process |
| addPage(0, new DeliveryProcessDescription(this)); |
| } else { |
| // Capability Pattern |
| // Process Contribution |
| addPage(0, new ProcessDescription(this)); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.ui.forms.editor.FormEditor#addPages() |
| */ |
| protected void addPages() { |
| try { |
| addDescriptionPage(); |
| |
| AdapterFactory adapterFactory; |
| |
| // create DND transfer objects |
| // int dndOperations = DND.DROP_COPY | DND.DROP_LINK; |
| // Transfer[] transfers = new Transfer[] |
| // {LocalTransfer.getInstance() }; |
| |
| // preference is managed by library plugin, |
| // since this preferences is also used for browsing and publishing |
| // Jinhua Xi 08/21/2006 |
| // IPreferenceStore store = AuthoringUIPlugin.getDefault() |
| // .getPreferenceStore(); |
| PreferenceUtil.validatePreferences(); |
| IPreferenceStore store = getPreferenceStore(); |
| |
| List pages = new ArrayList(); |
| |
| // WBS tab |
| WBSTab = new ProcessBreakdownStructureFormPage(this, WBS_FORM_ID, |
| AuthoringUIResources.ProcessEditor_WorkBreakdownStructure); //$NON-NLS-1$ |
| ColumnDescriptor[] columnDescriptors = toColumnDescriptors(store |
| .getString(ApplicationPreferenceConstants.PREF_WBS_COLUMNS)); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory(); |
| currentConfig = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| ProcessAuthoringConfigurator.INSTANCE |
| .setMethodConfiguration(currentConfig); |
| if (adapterFactory instanceof ConfigurableComposedAdapterFactory) { |
| ((ConfigurableComposedAdapterFactory) adapterFactory) |
| .setFilter(ProcessAuthoringConfigurator.INSTANCE); |
| } |
| WBSTab.setAdapterFactory(adapterFactory); |
| WBSTab.setColumnDescriptors(columnDescriptors); |
| int id = addPage(WBSTab.createControl(getContainer())); |
| setPageText(id, WBSTab.getTitle()); |
| WBSTab.setTabIndex(id); |
| StructuredViewer viewer = (StructuredViewer) WBSTab.getViewer(); |
| createContextMenuFor(viewer); |
| pages.add(WBSTab); |
| // viewer.addDropSupport(dndOperations, transfers, new |
| // ProcessEditorDropAdapter(editingDomain, viewer)); |
| // viewer.addDoubleClickListener(new IDoubleClickListener() |
| // { |
| // public void doubleClick(DoubleClickEvent event) |
| // { |
| // UIActionDispatcher.getInstance().handleDoubleClickEvent(event); |
| // // System.out.println("double clicked ..."); |
| // // |
| // // StructuredSelection selection = (StructuredSelection) |
| // event.getSelection(); |
| // // System.out.println("sel"+selection.getFirstElement()); |
| // // |
| // ProductEditorView.getView().getProductViewer().setInput(selection.getFirstElement()); |
| // } |
| // }); |
| // addPage(WBSTab); |
| |
| // OBS tab |
| OBSTab = new ProcessBreakdownStructureFormPage(this, TA_FORM_ID, |
| AuthoringUIResources.ProcessEditor_TeamAllocation); //$NON-NLS-1$ |
| columnDescriptors = toColumnDescriptors(store |
| .getString(ApplicationPreferenceConstants.PREF_TBS_COLUMNS)); |
| // setColumnIndexToNameMap(TngAdapterFactory.INSTANCE.getOBS_AdapterFactories(), |
| // columnDescriptors); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getOBS_ComposedAdapterFactory(); |
| if (adapterFactory instanceof ConfigurableComposedAdapterFactory) { |
| ((ConfigurableComposedAdapterFactory) adapterFactory) |
| .setFilter(ProcessAuthoringConfigurator.INSTANCE); |
| } |
| OBSTab.setAdapterFactory(adapterFactory); |
| OBSTab.setColumnDescriptors(columnDescriptors); |
| id = addPage(OBSTab.createControl(getContainer())); |
| setPageText(id, OBSTab.getTitle()); |
| OBSTab.setTabIndex(id); |
| viewer = (StructuredViewer) OBSTab.getViewer(); |
| createContextMenuFor(viewer); |
| pages.add(OBSTab); |
| // viewer.addDropSupport(dndOperations, transfers, new |
| // ProcessEditorDropAdapter(editingDomain, viewer)); |
| // addPage(OBSTab); |
| |
| // PBS tab |
| PBSTab = new ProcessBreakdownStructureFormPage(this, WPBS_FORM_ID, |
| AuthoringUIResources.ProcessEditor_WorkProductUsage); //$NON-NLS-1$ |
| columnDescriptors = toColumnDescriptors(store |
| .getString(ApplicationPreferenceConstants.PREF_WPBS_COLUMNS)); |
| // setColumnIndexToNameMap(TngAdapterFactory.INSTANCE.getPBS_AdapterFactories(), |
| // columnDescriptors); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getPBS_ComposedAdapterFactory(); |
| if (adapterFactory instanceof ConfigurableComposedAdapterFactory) { |
| ((ConfigurableComposedAdapterFactory) adapterFactory) |
| .setFilter(ProcessAuthoringConfigurator.INSTANCE); |
| } |
| PBSTab.setAdapterFactory(adapterFactory); |
| PBSTab.setColumnDescriptors(columnDescriptors); |
| id = addPage(PBSTab.createControl(getContainer())); |
| setPageText(id, PBSTab.getTitle()); |
| PBSTab.setTabIndex(id); |
| viewer = (StructuredViewer) PBSTab.getViewer(); |
| createContextMenuFor(viewer); |
| pages.add(PBSTab); |
| // viewer.addDropSupport(dndOperations, transfers, new |
| // ProcessEditorDropAdapter(editingDomain, viewer)); |
| // addPage(PBSTab); |
| |
| // consolidated tab |
| procTab = new ProcessBreakdownStructureFormPage(this, |
| CONSOLIDATED_FORM_ID, |
| AuthoringUIResources.ProcessEditor_ConsolidatedView); //$NON-NLS-1$ |
| procTab.setReadOnly(true); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getProcessComposedAdapterFactory(); |
| if (adapterFactory instanceof ConfigurableComposedAdapterFactory) { |
| ((ConfigurableComposedAdapterFactory) adapterFactory) |
| .setFilter(ProcessAuthoringConfigurator.INSTANCE); |
| } |
| procTab.setAdapterFactory(adapterFactory); |
| // columnDescriptors = toColumnDescriptors(store |
| // .getString(ApplicationPreferenceConstants.PREF_WBS_COLUMNS)); |
| // |
| // get WBS columns |
| List list = toColumnDescriptorList(store |
| .getString(ApplicationPreferenceConstants.PREF_WBS_COLUMNS)); |
| |
| // get TBS columns |
| ColumnDescriptor[] teamColumnDescriptors = toColumnDescriptors(store |
| .getString(ApplicationPreferenceConstants.PREF_TBS_COLUMNS)); |
| |
| // if TBS columns has TEAM column then add to consolidated view |
| for (int i = 0; i < teamColumnDescriptors.length; i++) { |
| ColumnDescriptor colDesc = teamColumnDescriptors[i]; |
| if (colDesc == COL_DESC_TEAM) { |
| list.add(colDesc); |
| break; |
| } |
| } |
| |
| ColumnDescriptor[] columns = new ColumnDescriptor[list.size()]; |
| list.toArray(columns); |
| procTab.setColumnDescriptors(columns); |
| |
| id = addPage(procTab.createControl(getContainer())); |
| setPageText(id, procTab.getTitle()); |
| procTab.setTabIndex(id); |
| viewer = (StructuredViewer) procTab.getViewer(); |
| createContextMenuFor(viewer); |
| pages.add(procTab); |
| |
| // check for extenstion point and add the page if there |
| List pageProviders = ProcessEditorPageProvider.getInstance() |
| .getPageProviders(); |
| |
| if (pageProviders != null && pageProviders.size() > 0) { |
| try { |
| extensionTabs = new ProcessBreakdownStructureFormPage[pageProviders |
| .size()]; |
| for (int i = 0; i < pageProviders.size(); i++) { |
| Object page = pageProviders.get(i); |
| if (page instanceof IExtensionFormPage) { |
| |
| IExtensionFormPage formPage = (IExtensionFormPage) page; |
| IFormPage control = formPage.setEditor(this); |
| formPage.setInput(selectedProcess); |
| ProcessBreakdownStructureFormPage extendedPage = null; |
| if (control instanceof ProcessBreakdownStructureFormPage) { |
| extendedPage = (ProcessBreakdownStructureFormPage) control; |
| extensionTabs[i] = extendedPage; |
| } |
| |
| id = addPage(extendedPage |
| .createControl(getContainer())); |
| setPageText(id, extendedPage.getTitle()); |
| extendedPage.setTabIndex(id); |
| viewer = (StructuredViewer) extendedPage |
| .getViewer(); |
| createContextMenuFor(viewer); |
| |
| pages.add(extendedPage); |
| } |
| } |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| bsPages = new ProcessBreakdownStructureFormPage[pages.size()]; |
| for (int i = 0; i < pages.size(); i++) { |
| bsPages[i] = (ProcessBreakdownStructureFormPage) pages.get(i); |
| } |
| |
| // bsPages = new ProcessBreakdownStructureFormPage[] { WBSTab, |
| // OBSTab, |
| // PBSTab, procTab }; |
| |
| // if(getEditorInput() instanceof ProcessEditorInput) { |
| // int pageId = |
| // ((ProcessEditorInput)getEditorInput()).getActivePage(); |
| // if(pageId != -1) { |
| // setActivePage(0); |
| // setActivePage(pageId); |
| // } |
| // } |
| |
| inputChanged(getEditorInput()); |
| } catch (PartInitException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| e.printStackTrace(); |
| } |
| } |
| |
| protected void setActivePage(int pageIndex) { |
| super.setActivePage(pageIndex); |
| |
| // work around for active page that is not a form page. Super method |
| // does not call pageChange() in this case |
| // |
| handlePageChange(); |
| if (pageIndex > 0 && bsPages.length <= pageIndex) { |
| Viewer viewer = bsPages[pageIndex].getViewer(); |
| ISelection selection = viewer.getSelection(); |
| if (selection == null || selection.isEmpty()) { |
| ISelection initialSelection = null; |
| if (getEditorInput() instanceof ProcessEditorInput) { |
| initialSelection = ((ProcessEditorInput) getEditorInput()) |
| .getInitialSelection(); |
| } |
| if (initialSelection == null) { |
| selection = new StructuredSelection(selectedProcess); |
| } else { |
| selection = initialSelection; |
| } |
| viewer.setSelection(selection, true); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.forms.editor.FormEditor#setActivePage(java.lang.String) |
| */ |
| public IFormPage setActivePage(String pageId) { |
| int id = -1; |
| IFormPage activePage = null; |
| for (int i = 0; i < pages.size(); i++) { |
| Object page = pages.get(i); |
| if (page instanceof IFormPage) { |
| IFormPage fpage = (IFormPage) page; |
| if (fpage.getId().equals(pageId)) { |
| id = i; |
| activePage = fpage; |
| break; |
| } |
| } |
| } |
| if(id == -1) { |
| for (int i = 0; i < bsPages.length; i++) { |
| ProcessBreakdownStructureFormPage page = bsPages[i]; |
| if (page.getId().equals(pageId)) { |
| id = page.getTabIndex(); |
| activePage = page; |
| break; |
| } |
| } |
| } |
| if(id == -1 && extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| ProcessBreakdownStructureFormPage page = extensionTabs[i]; |
| if (page.getId().equals(pageId)) { |
| id = page.getTabIndex(); |
| activePage = page; |
| break; |
| } |
| } |
| } |
| |
| if(activePage != null) { |
| setActivePage(id); |
| return activePage; |
| } |
| return null; |
| } |
| |
| private void handlePageChange() { |
| int id = getActivePage(); |
| if (id != -1) { |
| Object page = pages.get(id); |
| if (page instanceof ProcessDescription) { |
| ((ProcessDescription) page).setFormText(); |
| } |
| if (id == WBSTab.getTabIndex()) { |
| setCurrentViewer(WBSTab.getViewer()); |
| } else if (id == OBSTab.getTabIndex()) { |
| setCurrentViewer(OBSTab.getViewer()); |
| } else if (id == PBSTab.getTabIndex()) { |
| setCurrentViewer(PBSTab.getViewer()); |
| } else if (id == procTab.getTabIndex()) { |
| setCurrentViewer(procTab.getViewer()); |
| } else if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| if (extensionTabs[i] != null && id == extensionTabs[i].getTabIndex()) |
| setCurrentViewer(extensionTabs[i].getViewer()); |
| } |
| } else { |
| setCurrentViewer(null); |
| } |
| |
| if (propertySheetPage != null) { |
| propertySheetPage.refresh(); |
| } |
| } |
| } |
| |
| protected void pageChange(int newPageIndex) { |
| super.pageChange(newPageIndex); |
| handlePageChange(); |
| } |
| |
| /** |
| * Create context menu for the give viewer |
| * @param viewer |
| */ |
| public void createContextMenuFor(final StructuredViewer viewer) { |
| MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$ |
| contextMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| contextMenu.setRemoveAllWhenShown(true); |
| contextMenu.addMenuListener(this); |
| Menu menu = contextMenu.createContextMenu(viewer.getControl()); |
| viewer.getControl().setMenu(menu); |
| getSite().registerContextMenu(contextMenu, viewer); |
| |
| viewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| IStructuredSelection sel = (IStructuredSelection) event |
| .getSelection(); |
| setSelection(sel); |
| } |
| }); |
| |
| int dndOperations = DND.DROP_LINK | DND.DROP_COPY; |
| Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() }; |
| viewer.addDropSupport(dndOperations, transfers, |
| new ProcessEditorDropAdapter(editingDomain, viewer)); |
| } |
| |
| private void setCurrentViewer(Viewer viewer) { |
| // If it is changing... |
| // |
| if (currentViewer != viewer) { |
| if (selectionChangedListener == null) { |
| // Create the listener on demand. |
| // |
| selectionChangedListener = new ISelectionChangedListener() { |
| // This just notifies those things that are affected by the |
| // section. |
| // |
| public void selectionChanged( |
| SelectionChangedEvent selectionChangedEvent) { |
| setSelection(selectionChangedEvent.getSelection()); |
| } |
| }; |
| } |
| |
| // Stop listening to the old one. |
| // |
| if (currentViewer != null) { |
| currentViewer |
| .removeSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Start listening to the new one. |
| // |
| if (viewer != null) { |
| viewer.addSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Remember it. |
| // |
| currentViewer = viewer; |
| |
| // Set adapter factory of editingDomain to that of the current view |
| // |
| if (currentViewer instanceof ProcessViewer) { |
| IContentProvider contentProvider = ((ProcessViewer) currentViewer) |
| .getContentProvider(); |
| if (contentProvider instanceof AdapterFactoryContentProvider) { |
| AdapterFactoryContentProvider adapterFactoryContentProvider = ((AdapterFactoryContentProvider) contentProvider); |
| AdapterFactory adapterFactory = adapterFactoryContentProvider |
| .getAdapterFactory(); |
| if (adapterFactory instanceof EditingDomainComposedAdapterFactory) { |
| ((EditingDomainComposedAdapterFactory) adapterFactory) |
| .setEditingDomain(editingDomain); |
| } else { |
| editingDomain.setAdapterFactory(adapterFactory); |
| } |
| |
| if (propContentProvider != null) { |
| propContentProvider.setAdapterFactory(adapterFactory); |
| } |
| } |
| } |
| |
| // Set the editors selection based on the current viewer's |
| // selection. |
| // |
| setSelection(currentViewer == null ? StructuredSelection.EMPTY |
| : currentViewer.getSelection()); |
| |
| } |
| } |
| |
| private static Activity getParentActivity(BreakdownElement e, |
| AdapterFactory adapterFactory) { |
| Activity act = UmaUtil.getParentActivity(e); |
| if (act != null) { |
| return act; |
| } |
| |
| // TODO: handle element that does not directly belong to an activity |
| // (like deliverable part of a deliverable descriptor) |
| // |
| |
| return null; |
| } |
| |
| private static AdapterFactory getAdapterFactory(StructuredViewer viewer) { |
| return ((AdapterFactoryContentProvider) viewer.getContentProvider()) |
| .getAdapterFactory(); |
| } |
| |
| private static void setSelectionToViewer(Viewer viewer, |
| IStructuredSelection otherSel, boolean alternateSelection) { |
| if (alternateSelection) { |
| IStructuredSelection sel = (IStructuredSelection) viewer |
| .getSelection(); |
| Object currentSelection = null; |
| if (sel.size() == 1) { |
| currentSelection = sel.getFirstElement(); |
| if (currentSelection instanceof BreakdownElement) { |
| Activity act = getParentActivity( |
| (BreakdownElement) currentSelection, |
| getAdapterFactory((StructuredViewer) viewer)); |
| if (act != otherSel.getFirstElement()) { |
| viewer.setSelection(otherSel, true); |
| } |
| } |
| } else { |
| viewer.setSelection(otherSel, true); |
| } |
| } else { |
| viewer.setSelection(otherSel, true); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection) |
| */ |
| public void setSelection(ISelection selection) { |
| if (synchronizingSelection) { |
| return; |
| } |
| |
| // // check if the resources of selected objects are out of synch or any |
| // of the selected objects |
| // // became proxy then refresh them if needed |
| // // |
| // if(refreshOutOfSynch(selection)) { |
| // return; |
| // } |
| |
| viewSelection = selection; |
| ArrayList listenerList = new ArrayList(selectionChangedListeners); |
| |
| for (int i = 0; i < listenerList.size(); i++) { |
| ISelectionChangedListener listener = (ISelectionChangedListener) listenerList |
| .get(i); |
| listener |
| .selectionChanged(new SelectionChangedEvent(this, selection)); |
| } |
| |
| // synchronize selection in all BS views if only one element is selected |
| // |
| synchronizeSelection(selection, currentViewer); |
| } |
| |
| /** |
| * @param selection |
| * @return |
| */ |
| private boolean refreshOutOfSynch(ISelection selection) { |
| if (currentViewer != null && selection instanceof IStructuredSelection) { |
| boolean refreshRequired = false; |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| HashSet resources = new HashSet(); |
| for (Iterator iter = sel.iterator(); iter.hasNext();) { |
| Object e = TngUtil.unwrap(iter.next()); |
| if (e instanceof EObject) { |
| EObject eObject = ((EObject) e); |
| if (eObject.eIsProxy()) { |
| eObject = RefreshJob.getInstance().resolve(eObject); |
| refreshRequired = true; |
| } |
| Resource resource = eObject.eResource(); |
| if (resource != null) { |
| resources.add(resource); |
| } |
| } |
| } |
| if (!resources.isEmpty()) { |
| ArrayList removedResources = new ArrayList(); |
| ArrayList changedResources = new ArrayList(); |
| ResourceUtil.checkOutOfSynchResources(resources, |
| removedResources, changedResources); |
| if (!removedResources.isEmpty() || !changedResources.isEmpty()) { |
| boolean ret = promptReloadFiles(); |
| if (ret) { |
| // unload the removed resources |
| // |
| if (!removedResources.isEmpty()) { |
| for (Iterator iter = removedResources.iterator(); iter |
| .hasNext();) { |
| MultiFileXMIResourceImpl resource = (MultiFileXMIResourceImpl) iter |
| .next(); |
| try { |
| resource.unloadWithoutRemove(); |
| } catch (Exception e) { |
| CommonPlugin.INSTANCE.log(e); |
| } |
| } |
| } |
| |
| Collection reloadedResources = null; |
| if (!changedResources.isEmpty()) { |
| // Reload the changed resources. |
| ILibraryManager manager = (ILibraryManager) LibraryService |
| .getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| reloadedResources = manager |
| .reloadResources(changedResources); |
| } |
| } |
| |
| if (!removedResources.isEmpty() |
| || reloadedResources != null) { |
| refreshRequired = true; |
| } |
| |
| // refresh out-of-synch resources |
| // |
| for (Iterator iter = changedResources.iterator(); iter |
| .hasNext();) { |
| FileManager.getInstance().refresh( |
| (Resource) iter.next()); |
| } |
| } |
| } |
| } |
| if (refreshRequired) { |
| currentViewer.refresh(); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * @param selection |
| */ |
| private void synchronizeSelection(ISelection selection, Viewer currentViewer) { |
| try { |
| synchronizingSelection = true; |
| if (currentViewer != null |
| && selection instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| if (sel.size() == 1) { |
| Object selected = sel.getFirstElement(); |
| IStructuredSelection otherSel = null; |
| boolean alternateSelection = false; |
| ArrayList selectedPath = null; |
| AdapterFactory adapterFactory = getAdapterFactory((StructuredViewer) currentViewer); |
| if (selected instanceof BreakdownElementWrapperItemProvider) { |
| if (((BreakdownElementWrapperItemProvider) selected) |
| .isReadOnly()) { |
| if (adapterFactory != null) { |
| // get path |
| // |
| Object e = TngUtil.unwrap(selected); |
| selectedPath = new ArrayList(); |
| ITreeItemContentProvider adapter = (ITreeItemContentProvider) selected; |
| do { |
| selectedPath.add(0, e); |
| Object parent = adapter.getParent(e); |
| if (parent == null) { |
| break; |
| } |
| if (parent instanceof BreakdownElementWrapperItemProvider) { |
| adapter = (ITreeItemContentProvider) parent; |
| e = TngUtil.unwrap(parent); |
| } else { |
| adapter = (ITreeItemContentProvider) adapterFactory |
| .adapt( |
| parent, |
| ITreeItemContentProvider.class); |
| e = parent; |
| } |
| } while (true); |
| } |
| } else if (procTab.getViewer() == currentViewer) { |
| selected = TngUtil.unwrap(selected); |
| selection = new StructuredSelection(selected); |
| } else if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| if (extensionTabs[i].getViewer() == currentViewer) { |
| selected = TngUtil.unwrap(selected); |
| selection = new StructuredSelection( |
| selected); |
| |
| } |
| } |
| } |
| } |
| if (selected instanceof BreakdownElement) { |
| if (procTab.getViewer() != currentViewer) { |
| procTab.getViewer().setSelection(selection, false); |
| } |
| if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| if (extensionTabs[i].getViewer() != currentViewer) |
| extensionTabs[i].getViewer().setSelection( |
| selection, false); |
| } |
| } |
| |
| if (selected instanceof Activity |
| || selected instanceof Milestone) { |
| otherSel = (IStructuredSelection) selection; |
| } else { |
| Activity act = getParentActivity( |
| (BreakdownElement) selected, adapterFactory); |
| if (act != null) { |
| otherSel = new StructuredSelection(act); |
| alternateSelection = true; |
| } |
| } |
| } |
| if (otherSel != null) { |
| // own element is selected |
| // |
| Viewer viewer = WBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| if (selected instanceof WorkBreakdownElement) { |
| viewer.setSelection(selection, false); |
| } else { |
| setSelectionToViewer(viewer, otherSel, |
| alternateSelection); |
| } |
| } |
| viewer = OBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| if (selected instanceof RoleDescriptor) { |
| viewer.setSelection(selection, false); |
| } else { |
| setSelectionToViewer(viewer, otherSel, |
| alternateSelection); |
| } |
| } |
| viewer = PBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| if (selected instanceof WorkProductDescriptor) { |
| viewer.setSelection(selection, false); |
| } else { |
| setSelectionToViewer(viewer, otherSel, |
| alternateSelection); |
| } |
| } |
| } else if (selectedPath != null) { |
| // inherited element is selected |
| // |
| Viewer viewer = WBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| selection = new StructuredSelection(findSelection( |
| selectedPath, WBSTab.getAdapterFactory())); |
| viewer.setSelection(selection, false); |
| } |
| viewer = OBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| selection = new StructuredSelection(findSelection( |
| selectedPath, OBSTab.getAdapterFactory())); |
| viewer.setSelection(selection, false); |
| } |
| viewer = PBSTab.getViewer(); |
| if (viewer != currentViewer) { |
| selection = new StructuredSelection(findSelection( |
| selectedPath, PBSTab.getAdapterFactory())); |
| viewer.setSelection(selection, false); |
| } |
| viewer = procTab.getViewer(); |
| if (viewer != currentViewer) { |
| selection = new StructuredSelection(findSelection( |
| selectedPath, procTab.getAdapterFactory())); |
| viewer.setSelection(selection, false); |
| } |
| |
| if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| viewer = extensionTabs[i].getViewer(); |
| if (viewer != currentViewer) { |
| selection = new StructuredSelection( |
| findSelection( |
| selectedPath, |
| extensionTabs[i] |
| .getAdapterFactory())); |
| viewer.setSelection(selection, false); |
| } |
| } |
| } |
| } |
| } |
| } |
| } finally { |
| synchronizingSelection = false; |
| } |
| } |
| |
| private static Object findSelection(List selectedPath, |
| AdapterFactory adapterFactory) { |
| int size = selectedPath.size(); |
| if (size == 0) { |
| return null; |
| } |
| Object e = selectedPath.get(0); |
| Object selection = e; |
| ITreeItemContentProvider adapter = (ITreeItemContentProvider) adapterFactory |
| .adapt(e, ITreeItemContentProvider.class); |
| Collection children = adapter.getChildren(e); |
| find_selection: for (int i = 1; i < size; i++) { |
| e = selectedPath.get(i); |
| for (Iterator iter = children.iterator(); iter.hasNext();) { |
| Object child = iter.next(); |
| Object element = TngUtil.unwrap(child); |
| if (element == e) { |
| selection = child; |
| adapter = (ITreeItemContentProvider) adapterFactory.adapt( |
| child, ITreeItemContentProvider.class); |
| children = adapter.getChildren(e); |
| continue find_selection; |
| } |
| } |
| break find_selection; |
| } |
| return selection; |
| } |
| |
| // Implements ISelectionProvider |
| // |
| public void addSelectionChangedListener(ISelectionChangedListener listener) { |
| selectionChangedListeners.add(listener); |
| } |
| |
| public void removeSelectionChangedListener( |
| ISelectionChangedListener listener) { |
| selectionChangedListeners.remove(listener); |
| } |
| |
| /** |
| * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection() |
| */ |
| public ISelection getSelection() { |
| return viewSelection; |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.domain.IEditingDomainProvider#getEditingDomain() |
| */ |
| public EditingDomain getEditingDomain() { |
| return editingDomain; |
| } |
| |
| /** |
| * @see org.eclipse.emf.common.ui.viewer.IViewerProvider#getViewer() |
| */ |
| public Viewer getViewer() { |
| return currentViewer; |
| } |
| |
| /** |
| * Gets the adapter factory of the current page if there is any |
| * |
| * @return |
| * Adapter Factory of the current page of the editor |
| */ |
| public AdapterFactory getAdapterFactory() { |
| IFormPage page = getActivePageInstance(); |
| if (page instanceof ProcessBreakdownStructureFormPage) { |
| return ((ProcessBreakdownStructureFormPage) page) |
| .getAdapterFactory(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface.action.IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| ((IMenuListener) getEditorSite().getActionBarContributor()) |
| .menuAboutToShow(menuManager); |
| |
| // populate contributed menu items |
| // |
| IFormPage activePage = getActivePageInstance(); |
| if(activePage instanceof ProcessBreakdownStructureFormPage) { |
| IAction[] actions = ((ProcessBreakdownStructureFormPage)activePage).getAdditionalActions(); |
| if(actions != null && actions.length > 0) { |
| menuManager.insertAfter(IWorkbenchActionConstants.MB_ADDITIONS, new Separator()); |
| for (int i = 0; i < actions.length; i++) { |
| IAction action = actions[i]; |
| ISelection selection = getSelection(); |
| if(selection instanceof IStructuredSelection && action instanceof BaseSelectionListenerAction) { |
| ((BaseSelectionListenerAction)action).selectionChanged((IStructuredSelection) selection); |
| } |
| if (action instanceof IWorkbenchPartAction) { |
| ((IWorkbenchPartAction) action) |
| .setActiveWorkbenchPart(this); |
| } |
| menuManager.insertAfter(IWorkbenchActionConstants.MB_ADDITIONS, action); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Return property sheet page |
| * @return |
| * PropertySheet Page |
| */ |
| public IPropertySheetPage getPropertySheetPage() { |
| if (propertySheetPage == null) { |
| propertySheetPage = new EPFPropertySheetPage(this); |
| // { |
| // public void makeContributions(IMenuManager menuManager, |
| // IToolBarManager toolBarManager, IStatusLineManager |
| // statusLineManager) { |
| // super.makeContributions(menuManager, toolBarManager, |
| // statusLineManager); |
| // } |
| // |
| // public void setActionBars(IActionBars actionBars) { |
| // super.setActionBars(actionBars); |
| // getActionBarContributor().shareGlobalActions(this, actionBars); |
| // } |
| // }; |
| // System.out.println("Setting provider "); |
| if (currentViewer != null) { |
| AdapterFactoryContentProvider contentProvider = (AdapterFactoryContentProvider) ((ProcessViewer) currentViewer) |
| .getContentProvider(); |
| propContentProvider = new AdapterFactoryContentProvider( |
| contentProvider.getAdapterFactory()); |
| propertySheetPage |
| .setPropertySourceProvider(propContentProvider); |
| } |
| } |
| return propertySheetPage; |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.MultiPageEditorPart#getAdapter(java.lang.Class) |
| */ |
| public Object getAdapter(Class key) { |
| if (key.equals(IPropertySheetPage.class)) { |
| return getPropertySheetPage(); |
| } else if (key.equals(IGotoMarker.class)) { |
| return this; |
| } else { |
| return super.getAdapter(key); |
| } |
| } |
| |
| |
| /** |
| * @see org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor#getContributorId() |
| */ |
| public String getContributorId() { |
| return getSite().getId(); |
| } |
| |
| |
| /** |
| * Return column descriptor list for given string |
| * @param str |
| * @return |
| * list of column descriptors |
| */ |
| public static EList toColumnDescriptorList(String str) { |
| EList columnDescriptors = new BasicEList(); |
| StringTokenizer tokens = new StringTokenizer(str, ","); //$NON-NLS-1$ |
| while (tokens.hasMoreTokens()) { |
| String token = tokens.nextToken(); |
| Object columnDescriptor = ProcessEditor.idToColumnDescriptorMap |
| .get(token); |
| if (columnDescriptor != null) { |
| columnDescriptors.add(columnDescriptor); |
| } |
| } |
| return columnDescriptors; |
| } |
| |
| /** |
| * Return array of column descriptors for the given string |
| * @param str |
| * @return |
| * list of column descriptors |
| */ |
| public static ColumnDescriptor[] toColumnDescriptors(String str) { |
| List list = toColumnDescriptorList(str); |
| ColumnDescriptor[] columns = new ColumnDescriptor[list.size()]; |
| list.toArray(columns); |
| return columns; |
| } |
| |
| /** |
| * @see org.eclipse.ui.forms.editor.FormEditor#getCurrentPage() |
| */ |
| public int getCurrentPage() { |
| return super.getCurrentPage(); |
| } |
| |
| /** |
| * Return suppression info |
| */ |
| public Suppression getSuppression() { |
| return suppression; |
| } |
| |
| private void configChanged() { |
| MethodConfiguration config = LibraryService.getInstance() |
| .getCurrentMethodConfiguration(); |
| if (config != currentConfig) { |
| // refresh only if the active part is this editor or diagram editor |
| // of any activity in this process |
| // |
| IWorkbenchPart activePart = getSite().getWorkbenchWindow() |
| .getPartService().getActivePart(); |
| boolean refresh = activePart == this; |
| if (!refresh) { |
| if (activePart instanceof AbstractDiagramEditor) { |
| BreakdownElementEditorInput input = (BreakdownElementEditorInput) ((IEditorPart) activePart) |
| .getEditorInput(); |
| refresh = input.getSuppression().getProcess() == selectedProcess; |
| } |
| } |
| if (refresh) { |
| currentConfig = config; |
| refreshAll(); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#setInput(org.eclipse.ui.IEditorInput) |
| */ |
| protected void setInput(IEditorInput input) { |
| if (input != getEditorInput()) { |
| inputChanged = true; |
| } |
| super.setInput(input); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#updatePages() |
| */ |
| protected void updatePages() { |
| // remove and add description page if the model.xmi or content.xmi of |
| // the process have been changed |
| // |
| Resource modelResource = selectedProcess.eResource(); |
| Resource contentResource = selectedProcess.getPresentation() |
| .eResource(); |
| if (changedResources.contains(modelResource) |
| || (contentResource != null && changedResources |
| .contains(contentResource))) { |
| removePage(0); |
| try { |
| addDescriptionPage(); |
| } catch (PartInitException e) { |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError( |
| AuthoringUIResources.ProcessEditor_refreshErrorTitle, //$NON-NLS-1$ |
| AuthoringUIResources.ProcessEditor_refreshErrorMsg, e); //$NON-NLS-1$ |
| } |
| } |
| if (inputChanged) { |
| inputChanged(getEditorInput()); |
| if (propertySheetPage != null) { |
| propertySheetPage.refresh(); |
| } |
| } else { |
| refreshAll(); |
| } |
| } |
| |
| private void refreshAll() { |
| BusyIndicator.showWhile(getSite().getShell().getDisplay(), |
| new Runnable() { |
| |
| public void run() { |
| doRefreshAll(true); |
| } |
| |
| }); |
| } |
| |
| /** |
| * Refresh all viewers |
| * @param updateIDs |
| * if true, then refresh all index in viewers |
| */ |
| public void doRefreshAll(boolean updateIDs) { |
| if (updateIDs) { |
| AdapterFactory adapterFactory = TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory(); |
| ProcessUtil.updateIDs(adapterFactory, selectedProcess); |
| ProcessUtil.refreshPredeccessorLists(adapterFactory, |
| selectedProcess); |
| |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getProcessComposedAdapterFactory(); |
| ProcessUtil.updateIDs(adapterFactory, selectedProcess); |
| } |
| |
| WBSTab.getViewer().refresh(); |
| OBSTab.getViewer().refresh(); |
| PBSTab.getViewer().refresh(); |
| procTab.getViewer().refresh(); |
| |
| if (extensionTabs != null) { |
| for (int i = 0; i < extensionTabs.length; i++) { |
| extensionTabs[i].getViewer().refresh(); |
| } |
| } |
| |
| if (propertySheetPage != null) { |
| propertySheetPage.refresh(); |
| } |
| } |
| |
| |
| /** |
| * Refresh all open process editors |
| */ |
| public void refreshAllProcessEditors() { |
| IEditorReference[] editorReferences = getSite().getPage() |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof ProcessEditor) { |
| ((ProcessEditor) editor).doRefreshAll(false); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.ui.forms.editor.FormEditor#getActivePageInstance() |
| */ |
| public IFormPage getActivePageInstance() { |
| int index = getActivePage(); |
| if (index == -1) { |
| return null; |
| } |
| if (index == 0) { |
| return super.getActivePageInstance(); |
| } |
| return bsPages[index - 1]; |
| } |
| |
| protected Collection getModifiedResources() { |
| Collection modifiedResources = super.getModifiedResources(); |
| if (suppression.isSaveNeeded() |
| && !modifiedResources.contains(selectedProcessComponent |
| .eResource())) { |
| modifiedResources.add(selectedProcessComponent.eResource()); |
| } |
| modifiedResources.addAll(resourcesToSave); |
| |
| return modifiedResources; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#doSave(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void doSave(IProgressMonitor monitor) { |
| suppression.saveToModel(); |
| super.doSave(monitor); |
| suppression.saveIsDone(); |
| resourcesToSave.clear(); |
| firePropertyChange(PROP_DIRTY); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#isDirty() |
| */ |
| public boolean isDirty() { |
| if (suppression.isSaveNeeded()) { |
| return true; |
| } |
| return super.isDirty(); |
| } |
| |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#firePropertyChange(int) |
| */ |
| public void firePropertyChange(int propertyId) { |
| super.firePropertyChange(propertyId); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.editors.MethodElementEditor#getUsedResources() |
| */ |
| public Collection getUsedResources() { |
| HashSet usedResources = new HashSet(); |
| |
| // model.xmi |
| // |
| Resource resource = elementObj.eResource(); |
| if (resource != null) { |
| usedResources.add(resource); |
| } |
| |
| // content.xmi |
| // |
| resource = selectedProcess.getPresentation().eResource(); |
| if (resource != null) { |
| usedResources.add(resource); |
| } |
| |
| // configuration.xmi |
| // |
| MethodConfiguration config = selectedProcess.getDefaultContext(); |
| if (config != null) { |
| resource = config.eResource(); |
| if (resource != null) { |
| usedResources.add(resource); |
| } |
| } |
| |
| // resources of other processes that this process is depending on |
| // |
| AdapterFactory adapterFactory = WBSTab.getAdapterFactory(); |
| for (Iterator iter = new AdapterFactoryTreeIterator(adapterFactory, |
| selectedProcess); iter.hasNext();) { |
| Object obj = TngUtil.unwrap(iter.next()); |
| if (obj instanceof EObject) { |
| resource = ((EObject) obj).eResource(); |
| if (resource != null) { |
| usedResources.add(resource); |
| } |
| } |
| } |
| |
| lastUsedResources = usedResources; |
| |
| return usedResources; |
| } |
| |
| /** |
| * Check whether selected objects can be revealed or not and retuns result |
| * |
| * @param selection |
| * List of objects |
| * @param adapterFactory |
| * Adapter factory of the selected objects |
| * @param suppression |
| * Suppression information |
| * @return |
| * Boolean value to indicate whether selected objects can be revealed |
| */ |
| public static boolean canReveal(Collection selection, |
| AdapterFactory adapterFactory, Suppression suppression) { |
| // check if revealing the selected elements will cause name duplication |
| // |
| String msg = suppression.checkDuplicateNameAfterReveal(selection, |
| adapterFactory); |
| if (msg != null) { |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError( |
| AuthoringUIResources.ProcessEditor_Reveal_Title, //$NON-NLS-1$ |
| msg); |
| return false; |
| } |
| |
| // check if revealing the selected elements will cause duplicate |
| // descriptors. |
| // If so, prompt user to delete the duplicates before continuing. |
| // |
| Collection duplicates = ProcessUtil |
| .getDuplicateDescriptorsAfterReveal(selection); |
| if (!duplicates.isEmpty()) { |
| MultiStatus status = new MultiStatus(AuthoringUIPlugin.getDefault() |
| .getId(), 0, "", null); //$NON-NLS-1$ |
| for (Iterator iter = duplicates.iterator(); iter.hasNext();) { |
| Descriptor desc = (Descriptor) iter.next(); |
| String descTxt = TngUtil.getTypeText(desc) |
| + ": " + desc.getPresentationName(); //$NON-NLS-1$ |
| status.add(new Status(IStatus.INFO, AuthoringUIPlugin |
| .getDefault().getId(), 0, descTxt, null)); |
| } |
| if (AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| AuthoringUIResources.ProcessEditor_Reveal_Title, //$NON-NLS-1$ |
| AuthoringUIResources.ProcessEditor_promptToDeleteBeforeReveal, //$NON-NLS-1$ |
| status) == Dialog.CANCEL) { |
| return false; |
| } |
| |
| // delete duplicate descriptors |
| try { |
| ProcessDeleteAction.delete(duplicates); |
| } catch (OperationCanceledException e) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| private static boolean hasInherited(Collection selection) { |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| if (ProcessUtil.isInherited(element)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private IPreferenceStore getPreferenceStore() { |
| // preference is managed by library plugin, |
| // since this preferences is also used for browsing and publishing |
| // Jinhua Xi 08/21/2006 |
| // IPreferenceStore store = AuthoringUIPlugin.getDefault() |
| // .getPreferenceStore(); |
| IPreferenceStore store = LibraryPlugin.getDefault() |
| .getPreferenceStore(); |
| |
| return store; |
| } |
| } |
