| //------------------------------------------------------------------------------ |
| // 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.properties; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.draw2d.ColorConstants; |
| 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.AuthoringUIText; |
| import org.eclipse.epf.authoring.ui.dialogs.ItemsFilterDialog; |
| import org.eclipse.epf.authoring.ui.editors.ProcessEditor; |
| import org.eclipse.epf.authoring.ui.filters.ActivityVariabilityFilter; |
| import org.eclipse.epf.authoring.ui.forms.ProcessBreakdownStructureFormPage; |
| import org.eclipse.epf.authoring.ui.views.ProcessViewer; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInput; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy; |
| import org.eclipse.epf.diagram.core.providers.SharedResourceDiagramDocumentProvider; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.configuration.ProcessVariabilityConfigurator; |
| import org.eclipse.epf.library.edit.IConfigurator; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.command.IActionManager; |
| import org.eclipse.epf.library.edit.itemsfilter.FilterConstants; |
| import org.eclipse.epf.library.edit.process.IBSItemProvider; |
| import org.eclipse.epf.library.edit.process.command.ActivityVariabilityCommand; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.validation.DependencyChecker; |
| import org.eclipse.epf.library.ui.LibraryUIText; |
| import org.eclipse.epf.library.ui.dialogs.ConvertActivityDialog; |
| 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.Iteration; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.Phase; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.epf.uma.VariabilityType; |
| import org.eclipse.epf.uma.util.Scope; |
| import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocumentProvider; |
| import org.eclipse.jface.viewers.ComboViewer; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * The general tab section for Activity |
| * |
| * @author Shilpa Toraskar |
| * @author Phong Nguyen Le |
| * @since 1.0 |
| * |
| */ |
| public class ActivityGeneralSection extends WorkBreakdownElementGeneralSection { |
| protected Activity element; |
| |
| private static final String NOT_APPLICABLE_TEXT = AuthoringUIResources.notApplicable_text; |
| |
| private static final String CONTRIBUTES_TEXT = AuthoringUIResources.contributes_text; |
| |
| private static final String EXTENDS_TEXT = AuthoringUIResources.extends_text; |
| |
| private static final String REPLACES_TEXT = AuthoringUIResources.replaces_text; |
| |
| private Text modelInfoText; |
| |
| private Label activityTypeLabel; |
| |
| private Text ctrl_type_text; |
| |
| private Button ctrl_type_button; |
| |
| private Combo ctrl_variability; |
| |
| private ComboViewer viewer_variability; |
| |
| private Text baseText; |
| |
| private Button selectButton; |
| |
| protected ILabelProvider variabilityLabelProvider = new AdapterFactoryLabelProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public String getText(Object object) { |
| VariabilityType varObject = (VariabilityType) object; |
| if (varObject == VariabilityType.NA) |
| return NOT_APPLICABLE_TEXT; |
| if (varObject == VariabilityType.CONTRIBUTES) |
| return CONTRIBUTES_TEXT; |
| if (varObject == VariabilityType.EXTENDS) |
| return EXTENDS_TEXT; |
| if (varObject == VariabilityType.REPLACES) |
| return REPLACES_TEXT; |
| return null; |
| } |
| }; |
| |
| private IContentProvider variabilityContentProvider = new AdapterFactoryContentProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public Object[] getElements(Object object) { |
| List variabilityTypesList = new ArrayList(); |
| variabilityTypesList.add(VariabilityType.NA); |
| variabilityTypesList.add(VariabilityType.CONTRIBUTES); |
| variabilityTypesList.add(VariabilityType.EXTENDS); |
| variabilityTypesList.add(VariabilityType.REPLACES); |
| return variabilityTypesList.toArray(); |
| } |
| }; |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.properties.WorkBreakdownElementGeneralSection#init() |
| */ |
| protected void init() { |
| super.init(); |
| // get activity object |
| element = (Activity) getElement(); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.properties.WorkBreakdownElementGeneralSection#createGeneralSection(org.eclipse.swt.widgets.Composite) |
| */ |
| protected void createGeneralSection(Composite composite) { |
| super.createGeneralSection(composite); |
| |
| // Model Info |
| FormUI.createLabel(toolkit, generalComposite, |
| PropertiesResources.Activity_ModelInfo); |
| |
| modelInfoText = FormUI.createText(toolkit, generalComposite, |
| SWT.DEFAULT, horizontalSpan); |
| // modelInfoText.setEnabled(false); |
| modelInfoText.setEditable(false); |
| modelInfoText.setText(getModelInfo()); |
| modelInfoText.setForeground(ColorConstants.gray); |
| |
| // Type of an Activity |
| activityTypeLabel = FormUI.createLabel(toolkit, generalComposite, |
| PropertiesResources.Activity_Type); |
| |
| ctrl_type_text = toolkit.createText(generalComposite, "", SWT.READ_ONLY); //$NON-NLS-1$ |
| { |
| GridData gridData = new GridData(GridData.BEGINNING | GridData.FILL_HORIZONTAL); |
| gridData.horizontalSpan = 1; |
| ctrl_type_text.setLayoutData(gridData); |
| } |
| ctrl_type_button = toolkit.createButton(generalComposite, |
| AuthoringUIText.CHANGE_TYPE_BUTTON_TEXT, SWT.PUSH); |
| { |
| GridData gridData = new GridData(GridData.BEGINNING); |
| gridData.horizontalSpan = 1; |
| ctrl_type_button.setLayoutData(gridData); |
| } |
| if (ConvertActivityDialog.getValidNewActivityTypes(element) == null) { |
| ctrl_type_button.setVisible(false); |
| } |
| |
| FormUI.createLabel(toolkit, generalComposite, ""); //$NON-NLS-1$ |
| |
| // Variability Type |
| FormUI.createLabel(toolkit, generalComposite, |
| AuthoringUIText.VARIABILITY_TYPE_TEXT); |
| |
| ctrl_variability = FormUI.createCombo(toolkit, generalComposite, 2); |
| { |
| GridData gridData = new GridData(GridData.BEGINNING); |
| gridData.horizontalSpan = 1; |
| ctrl_variability.setLayoutData(gridData); |
| } |
| |
| viewer_variability = new ComboViewer(ctrl_variability); |
| viewer_variability.getCombo().setLayoutData(new GridData(1)); |
| viewer_variability.setContentProvider(variabilityContentProvider); |
| viewer_variability.setLabelProvider(variabilityLabelProvider); |
| viewer_variability.setInput(element); |
| |
| Label blankLabel = FormUI.createLabel(toolkit, generalComposite, ""); //$NON-NLS-1$ |
| { |
| GridData gridData = new GridData(GridData.BEGINNING); |
| gridData.horizontalSpan = 2; |
| blankLabel.setLayoutData(gridData); |
| } |
| |
| // Base elements |
| FormUI.createLabel(toolkit, generalComposite, |
| AuthoringUIText.BASE_ELEMENT_TEXT); |
| |
| baseText = FormUI.createText(toolkit, generalComposite); |
| { |
| GridData gd = new GridData(GridData.BEGINNING |
| | GridData.FILL_HORIZONTAL); |
| gd.horizontalSpan = 2; |
| baseText.setLayoutData(gd); |
| } |
| baseText.setEnabled(false); |
| |
| // Button to select |
| selectButton = FormUI.createButton(toolkit, generalComposite, |
| AuthoringUIText.SELECT_BUTTON_TEXT); |
| } |
| |
| private List<AbstractDiagramEditor> getDirtyDiagramEditors() { |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| org.eclipse.epf.uma.Process process = TngUtil.getOwningProcess(element); |
| ArrayList<AbstractDiagramEditor> dirtyEditors = new ArrayList<AbstractDiagramEditor>(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof AbstractDiagramEditor && editor.isDirty()) { |
| IEditorInput input = editor.getEditorInput(); |
| if (input instanceof DiagramEditorInputProxy) { |
| DiagramEditorInput diagramInput = ((DiagramEditorInputProxy) input).getDiagramEditorInput(); |
| if (diagramInput != null) { |
| MethodElement element = diagramInput.getMethodElement(); |
| if(element instanceof BreakdownElement && process == TngUtil.getOwningProcess((BreakdownElement)element)) { |
| dirtyEditors.add((AbstractDiagramEditor) editor); |
| } |
| } |
| } |
| } |
| } |
| return dirtyEditors; |
| } |
| |
| /** |
| * add listeners |
| */ |
| protected void addListeners() { |
| super.addListeners(); |
| ctrl_type_button.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| final ProcessEditor editor = (ProcessEditor) getEditor(); |
| // allow changing type only if the process editor and all of its diagram editors are not dirty |
| // |
| if (editor.isDirty() || !getDirtyDiagramEditors().isEmpty()) { |
| String title = AuthoringUIResources.changeActivityTypeWarningDialog_title; |
| String message = AuthoringUIResources.descriptionTabGuidanceWarningDialog_message1; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayWarning(title, message); |
| } else { |
| nameText.removeListener(SWT.Deactivate, |
| nameDeactivateListener); |
| presentationNameText.removeListener(SWT.Deactivate, |
| presentationNameDeactivateListener); |
| |
| Activity newActivity = ConvertActivityDialog |
| .queryUserAndConvert((Activity) element, null, null); |
| |
| if (newActivity != null) { |
| IStructuredSelection sel = new StructuredSelection( |
| newActivity); |
| // deal with property sheet directly. |
| getPropertySheetPage().selectionChanged(getPart(), |
| sel); |
| // getEditor().setSelection(sel); |
| refresh(); |
| ((ProcessViewer) ((ProcessBreakdownStructureFormPage) getEditor() |
| .getActivePageInstance()).getViewer()) |
| .expandToLevel(newActivity, 3); |
| } |
| nameText.addListener(SWT.Deactivate, |
| nameDeactivateListener); |
| presentationNameText.addListener(SWT.Deactivate, |
| presentationNameDeactivateListener); |
| |
| Display.getCurrent().asyncExec(new Runnable() { |
| |
| public void run() { |
| // refresh any dirty diagram editor and clear the dirty flag |
| // |
| List<AbstractDiagramEditor> dirtyDiagramEditors = getDirtyDiagramEditors(); |
| for (AbstractDiagramEditor diagramEditor : dirtyDiagramEditors) { |
| diagramEditor.refresh(); |
| IDocumentProvider docProvider = diagramEditor.getDocumentProvider(); |
| if(docProvider instanceof SharedResourceDiagramDocumentProvider) { |
| ((SharedResourceDiagramDocumentProvider)docProvider).markDocumentAsSaved((IFileEditorInput) diagramEditor.getEditorInput()); |
| } |
| } |
| } |
| |
| }); |
| } |
| } |
| |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| }); |
| |
| ctrl_variability.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent event) { |
| IStructuredSelection selection = (IStructuredSelection) viewer_variability |
| .getSelection(); |
| |
| VariabilityElement ve = element.getVariabilityBasedOnElement(); |
| VariabilityType type = (VariabilityType) selection |
| .getFirstElement(); |
| |
| if (ve != null & ve instanceof Activity) { |
| // if(type.equals(VariabilityType.REPLACES_LITERAL) |
| // && ve instanceof Process){ |
| // Object[] args = { element.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.activity_variability_error_msg1, |
| // args); |
| // |
| // String title = AuthoringUIResources.activity_variability_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // VariabilityType vtype = element.getVariabilityType(); |
| // if(vtype != null){ |
| // IStructuredSelection sel = new StructuredSelection(vtype); |
| // viewer_variability.setSelection(sel); |
| // } |
| // return; |
| // } |
| // if (ProcessUtil.hasContributorOrReplacer((Activity) ve) |
| // && type.equals(VariabilityType.EXTENDS_LITERAL)) { |
| // Object[] args = { element.getName(), |
| // ((Activity) ve).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$ |
| // |
| // VariabilityType variabilityType = element |
| // .getVariabilityType(); |
| // IStructuredSelection newVariabilitySelection = new StructuredSelection( |
| // variabilityType); |
| // viewer_variability.setSelection( |
| // newVariabilitySelection, true); |
| // |
| // return; |
| // } |
| |
| if(type != VariabilityType.NA) { |
| IStatus state = DependencyChecker.checkCircularDependencyAfterFilterSelection(element, (Activity) ve, type); |
| if(!state.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError(title, state.getMessage()); |
| |
| // set variability to back whatever it was for UI |
| VariabilityType variabilityType = element.getVariabilityType(); |
| IStructuredSelection newVariabilitySelection = new StructuredSelection( |
| variabilityType); |
| viewer_variability.setSelection(newVariabilitySelection, true); |
| return; |
| } |
| } |
| boolean status = actionMgr.doAction(IActionManager.SET, |
| element, UmaPackage.eINSTANCE |
| .getVariabilityElement_VariabilityType(), |
| type, -1); |
| if (!status) { |
| if (element.getPresentationName() == null |
| || element.getPresentationName().equals("")) { //$NON-NLS-1$ |
| if (type.equals(VariabilityType.NA)) |
| element.setPresentationName(element.getName()); |
| } |
| return; |
| } |
| if (element.getPresentationName() == null |
| || element.getPresentationName().equals("")) { //$NON-NLS-1$ |
| if (type.equals(VariabilityType.CONTRIBUTES) |
| || type.equals(VariabilityType.REPLACES) |
| || type.equals(VariabilityType.NA)) |
| element.setPresentationName(element.getName()); |
| } |
| } |
| |
| if (type == VariabilityType.NA) { |
| if (ve != null) { |
| boolean status = actionMgr |
| .doAction( |
| IActionManager.SET, |
| element, |
| UmaPackage.eINSTANCE |
| .getVariabilityElement_VariabilityBasedOnElement(), |
| null, -1); |
| |
| if (!status) { |
| return; |
| } |
| } |
| selectButton.setEnabled(false); |
| baseText.setText(""); //$NON-NLS-1$ |
| } else { |
| List selectionBaseList = new ArrayList(); |
| VariabilityElement base = element |
| .getVariabilityBasedOnElement(); |
| selectionBaseList.add(base); |
| selectButton.setEnabled(true); |
| |
| } |
| // setFormTextWithVariableInfo(); |
| } |
| }); |
| |
| selectButton.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| MethodConfiguration config = getConfiguration(); |
| if (config instanceof Scope) { |
| config = LibraryService.getInstance().getCurrentMethodConfiguration(); |
| } |
| String tabName = FilterConstants.ACTIVITIES; |
| |
| VariabilityType type = (VariabilityType) ((IStructuredSelection) viewer_variability |
| .getSelection()).getFirstElement(); |
| |
| IFilter filter = new ActivityVariabilityFilter(config, null, |
| tabName, element); |
| |
| ItemsFilterDialog fd = new ItemsFilterDialog(PlatformUI |
| .getWorkbench().getActiveWorkbenchWindow().getShell(), |
| filter, tabName, null, config); |
| fd.setBlockOnOpen(true); |
| fd.setViewerSelectionSingle(true); |
| fd.setTitle(tabName); |
| fd.open(); |
| |
| List selectedItems = fd.getSelectedItems(); |
| |
| if (selectedItems != null && !selectedItems.isEmpty()) { |
| Object o = selectedItems.get(0); |
| if (o instanceof Activity) { |
| // Activity act = (Activity) o; |
| // if (isDirectParent(act) |
| // || ((act instanceof Process) && type.equals(VariabilityType.REPLACES_LITERAL) |
| // && !(element instanceof Process))) |
| // { |
| // Object[] args = { element.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.activity_variability_error_msg1, |
| // args); |
| // |
| // String title = AuthoringUIResources.activity_variability_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // |
| // return; |
| // } |
| // if (isCircularDependency(act)) { |
| // Object[] args = { element.getName(), act.getName() }; |
| // String message = AuthoringUIResources |
| // .bind( |
| // AuthoringUIResources.activity_variability_error_msg2, |
| // args); |
| // |
| // String title = AuthoringUIResources.activity_variability_error_title; |
| // AuthoringUIPlugin.getDefault().getMsgDialog() |
| // .displayError(title, message, ""); //$NON-NLS-1$ |
| // |
| // return; |
| // } |
| // // block for children |
| // if (ProcessUtil.hasContributorOrReplacer(act) |
| // && type.equals(VariabilityType.EXTENDS_LITERAL)) { |
| // Object[] args = { element.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$ |
| // |
| // return; |
| // } |
| |
| IStatus status = DependencyChecker.checkCircularDependencyAfterFilterSelection(element, (Activity) o, type); |
| if(!status.isOK()) { |
| String title = AuthoringUIResources.activity_variability_error_title; |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError(title, status.getMessage()); |
| return; |
| } |
| } |
| if (o instanceof VariabilityElement) { |
| VariabilityElement ve = (VariabilityElement) o; |
| |
| IConfigurator configurator = new ProcessVariabilityConfigurator( |
| getDefaultConfiguration()); |
| ActivityVariabilityCommand cmd = new ActivityVariabilityCommand( |
| element, ve, type, configurator); |
| boolean status = actionMgr.execute(cmd); |
| |
| if (!status) { |
| return; |
| } |
| |
| baseText.setText(TngUtil.getLabelWithPath(ve)); |
| } |
| } |
| } |
| }); |
| |
| } |
| |
| /** |
| * Get model information for the activity |
| * @return |
| * model info string |
| */ |
| private String getModelInfo() { |
| String info = null; |
| |
| try { |
| Object o = getAdapter(); |
| if (o instanceof IBSItemProvider) { |
| IBSItemProvider adapter = (IBSItemProvider) o; |
| info = adapter.getAttribute(element, |
| IBSItemProvider.COL_MODEL_INFO); |
| } |
| } catch (Exception e) { |
| // print exception |
| } |
| if (!(StrUtil.isBlank(info))) |
| return info; |
| else |
| return PropertiesResources.Process_None; |
| } |
| |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.properties.WorkBreakdownElementGeneralSection#updateControls() |
| */ |
| protected void updateControls() { |
| super.updateControls(); |
| |
| ctrl_type_button.setEnabled(editable); |
| ctrl_variability.setEnabled(editable); |
| selectButton.setEnabled(editable); |
| |
| ctrl_variability.setEnabled(editable); |
| if (((IStructuredSelection) viewer_variability.getSelection()) |
| .getFirstElement() == VariabilityType.NA) { |
| selectButton.setEnabled(false); |
| } |
| } |
| |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.properties.WorkBreakdownElementGeneralSection#refresh() |
| */ |
| public void refresh() { |
| try { |
| if (getElement() instanceof Activity) { |
| super.refresh(); |
| |
| element = (Activity) getElement(); |
| |
| modelInfoText.setText(getModelInfo()); |
| |
| ctrl_type_text.setText(PropertiesUtil.getType(element)); |
| |
| // hide/show combo |
| if ((element instanceof org.eclipse.epf.uma.Process) |
| && (element.getSuperActivities() == null || element |
| .getSuperActivities() == null)) { |
| activityTypeLabel.setVisible(false); |
| ctrl_type_text.setVisible(false); |
| ctrl_type_button.setVisible(false); |
| } else { |
| activityTypeLabel.setVisible(true); |
| ctrl_type_text.setVisible(true); |
| ctrl_type_button.setVisible(true); |
| } |
| |
| VariabilityType variabilityType = element.getVariabilityType(); |
| IStructuredSelection newVariabilitySelection = new StructuredSelection( |
| variabilityType); |
| viewer_variability.setSelection(newVariabilitySelection, true); |
| |
| if (element.getVariabilityBasedOnElement() != null) |
| baseText.setText(TngUtil.getLabelWithPath(element |
| .getVariabilityBasedOnElement())); |
| else |
| baseText.setText(""); //$NON-NLS-1$ |
| |
| // make variability type combo disabled incase type is either local contributes or local replaces. |
| if (variabilityType |
| .equals(VariabilityType.LOCAL_CONTRIBUTION) |
| || (variabilityType |
| .equals(VariabilityType.LOCAL_REPLACEMENT))) { |
| IStructuredSelection selection = new StructuredSelection( |
| VariabilityType.NA); |
| viewer_variability.setSelection(selection); |
| ctrl_variability.setEnabled(false); |
| } else |
| ctrl_variability.setEnabled(editable); |
| } |
| } catch (Exception ex) { |
| logger |
| .logError( |
| "Error refreshing Activity general section : " + element, ex); //$NON-NLS-1$ |
| } |
| } |
| |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.properties.WorkBreakdownElementGeneralSection#getNamePrefix() |
| */ |
| public String getNamePrefix() { |
| if (element instanceof CapabilityPattern) { |
| return LibraryUIText.TEXT_CAPABILITY_PATTERN + ": "; //$NON-NLS-1$ |
| } else if (element instanceof DeliveryProcess) { |
| return LibraryUIText.TEXT_DELIVERY_PROCESS + ": "; //$NON-NLS-1$ |
| } else if (element instanceof Phase) { |
| return LibraryUIText.TEXT_PHASE + ": "; //$NON-NLS-1$ |
| } else if (element instanceof Iteration) { |
| return LibraryUIText.TEXT_ITERATION + ": "; //$NON-NLS-1$ |
| } else |
| return LibraryUIText.TEXT_ACTIVITY + ": "; //$NON-NLS-1$ |
| } |
| |
| } |
