| /******************************************************************************* | |
| * Copyright (c) 2007-2019 Cisco Systems, Inc. | |
| * 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: | |
| * E. Dillon (Cisco Systems, Inc.) - reformat for Code Open-Sourcing | |
| *******************************************************************************/ | |
| package org.eclipse.tigerstripe.workbench.ui.internal.editors.descriptor.dependencies; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.Collections; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import org.apache.commons.lang.StringUtils; | |
| import org.eclipse.core.resources.IResource; | |
| import org.eclipse.core.runtime.NullProgressMonitor; | |
| import org.eclipse.jdt.core.ElementChangedEvent; | |
| import org.eclipse.jdt.core.IElementChangedListener; | |
| import org.eclipse.jdt.core.IJavaElement; | |
| import org.eclipse.jdt.core.IJavaElementDelta; | |
| import org.eclipse.jdt.core.IJavaProject; | |
| import org.eclipse.jdt.core.JavaCore; | |
| import org.eclipse.jface.dialogs.MessageDialog; | |
| import org.eclipse.jface.layout.GridDataFactory; | |
| import org.eclipse.jface.layout.GridLayoutFactory; | |
| import org.eclipse.jface.viewers.CheckboxTableViewer; | |
| import org.eclipse.jface.viewers.IStructuredContentProvider; | |
| import org.eclipse.jface.viewers.IStructuredSelection; | |
| import org.eclipse.jface.viewers.ITableLabelProvider; | |
| import org.eclipse.jface.viewers.LabelProvider; | |
| import org.eclipse.jface.viewers.Viewer; | |
| import org.eclipse.jface.window.Window; | |
| import org.eclipse.swt.SWT; | |
| import org.eclipse.swt.events.SelectionAdapter; | |
| import org.eclipse.swt.events.SelectionEvent; | |
| import org.eclipse.swt.graphics.Image; | |
| import org.eclipse.swt.layout.GridData; | |
| import org.eclipse.swt.widgets.Button; | |
| import org.eclipse.swt.widgets.Composite; | |
| import org.eclipse.swt.widgets.Control; | |
| import org.eclipse.swt.widgets.Display; | |
| import org.eclipse.swt.widgets.Table; | |
| import org.eclipse.swt.widgets.TableItem; | |
| import org.eclipse.tigerstripe.workbench.TigerstripeException; | |
| import org.eclipse.tigerstripe.workbench.internal.api.impl.AbstractTigerstripeProjectHandle; | |
| import org.eclipse.tigerstripe.workbench.internal.api.impl.TigerstripeProjectHandle; | |
| import org.eclipse.tigerstripe.workbench.internal.core.module.InstalledModule; | |
| import org.eclipse.tigerstripe.workbench.internal.core.project.Dependency; | |
| import org.eclipse.tigerstripe.workbench.internal.core.project.InternalTigerstripeProject; | |
| import org.eclipse.tigerstripe.workbench.internal.core.project.ModelReference; | |
| import org.eclipse.tigerstripe.workbench.project.IDependency; | |
| import org.eclipse.tigerstripe.workbench.project.IModelReference; | |
| import org.eclipse.tigerstripe.workbench.project.ITigerstripeModelProject; | |
| import org.eclipse.tigerstripe.workbench.project.ITigerstripeModelProjectInternal; | |
| import org.eclipse.tigerstripe.workbench.ui.EclipsePlugin; | |
| import org.eclipse.tigerstripe.workbench.ui.components.md.MasterDetails; | |
| import org.eclipse.tigerstripe.workbench.ui.components.md.MasterDetailsBuilder; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.dialogs.CustomTigerstripeDependenciesManager; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.dialogs.IProjectSelectionDialog; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.dialogs.TigerstripeProjectSelectionDialog; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.editors.TigerstripeFormPage; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.editors.descriptor.DescriptorEditor; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.editors.descriptor.TigerstripeDescriptorSectionPart; | |
| import org.eclipse.tigerstripe.workbench.ui.internal.utils.TigerstripeLayoutFactory; | |
| import org.eclipse.ui.forms.IManagedForm; | |
| import org.eclipse.ui.forms.widgets.ExpandableComposite; | |
| import org.eclipse.ui.forms.widgets.FormToolkit; | |
| /** | |
| * Section used to define Tigerstripe dependencies. Look under tigerstripe.xml > | |
| * Dependencies | |
| * | |
| * @author nmehrega | |
| */ | |
| public class ReferencedProjectsSection extends TigerstripeDescriptorSectionPart { | |
| private CheckboxTableViewer viewer; | |
| private Button editButton; | |
| private Button removeButton; | |
| private Button selectAllButton; | |
| private Button deselectAllButton; | |
| private MasterDetails masterDetails; | |
| private ClasspathChangesListener classpathListener; | |
| private Button modifyRuntimeDependencies; | |
| private static final String DEP_CHECKBOX_LABEL = "Modify dependencies at generation time (advanced)"; | |
| private static final String ADVANCED_PROPERTY_MODIFY_DEP_AT_RUNTIME = "modifyDependenciesAtGenerationTime"; | |
| private class ClasspathChangesListener implements IElementChangedListener { | |
| public void elementChanged(ElementChangedEvent event) { | |
| IJavaElementDelta delta = event.getDelta(); | |
| IJavaElementDelta[] childs = delta.getAffectedChildren(); | |
| for (IJavaElementDelta child : childs) { | |
| if (child.getElement().getElementType() == IJavaElement.JAVA_PROJECT) { | |
| IJavaProject jProject = (IJavaProject) child.getElement(); | |
| if (isCurrentProject(jProject) && isClassPathChanged(child)) { | |
| resolveReferencedModels(); | |
| refreshReferences(); | |
| } | |
| } | |
| } | |
| } | |
| private boolean isCurrentProject(IJavaProject jProject) { | |
| IJavaProject jTsProject = getTSProject().getAdapter(IJavaProject.class); | |
| return jTsProject != null && jTsProject.equals(jProject); | |
| } | |
| private boolean isClassPathChanged(IJavaElementDelta delta) { | |
| return (delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0 | |
| || (delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0; | |
| } | |
| private void resolveReferencedModels() { | |
| try { | |
| IModelReference[] references = getTSProject().getModelReferences(); | |
| for (IModelReference reference : references) { | |
| reference.getResolvedModel(); | |
| } | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| } | |
| private void refreshReferences() { | |
| Control control = viewer.getControl(); | |
| if (!control.isDisposed()) { | |
| control.getDisplay().asyncExec(ReferencedProjectsSection.this::refresh); | |
| } | |
| } | |
| } | |
| static class ReferencedProjectsContentProvider implements IStructuredContentProvider { | |
| public Object[] getElements(Object inputElement) { | |
| if (inputElement instanceof ITigerstripeModelProject) { | |
| ITigerstripeModelProject project = (ITigerstripeModelProject) inputElement; | |
| try { | |
| IModelReference[] modelReferences = project.getModelReferences(); | |
| IDependency[] dependencies = project.getDependencies(); | |
| Object[] elements = new Object[modelReferences.length + dependencies.length]; | |
| System.arraycopy(modelReferences, 0, elements, 0, modelReferences.length); | |
| System.arraycopy(dependencies, 0, elements, modelReferences.length, dependencies.length); | |
| return elements; | |
| } catch (TigerstripeException e) { | |
| return new Object[0]; | |
| } | |
| } | |
| return new Object[0]; | |
| } | |
| public void dispose() { | |
| // N/A | |
| } | |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { | |
| // N/A | |
| } | |
| } | |
| static class ReferencedProjectsLabelProvider extends LabelProvider implements ITableLabelProvider { | |
| public String getColumnText(Object obj, int index) { | |
| if (obj instanceof ModelReference) { | |
| ModelReference ref = (ModelReference) obj; | |
| String modelId = ref.getToModelId(); | |
| String projectName = null; | |
| String version = null; | |
| if (ref.isResolved()) { | |
| ITigerstripeModelProject project = ref.getResolvedModel(); | |
| projectName = project.getName(); | |
| try { | |
| version = project.getProjectDetails().getVersion(); | |
| } catch (Exception e) { | |
| } | |
| } | |
| StringBuilder buffer = new StringBuilder(); | |
| if (modelId != null && modelId.length() > 0) { | |
| buffer.append(modelId); | |
| } else { | |
| buffer.append(projectName); | |
| } | |
| if (version != null && version.length() > 0) { | |
| buffer.append(" ("); | |
| buffer.append(version); | |
| buffer.append(")"); | |
| } | |
| return buffer.toString(); | |
| } else if (obj instanceof IDependency) { | |
| return ((IDependency) obj).getPath(); | |
| } else { | |
| return "Unknown"; | |
| } | |
| } | |
| public Image getColumnImage(Object obj, int index) { | |
| return getImage(obj); | |
| } | |
| @Override | |
| public String getText(Object obj) { | |
| return getColumnText(obj, 0); | |
| } | |
| @Override | |
| public Image getImage(Object obj) { | |
| return IMAGE_PROVIDER.getImage(obj); | |
| } | |
| } | |
| public ReferencedProjectsSection(TigerstripeFormPage page, Composite parent, FormToolkit toolkit) { | |
| super(page, parent, toolkit, ExpandableComposite.TITLE_BAR); | |
| setTitle("Dependencies"); | |
| } | |
| @Override | |
| public void initialize(IManagedForm form) { | |
| super.initialize(form); | |
| createContent(); | |
| initializeDependencyEnablement(); | |
| classpathListener = new ClasspathChangesListener(); | |
| JavaCore.addElementChangedListener(classpathListener, ElementChangedEvent.POST_CHANGE); | |
| } | |
| private void initializeDependencyEnablement() { | |
| InternalTigerstripeProject tsProject = getActualTSProject(); | |
| String enableModificationOfDepAtRuntime = null; | |
| if (tsProject != null) | |
| enableModificationOfDepAtRuntime = tsProject.getAdvancedProperty(ADVANCED_PROPERTY_MODIFY_DEP_AT_RUNTIME); | |
| if (enableModificationOfDepAtRuntime != null && enableModificationOfDepAtRuntime.equalsIgnoreCase("true")) { | |
| modifyRuntimeDependencies.setSelection(true); | |
| int numOfDependencies = viewer.getTable().getItemCount(); | |
| for (int i = 0; i < numOfDependencies; i++) { | |
| Object element = viewer.getElementAt(i); | |
| if (element instanceof ModelReference) { | |
| ModelReference reference = (ModelReference) element; | |
| viewer.setChecked(reference, reference.isEnabled()); | |
| } else if (element instanceof IDependency) { | |
| IDependency dependency = (IDependency) element; | |
| viewer.setChecked(dependency, dependency.isEnabled()); | |
| } | |
| } | |
| selectAllButton.setEnabled(true); | |
| deselectAllButton.setEnabled(true); | |
| } else { | |
| // Dependency modification at runtime is off | |
| modifyRuntimeDependencies.setSelection(false); | |
| selectAllButton.setEnabled(false); | |
| deselectAllButton.setEnabled(false); | |
| viewer.setAllChecked(true); | |
| } | |
| } | |
| // TODO - Why do we need access to the internal project? Can we abstract it | |
| // behind the interface? | |
| private InternalTigerstripeProject getActualTSProject() { | |
| Object input = viewer.getInput(); | |
| if (input instanceof TigerstripeProjectHandle) { | |
| try { | |
| return (InternalTigerstripeProject) ((TigerstripeProjectHandle) input).getTSProject(); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.logErrorMessage("Problem occured while getting Tigerstripe Project: " | |
| + StringUtils.defaultString(e.getMessage()), e); | |
| } | |
| } | |
| return null; | |
| } | |
| @Override | |
| public void dispose() { | |
| if (classpathListener != null) { | |
| JavaCore.removeElementChangedListener(classpathListener); | |
| EclipsePlugin.getTigerStripeDependenciesManager().fireDisposed(getTSProject()); | |
| } | |
| super.dispose(); | |
| } | |
| @Override | |
| protected void createContent() { | |
| GridDataFactory.fillDefaults().grab(true, true).applyTo(getSection()); | |
| GridLayoutFactory.fillDefaults().applyTo(getSection()); | |
| GridLayoutFactory.fillDefaults().applyTo(getBody()); | |
| getSection().setClient(getBody()); | |
| Composite parent = getToolkit().createComposite(getBody()); | |
| GridDataFactory.fillDefaults().grab(true, true).applyTo(parent); | |
| GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(true).applyTo(parent); | |
| Composite masterContainer = getToolkit().createComposite(parent); | |
| Composite detailsContainer = getToolkit().createComposite(parent, SWT.NONE); | |
| GridLayoutFactory.fillDefaults().margins(1, 1).numColumns(2).applyTo(masterContainer); | |
| GridLayoutFactory.fillDefaults().applyTo(detailsContainer); | |
| GridDataFactory.fillDefaults().grab(true, true).applyTo(masterContainer); | |
| GridDataFactory.fillDefaults().grab(true, true).applyTo(detailsContainer); | |
| createTable(masterContainer, getToolkit()); | |
| modifyRuntimeDependencies = new Button(parent, SWT.CHECK); | |
| modifyRuntimeDependencies.setEnabled(true); | |
| modifyRuntimeDependencies.setText(DEP_CHECKBOX_LABEL); | |
| modifyRuntimeDependencies.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| InternalTigerstripeProject tsProject = getActualTSProject(); | |
| if (tsProject != null) { | |
| tsProject.setAdvancedProperty(ADVANCED_PROPERTY_MODIFY_DEP_AT_RUNTIME, | |
| modifyRuntimeDependencies.getSelection() ? "true" : "false"); | |
| } | |
| if (modifyRuntimeDependencies.getSelection()) { | |
| selectAllButton.setEnabled(true); | |
| deselectAllButton.setEnabled(true); | |
| if (tsProject != null) { | |
| tsProject.setDirty(); | |
| } | |
| } else { | |
| enableAllDependencies(true); | |
| selectAllButton.setEnabled(false); | |
| deselectAllButton.setEnabled(false); | |
| } | |
| markPageModified(); | |
| } | |
| }); | |
| getToolkit().paintBordersFor(masterContainer); | |
| masterDetails = MasterDetailsBuilder.create() | |
| .addDetail(ModelReference.class, getReferenceDetailsPage(getToolkit(), detailsContainer)) | |
| .addDetail(Dependency.class, new DependencyDetails(getToolkit(), detailsContainer)).build(); | |
| } | |
| private ReferenceDetails getReferenceDetailsPage(FormToolkit toolkit, Composite container){ | |
| if (CustomTigerstripeDependenciesManager.hasCustomDetailsPage()) { | |
| try { | |
| return CustomTigerstripeDependenciesManager.makeReferenceDetailsPage(toolkit, container); | |
| } catch (TigerstripeException t) { | |
| EclipsePlugin.logErrorMessage("Failure createing Custom details Page",t); | |
| } | |
| } | |
| return new ReferenceDetails(toolkit, container); | |
| } | |
| private void enableAllDependencies(boolean markAsDirty) { | |
| boolean stateChanged = false; | |
| // Walk through all dependencies and enable them. | |
| int numOfDependencies = viewer.getTable().getItemCount(); | |
| for (int i = 0; i < numOfDependencies; i++) { | |
| TableItem item = viewer.getTable().getItem(i); | |
| if (!item.getChecked()) { | |
| stateChanged = true; | |
| item.setChecked(true); | |
| Object element = viewer.getElementAt(i); | |
| if (element instanceof ModelReference) { | |
| ModelReference reference = (ModelReference) element; | |
| reference.setEnabled(true); | |
| } else if (element instanceof IDependency) { | |
| IDependency dependency = (IDependency) element; | |
| dependency.setEnabled(true); | |
| } | |
| } | |
| } | |
| InternalTigerstripeProject tsProject = getActualTSProject(); | |
| if (stateChanged && markAsDirty && tsProject != null) { | |
| tsProject.setDirty(); | |
| markPageModified(); | |
| Object input = viewer.getInput(); | |
| if (input instanceof TigerstripeProjectHandle) { | |
| ((TigerstripeProjectHandle) input).markCacheAsDirty(); | |
| } | |
| } | |
| } | |
| private void disableAllDependencies() { | |
| boolean stateChanged = false; | |
| // Walk through all dependencies and enable them. | |
| int numOfDependencies = viewer.getTable().getItemCount(); | |
| for (int i = 0; i < numOfDependencies; i++) { | |
| TableItem item = viewer.getTable().getItem(i); | |
| if (item.getChecked()) { | |
| stateChanged = true; | |
| item.setChecked(false); | |
| Object element = viewer.getElementAt(i); | |
| if (element instanceof ModelReference) { | |
| ModelReference reference = (ModelReference) element; | |
| reference.setEnabled(false); | |
| } else if (element instanceof IDependency) { | |
| IDependency dependency = (IDependency) element; | |
| dependency.setEnabled(false); | |
| } | |
| } | |
| } | |
| InternalTigerstripeProject tsProject = getActualTSProject(); | |
| if (stateChanged && tsProject != null) { | |
| tsProject.setDirty(); | |
| markPageModified(); | |
| Object input = viewer.getInput(); | |
| if (input instanceof TigerstripeProjectHandle) { | |
| ((TigerstripeProjectHandle) input).markCacheAsDirty(); | |
| } | |
| } | |
| } | |
| private void createTable(Composite parent, FormToolkit toolkit) { | |
| Table t = toolkit.createTable(parent, SWT.NULL | SWT.MULTI | SWT.CHECK); | |
| GridData gd = new GridData(GridData.FILL_BOTH); | |
| gd.verticalSpan = 2; | |
| t.setLayoutData(gd); | |
| Composite buttonsClient = toolkit.createComposite(parent); | |
| buttonsClient.setLayout(TigerstripeLayoutFactory.createButtonsGridLayout()); | |
| buttonsClient.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); | |
| // Add Dependency button | |
| Button addButton = toolkit.createButton(buttonsClient, "Add...", SWT.PUSH); | |
| addButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| addButtonSelected(); | |
| } | |
| }); | |
| addButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| // Edit Dependency button - only if there is a custom Dialog, as the built-in does not need/support this | |
| if (CustomTigerstripeDependenciesManager.hasCustomDialog()) { | |
| editButton = toolkit.createButton(buttonsClient, "Edit...", SWT.PUSH); | |
| editButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| editButtonSelected(); | |
| } | |
| }); | |
| editButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| } | |
| // Add Missing Transitive Dependency button | |
| // Need to disable this function in the case where the "custom dependency | |
| // Dialog" is set? | |
| if (CustomTigerstripeDependenciesManager.isTransitiveSupported()) { | |
| Button addMissingTransitiveDependenciesButton = toolkit.createButton(buttonsClient, "Add Transitive", | |
| SWT.PUSH); | |
| addMissingTransitiveDependenciesButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| addMissingTransitiveDependenciesButtonSelected(); | |
| } | |
| }); | |
| addMissingTransitiveDependenciesButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| } | |
| // Remove Dependency button | |
| removeButton = toolkit.createButton(buttonsClient, "Remove", SWT.PUSH); | |
| removeButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| removeButtonSelected(); | |
| } | |
| }); | |
| removeButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| // Select All button | |
| selectAllButton = toolkit.createButton(buttonsClient, "Select All", SWT.PUSH); | |
| selectAllButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| enableAllDependencies(true); | |
| } | |
| }); | |
| selectAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| // Deselect All button | |
| deselectAllButton = toolkit.createButton(buttonsClient, "Deselect All", SWT.PUSH); | |
| deselectAllButton.addSelectionListener(new SelectionAdapter() { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) { | |
| disableAllDependencies(); | |
| } | |
| }); | |
| deselectAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); | |
| viewer = new CheckboxTableViewer(t); | |
| viewer.addSelectionChangedListener(event -> { | |
| updateDetails(); | |
| updateButtonsEnablement(); | |
| }); | |
| viewer.setContentProvider(new ReferencedProjectsContentProvider()); | |
| final ITableLabelProvider labelProvider = CustomTigerstripeDependenciesManager.hasCustomLabelProvider() | |
| ? CustomTigerstripeDependenciesManager.makeLabelProvider() | |
| : new ReferencedProjectsLabelProvider(); | |
| viewer.setLabelProvider(labelProvider); | |
| ITextProvider textAdapter = obj -> labelProvider.getColumnText(obj, 0); | |
| viewer.setComparator(new DependenciesSorter(textAdapter, DEPENDENCY_KIND_RESOLVER)); | |
| AbstractTigerstripeProjectHandle handle = (AbstractTigerstripeProjectHandle) getTSProject(); | |
| viewer.setInput(handle); | |
| viewer.addCheckStateListener(event -> { | |
| if (!modifyRuntimeDependencies.getSelection()) { | |
| MessageDialog.openInformation(Display.getCurrent().getActiveShell(), "Operation Not Enabled", | |
| "To modify dependencies at generation time (i.e. run generation on certain modules), you'll need to explicitly enable the option below: '" | |
| + DEP_CHECKBOX_LABEL + "'"); | |
| viewer.setChecked(event.getElement(), true); | |
| } else { | |
| getActualTSProject().setDirty(); | |
| Object source = event.getElement(); | |
| if (source instanceof IDependency) { | |
| ((IDependency) source).setEnabled(event.getChecked()); | |
| } else if (source instanceof ModelReference) { | |
| ((ModelReference) source).setEnabled(event.getChecked()); | |
| } | |
| Object input = viewer.getInput(); | |
| if (input instanceof TigerstripeProjectHandle) { | |
| ((TigerstripeProjectHandle) input).markCacheAsDirty(); | |
| } | |
| markPageModified(); | |
| } | |
| }); | |
| } | |
| protected void editButtonSelected() { | |
| // Need the dialog with everything except the current project in! | |
| // ie INCLUDING current ref, as that's what we want to edit | |
| TableItem[] selectedItems = viewer.getTable().getSelection(); | |
| IModelReference selectedReference = null; | |
| if (selectedItems.length > 0) { | |
| Object data = selectedItems[0].getData(); | |
| if (data instanceof IModelReference) { | |
| selectedReference = (IModelReference) data; | |
| } | |
| } | |
| List<IModelReference> refList = new ArrayList<IModelReference>(); | |
| refList.add(selectedReference); | |
| IProjectSelectionDialog dialog = getDialog(refList); | |
| if (dialog != null) { | |
| dialog.setInitialProjectSelection(selectedReference); | |
| if (selectedReference != null && dialog.open() == Window.OK) { | |
| Object[] results = dialog.getResult(); | |
| for (Object res : results) { | |
| String modelId = getModelIdFromResult(res); | |
| if (StringUtils.isNotEmpty(modelId)) { | |
| try { | |
| // Here we need to replace the prior reference with our new one. | |
| // NOTE this can cause duplicates if we are not careful. | |
| getTSProject().removeModelReference(selectedReference.getToModelId()); | |
| Map<String, IModelReference> modelRefMap = new HashMap<>(); | |
| modelRefMap.put(selectedReference.getToModelId(), selectedReference); | |
| EclipsePlugin.getTigerStripeDependenciesManager().fireRemoveDependencies(getTSProject(), | |
| modelRefMap); | |
| IModelReference ref = null; | |
| for (IModelReference existingRef : getTSProject().getModelReferences()) { | |
| if (StringUtils.equals(existingRef.getToModelId(), modelId)) { | |
| ref = existingRef; | |
| break; | |
| } | |
| } | |
| if (ref == null) { | |
| ref = getTSProject().addModelReference(modelId); | |
| } | |
| viewer.refresh(true); | |
| viewer.setChecked(ref, true); // NM: Check newly added | |
| // dependency | |
| markPageModified(); | |
| if (dialog.isIncludeTransitiveDependencies()) { | |
| addMissingTransitiveDependencies(new IModelReference[] { ref }); | |
| } | |
| dialog.addDependency(); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| } | |
| } | |
| } | |
| viewer.refresh(); | |
| } | |
| } | |
| private String getModelIdFromResult(Object res) { | |
| String modelId = null; | |
| if (res instanceof IJavaProject) { | |
| IJavaProject prj = (IJavaProject) res; | |
| ITigerstripeModelProject tsPrj = prj.getProject().getAdapter(ITigerstripeModelProject.class); | |
| if (tsPrj != null) { | |
| try { | |
| modelId = tsPrj.getModelId(); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.logErrorMessage("Failed to parse model ID from project: " + tsPrj.getName(), e); | |
| } | |
| } | |
| } else if (res instanceof InstalledModule) { | |
| InstalledModule module = (InstalledModule) res; | |
| modelId = module.getModuleID(); | |
| } else if (res instanceof String) { | |
| modelId = (String) res; | |
| } | |
| return modelId; | |
| } | |
| protected IProjectSelectionDialog getDialog() { | |
| return getDialog(Collections.emptyList()); | |
| } | |
| protected IProjectSelectionDialog getDialog(List<IModelReference> allowedRefs) { | |
| Set<String> filteredOutProjects = new HashSet<>(); | |
| try { | |
| // the current project | |
| filteredOutProjects.add(getTSProject().getModelId()); | |
| // allowed Refs | |
| for (IModelReference prjRef : getTSProject().getModelReferences()) { | |
| if (!allowedRefs.contains(prjRef)) { | |
| filteredOutProjects.add(prjRef.getToModelId()); | |
| } | |
| } | |
| } catch (TigerstripeException e) { | |
| // ignore here | |
| } | |
| // Here we override the default dialog if appropriate extension point is | |
| // implemented | |
| if (CustomTigerstripeDependenciesManager.hasCustomDialog()) { | |
| try { | |
| return CustomTigerstripeDependenciesManager.makeDialog(getSection().getShell(), filteredOutProjects, | |
| getTSProject()); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.logErrorMessage("Custom Dependencies Dialog Load Error", e); | |
| } | |
| } | |
| return new TigerstripeProjectSelectionDialog(getSection().getShell(), filteredOutProjects, getTSProject()); | |
| } | |
| protected void addButtonSelected() { | |
| IProjectSelectionDialog dialog = getDialog(); | |
| if (dialog != null && dialog.open() == Window.OK) { | |
| Object[] results = dialog.getResult(); | |
| for (Object res : results) { | |
| String modelId = getModelIdFromResult(res); | |
| if (StringUtils.isNotEmpty(modelId)) { | |
| try { | |
| IModelReference ref = null; | |
| for (IModelReference existingRef : getTSProject().getModelReferences()) { | |
| if (StringUtils.equals(existingRef.getToModelId(), modelId)) { | |
| ref = existingRef; | |
| break; | |
| } | |
| } | |
| if (ref == null) { | |
| ref = getTSProject().addModelReference(modelId); | |
| } | |
| viewer.refresh(true); | |
| viewer.setChecked(ref, true); // NM: Check newly added | |
| // dependency | |
| markPageModified(); | |
| if (dialog.isIncludeTransitiveDependencies()) { | |
| addMissingTransitiveDependencies(new IModelReference[] { ref }); | |
| } | |
| dialog.addDependency(); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| continue; | |
| } | |
| if (res instanceof IResource) { | |
| try { | |
| IDependency dep = getTSProject() | |
| .makeDependency(((IResource) res).getProjectRelativePath().toOSString()); | |
| getTSProject().addDependency(dep, new NullProgressMonitor()); | |
| viewer.refresh(true); | |
| viewer.setChecked(dep, true); // NM: Check newly added | |
| // dependency | |
| markPageModified(); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| } | |
| } | |
| } | |
| viewer.refresh(); | |
| } | |
| protected void addMissingTransitiveDependenciesButtonSelected() { | |
| // Take the list of current Dependencies and work out | |
| // the list of "missing" transitive" dependencies | |
| // these could be project, or modules | |
| // check for circular/repeats. | |
| // Add the ones found, and highlight any not found in a dialog. | |
| try { | |
| IModelReference[] references = getTSProject().getModelReferences(); | |
| addMissingTransitiveDependencies(references); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| } | |
| protected void addMissingTransitiveDependencies(IModelReference[] references) { | |
| try { | |
| Set<String> existingModels = new HashSet<>(); | |
| IModelReference[] existingReferences = getTSProject().getModelReferences(); | |
| for (IModelReference ref : existingReferences) { | |
| existingModels.add(ref.getToModelId()); | |
| } | |
| existingModels.add(getTSProject().getModelId()); | |
| List<IModelReference> newRefs = new ArrayList<>(); | |
| for (IModelReference ref : references) { | |
| newRefs.addAll(getTransitiveRefs(ref)); | |
| } | |
| // deDuplicate | |
| Set<String> referencedModels = new HashSet<>(); | |
| for (IModelReference ref : newRefs) { | |
| if (!existingModels.contains(ref.getToModelId())) { | |
| referencedModels.add(ref.getToModelId()); | |
| } | |
| } | |
| // set on the model... | |
| for (String ref : referencedModels) { | |
| IModelReference newRef = getTSProject().addModelReference(ref); | |
| if (newRef.getResolvedModel() != null) { | |
| viewer.refresh(true); | |
| viewer.setChecked(newRef, true); // NM: Check newly added | |
| // dependency | |
| markPageModified(); | |
| } | |
| } | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| } | |
| // recurse on the transitive dependencies | |
| private static List<IModelReference> getTransitiveRefs(IModelReference modelRef) throws TigerstripeException { | |
| List<IModelReference> newRefs = new ArrayList<>(); | |
| if (modelRef.getResolvedModel() != null) { | |
| List<IModelReference> addedRefs = Arrays.asList(modelRef.getResolvedModel().getModelReferences()); | |
| newRefs.addAll(addedRefs); | |
| for (IModelReference ref : addedRefs) { | |
| if (!newRefs.contains(ref)) { | |
| newRefs.addAll(getTransitiveRefs(ref)); | |
| } | |
| } | |
| } | |
| return newRefs; | |
| } | |
| protected void removeButtonSelected() { | |
| TableItem[] selectedItems = viewer.getTable().getSelection(); | |
| Map<String, IModelReference> modelRefMap = new HashMap<>(); | |
| List<IDependency> dependencyFields = new ArrayList<>(); | |
| for (int i = 0; i < selectedItems.length; i++) { | |
| Object data = selectedItems[i].getData(); | |
| if (data instanceof IModelReference) { | |
| IModelReference modelRef = (ModelReference) data; | |
| modelRefMap.put(modelRef.getToModelId(), modelRef); | |
| } else if (data instanceof IDependency) { | |
| dependencyFields.add((IDependency) data); | |
| } | |
| } | |
| String message = "Do you really want to remove "; | |
| if (selectedItems.length > 1) { | |
| message = message + "these " + selectedItems.length + " items?"; | |
| } else { | |
| message = message + "this item?"; | |
| } | |
| MessageDialog msgDialog = new MessageDialog(getBody().getShell(), "Remove Reference/Dependency", null, message, | |
| MessageDialog.QUESTION, new String[] { "Yes", "No" }, 1); | |
| if (msgDialog.open() == 0) { | |
| ITigerstripeModelProjectInternal handle = getTSProject(); | |
| try { | |
| handle.removeModelReferences(modelRefMap.keySet().stream().toArray(String[]::new)); | |
| handle.removeDependencies(dependencyFields.toArray(new IDependency[0]), new NullProgressMonitor()); | |
| } catch (TigerstripeException e) { | |
| EclipsePlugin.log(e); | |
| } | |
| EclipsePlugin.getTigerStripeDependenciesManager().fireRemoveDependencies(getTSProject(), modelRefMap); | |
| markPageModified(); | |
| viewer.refresh(true); | |
| } | |
| } | |
| protected void markPageModified() { | |
| DescriptorEditor editor = (DescriptorEditor) getPage().getEditor(); | |
| editor.pageModified(); | |
| } | |
| @Override | |
| public void refresh() { | |
| if (viewer.getTable().isDisposed()) { | |
| return; | |
| } | |
| updateViewerInput(); | |
| updateDetails(); | |
| // Don't mark the page as dirty after a refresh. | |
| if (!modifyRuntimeDependencies.getSelection()) { | |
| enableAllDependencies(false); | |
| } | |
| updateButtonsEnablement(); | |
| } | |
| private void updateDetails() { | |
| masterDetails.switchTo(((IStructuredSelection) viewer.getSelection()).getFirstElement()); | |
| } | |
| private void updateButtonsEnablement() { | |
| TableItem[] selectedItems = viewer.getTable().getSelection(); | |
| if (editButton != null) { | |
| editButton.setEnabled(selectedItems != null && selectedItems.length > 0); | |
| } | |
| removeButton.setEnabled(selectedItems != null && selectedItems.length > 0); | |
| } | |
| // [nmehrega] Bugzilla 322566: Update the viewer's input if our working copy | |
| // of TS Project has changed. | |
| // This, for example, happens when the project descriptor is modified and | |
| // saved. | |
| private void updateViewerInput() { | |
| Object tsProjectWorkingCopy = getTSProject(); | |
| if (!viewer.getTable().isDisposed()) { | |
| viewer.setInput(tsProjectWorkingCopy); | |
| initializeDependencyEnablement(); | |
| } | |
| } | |
| private static final IDependencyKindResolver DEPENDENCY_KIND_RESOLVER = obj -> { | |
| if (obj instanceof ModelReference) { | |
| ModelReference ref = (ModelReference) obj; | |
| if (ref.isResolved()) { | |
| if (ref.isWorkspaceReference()) { | |
| return DependencyKind.PROJECT; | |
| } else if (ref.isInstalledModuleReference()) { | |
| return DependencyKind.MODULE; | |
| } | |
| } | |
| } | |
| if (obj instanceof IDependency) { | |
| return DependencyKind.DEPENDENCY; | |
| } | |
| return DependencyKind.UNKNOWN; | |
| }; | |
| public static final DependenciesImageProvider IMAGE_PROVIDER = new DependenciesImageProvider( | |
| DEPENDENCY_KIND_RESOLVER); | |
| } |