| /*******************************************************************************
|
| * Copyright (c) 2011, 2019 Mia-Software and others.
|
| * All rights reserved. This program and the accompanying materials
|
| * are made available under the terms of the Eclipse Public License v2.0
|
| * which accompanies this distribution, and is available at
|
| * http://www.eclipse.org/legal/epl-v20.html
|
| *
|
| * Contributors:
|
| * Nicolas Bros (Mia-Software) - Bug 335003 - [Discoverer] : Existing Discoverers Refactoring based on new framework
|
| * Nicolas Bros (Mia-Software) - Bug 342548 - [Java Discovery] Illegal parameter initializer for ELEMENTS_TO_ANALYZE
|
| *******************************************************************************/ |
| package org.eclipse.modisco.java.discoverer.ui.internal;
|
|
|
| import java.io.File;
|
| import java.util.Map;
|
| import java.util.Set;
|
|
|
| import org.eclipse.jdt.core.IJavaProject;
|
| import org.eclipse.jdt.core.IPackageFragmentRoot;
|
| import org.eclipse.jdt.core.JavaModelException;
|
| import org.eclipse.jdt.ui.JavaElementLabelProvider;
|
| import org.eclipse.jface.dialogs.IDialogSettings;
|
| import org.eclipse.jface.dialogs.TitleAreaDialog;
|
| import org.eclipse.jface.viewers.CellEditor;
|
| import org.eclipse.jface.viewers.CheckStateChangedEvent;
|
| import org.eclipse.jface.viewers.CheckboxCellEditor;
|
| import org.eclipse.jface.viewers.CheckboxTreeViewer;
|
| import org.eclipse.jface.viewers.ColumnLabelProvider;
|
| import org.eclipse.jface.viewers.ColumnViewer;
|
| import org.eclipse.jface.viewers.EditingSupport;
|
| import org.eclipse.jface.viewers.ICheckStateListener;
|
| import org.eclipse.jface.viewers.ILabelProviderListener;
|
| import org.eclipse.jface.viewers.ITreeContentProvider;
|
| import org.eclipse.jface.viewers.TreeViewerColumn;
|
| import org.eclipse.jface.viewers.Viewer;
|
| import org.eclipse.modisco.infra.common.core.logging.MoDiscoLogger;
|
| import org.eclipse.modisco.java.discoverer.AbstractDiscoverJavaModelFromProject;
|
| import org.eclipse.modisco.java.discoverer.ElementsToAnalyze;
|
| import org.eclipse.swt.SWT;
|
| import org.eclipse.swt.graphics.Color;
|
| import org.eclipse.swt.graphics.Image;
|
| import org.eclipse.swt.layout.GridData;
|
| import org.eclipse.swt.layout.GridLayout;
|
| import org.eclipse.swt.layout.RowLayout;
|
| import org.eclipse.swt.widgets.Composite;
|
| import org.eclipse.swt.widgets.Control;
|
| import org.eclipse.swt.widgets.Display;
|
| import org.eclipse.swt.widgets.Label;
|
| import org.eclipse.swt.widgets.Shell;
|
| import org.eclipse.ui.PlatformUI;
|
|
|
| public class JavaElementsToAnalyzeDialog extends TitleAreaDialog {
|
|
|
| private static final int COLUMN_USE_SOURCE_WIDTH = 130;
|
|
|
| private static final int COLUMN_DEPENDENCY_SHORTNAME_WIDTH = 400;
|
|
|
| private static final int COLUMN_DEPENDENCY_LONGNAME_WIDTH = 200;
|
|
|
| private static final int DIALOG_WIDTH = 800;
|
|
|
| private static final int DIALOG_HEIGHT = 700;
|
|
|
| private static final String USE_SOURCES_OPTIONS = "USE_SOURCES"; //$NON-NLS-1$
|
|
|
| private final ElementsToAnalyze elementsToAnalyze;
|
|
|
| /** the tree to selected the dependencies to discover */
|
| private CheckboxTreeViewer dependenciesTree;
|
|
|
| /**
|
| * the label which shows the number of selected projects/libraries.
|
| */
|
| private Label textNumberElementsSelected;
|
|
|
| /**
|
| * @param parentShell
|
| * the parent shell
|
| * @param discoverableElements
|
| * elements that can be chosen for analysis
|
| * @param initialElementsToAnalyze
|
| * the initial selection of elements to analyze with their
|
| * associated options
|
| */
|
| protected JavaElementsToAnalyzeDialog(final Shell parentShell,
|
| final ElementsToAnalyze initialElementsToAnalyze) {
|
| super(parentShell);
|
| if (initialElementsToAnalyze != null) {
|
| this.elementsToAnalyze = AbstractDiscoverJavaModelFromProject
|
| .computeElementsToDiscover(initialElementsToAnalyze);
|
| } else {
|
| throw new IllegalStateException(
|
| "initialElementsToAnalyze is null. It should be initialized (cf @ParameterInitialValue)"); //$NON-NLS-1$
|
| }
|
| }
|
|
|
| @Override
|
| protected Control createDialogArea(final Composite parent) {
|
| Composite composite = (Composite) super.createDialogArea(parent);
|
| composite.setLayout(new GridLayout());
|
|
|
| setTitle(Messages.JavaElementsToAnalyzeDialog_title);
|
| setMessage(Messages.JavaElementsToAnalyzeDialog_message);
|
|
|
| final CheckboxTreeViewer treeViewer = new CheckboxTreeViewer(composite,
|
| SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE
|
| | SWT.FULL_SELECTION);
|
| this.dependenciesTree = treeViewer;
|
|
|
| treeViewer.addCheckStateListener(new ICheckStateListener() {
|
| public void checkStateChanged(final CheckStateChangedEvent event) {
|
|
|
| Object element = event.getElement();
|
| if (event.getChecked()) {
|
| getElementsToAnalyze().addElementToDiscover(element);
|
| } else {
|
| getElementsToAnalyze().removeElementToDiscover(element);
|
| }
|
|
|
| treeViewer.update(event.getElement(), null);
|
| refreshInformationLabel();
|
| }
|
| });
|
| treeViewer.getTree().setLinesVisible(true);
|
| treeViewer.getTree().setHeaderVisible(true);
|
|
|
| TreeViewerColumn columnShortName = new TreeViewerColumn(
|
| getDependenciesTree(), SWT.NONE);
|
| columnShortName.getColumn().setWidth(
|
| JavaElementsToAnalyzeDialog.COLUMN_DEPENDENCY_SHORTNAME_WIDTH);
|
| columnShortName.getColumn().setText(
|
| Messages.JavaElementsToAnalyzeDialog_name);
|
| columnShortName.setLabelProvider(new JDTDelegateColumnLabelProvider(
|
| true));
|
|
|
| TreeViewerColumn columnUseSource = new TreeViewerColumn(
|
| getDependenciesTree(), SWT.NONE);
|
| columnUseSource.getColumn().setWidth(
|
| JavaElementsToAnalyzeDialog.COLUMN_USE_SOURCE_WIDTH);
|
| columnUseSource.getColumn().setText(
|
| Messages.JavaElementsToAnalyzeDialog_useSources);
|
| columnUseSource.getColumn().setAlignment(SWT.CENTER);
|
| columnUseSource.setLabelProvider(new UseSourceColumnLabelProvider());
|
|
|
| columnUseSource.setEditingSupport(new UseSourceEditingSupport(
|
| getDependenciesTree()));
|
|
|
| TreeViewerColumn columnLongName = new TreeViewerColumn(
|
| getDependenciesTree(), SWT.NONE);
|
| columnLongName.getColumn().setWidth(
|
| JavaElementsToAnalyzeDialog.COLUMN_DEPENDENCY_LONGNAME_WIDTH);
|
| columnLongName.getColumn().setText(
|
| Messages.JavaElementsToAnalyzeDialog_Path);
|
| columnLongName.setLabelProvider(new JDTDelegateColumnLabelProvider(
|
| false));
|
|
|
| treeViewer.getTree().setLayoutData(
|
| new GridData(SWT.FILL, SWT.FILL, true, true));
|
|
|
| DependenciesContentProvider contentProvider = new DependenciesContentProvider();
|
| getDependenciesTree().setContentProvider(contentProvider);
|
| DependenciesTreeInput input = new DependenciesTreeInput(
|
| this.elementsToAnalyze.getJavaProject());
|
| getDependenciesTree().setInput(input);
|
|
|
| // check and expand the elements which are selected
|
| Object[] elements = contentProvider.getElements(input);
|
| for (Object element : elements) {
|
| if (getElementsToAnalyze().getElementsToDiscover()
|
| .contains(element)) {
|
| getDependenciesTree().setChecked(element, true);
|
| getDependenciesTree().expandToLevel(element, 1);
|
| }
|
| Object[] children = contentProvider.getChildren(element);
|
| for (Object child : children) {
|
| if (getElementsToAnalyze().getElementsToDiscover().contains(
|
| child)) {
|
| getDependenciesTree().setChecked(child, true);
|
| }
|
| }
|
| }
|
|
|
| // "n selected" label at the bottom of the dialog
|
| Composite compositeLabels = new Composite(composite, SWT.NONE);
|
| compositeLabels.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
|
| false));
|
|
|
| RowLayout rowLayout = new RowLayout();
|
| rowLayout.wrap = false;
|
| compositeLabels.setLayout(rowLayout);
|
|
|
| Label imageInformationNumberElementsSelected = new Label(
|
| compositeLabels, SWT.NONE);
|
| imageInformationNumberElementsSelected.setImage(PlatformUI
|
| .getWorkbench().getSharedImages()
|
| .getImage(org.eclipse.ui.ISharedImages.IMG_OBJS_INFO_TSK));
|
|
|
| this.textNumberElementsSelected = new Label(compositeLabels, SWT.NONE);
|
| refreshInformationLabel();
|
|
|
| return composite;
|
|
|
| }
|
|
|
| protected static boolean hasSourceAvailable(final Object element) {
|
| if (element instanceof IPackageFragmentRoot) {
|
| IPackageFragmentRoot lib = (IPackageFragmentRoot) element;
|
| try {
|
| return lib.getSourceAttachmentPath() != null;
|
| } catch (JavaModelException e) {
|
| MoDiscoLogger.logError(e, Activator.getDefault());
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| protected void refreshInformationLabel() {
|
|
|
| int nProjectsSelected = 0;
|
| int nLibrariesSelected = 0;
|
|
|
| // we count the checked elements in the tree
|
| // if the user wants to discover dependencies
|
| for (Object element : getDependenciesTree().getCheckedElements()) {
|
| if (element instanceof IJavaProject) {
|
| nProjectsSelected++;
|
| } else if (element instanceof IPackageFragmentRoot) {
|
| nLibrariesSelected++;
|
| }
|
| }
|
|
|
| StringBuilder builder = new StringBuilder();
|
| builder.append(nProjectsSelected);
|
| if (nProjectsSelected > 1) {
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_projects);
|
| } else {
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_project);
|
| }
|
|
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_and);
|
| builder.append(nLibrariesSelected);
|
| if (nLibrariesSelected > 1) {
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_libraries);
|
| } else {
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_library);
|
| }
|
| builder.append(Messages.JavaElementsToAnalyzeDialog_selected);
|
|
|
| this.textNumberElementsSelected.setText(builder.toString());
|
| this.textNumberElementsSelected.pack(true);
|
| }
|
|
|
| /**
|
| * because JFace doesn't like the input to be in the list of elements (leads
|
| * to recursion)
|
| */
|
| protected class DependenciesTreeInput {
|
| private final IJavaProject javaProject;
|
|
|
| public DependenciesTreeInput(final IJavaProject javaProject) {
|
| this.javaProject = javaProject;
|
| }
|
|
|
| public IJavaProject getJavaProject() {
|
| return this.javaProject;
|
| }
|
| }
|
|
|
| /** The tree content provider for the Dependencies Tree. */
|
| protected class DependenciesContentProvider implements ITreeContentProvider {
|
|
|
| public Object[] getElements(final Object inputElement) {
|
| if (inputElement instanceof DependenciesTreeInput) {
|
| IJavaProject javaProject = ((DependenciesTreeInput) inputElement)
|
| .getJavaProject();
|
| if (javaProject != null) {
|
| try {
|
| Set<IJavaProject> projects = AbstractDiscoverJavaModelFromProject
|
| .computeRequiredProjects(javaProject);
|
| return projects.toArray();
|
| } catch (JavaModelException e) {
|
| MoDiscoLogger.logError(e, Activator.getDefault());
|
| }
|
| }
|
| } else {
|
| throw new IllegalArgumentException("wrong input"); //$NON-NLS-1$
|
| }
|
| return new Object[0];
|
| }
|
|
|
| public boolean hasChildren(final Object element) {
|
| if (element instanceof IJavaProject) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| public Object[] getChildren(final Object element) {
|
| if (element instanceof IJavaProject) {
|
| IJavaProject javaProject = (IJavaProject) element;
|
| try {
|
| Set<IPackageFragmentRoot> requiredLibraries = AbstractDiscoverJavaModelFromProject
|
| .computeRequiredLibraries(javaProject);
|
| return requiredLibraries.toArray();
|
| } catch (JavaModelException e) {
|
| MoDiscoLogger.logError(e, Activator.getDefault());
|
| }
|
| }
|
| return new Object[0];
|
| }
|
|
|
| public Object getParent(final Object element) {
|
| if (element instanceof IPackageFragmentRoot) {
|
| return ((IPackageFragmentRoot) element).getJavaProject();
|
| }
|
| return null;
|
| }
|
|
|
| public void dispose() {
|
| // Nothing
|
| }
|
|
|
| public void inputChanged(final Viewer viewer, final Object oldInput,
|
| final Object newInput) {
|
| // Nothing
|
| }
|
| }
|
|
|
| protected class UseSourceColumnLabelProvider extends ColumnLabelProvider {
|
| @Override
|
| public String getText(final Object element) {
|
| if (element instanceof IPackageFragmentRoot
|
| && getElementsToAnalyze().getElementsToDiscover().contains(
|
| element)) {
|
| IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;
|
| if (!hasSourceAvailable(packageFragmentRoot)) {
|
| return Messages.JavaElementsToAnalyzeDialog_sourceNotAvailable;
|
| }
|
| Map<String, Object> discoveryOptions = getElementsToAnalyze()
|
| .getDiscoveryOptions(packageFragmentRoot);
|
| if (discoveryOptions != null
|
| && Boolean.TRUE
|
| .equals(discoveryOptions
|
| .get(JavaElementsToAnalyzeDialog.USE_SOURCES_OPTIONS))) {
|
| return Messages.JavaElementsToAnalyzeDialog_useSource;
|
| }
|
| return Messages.JavaElementsToAnalyzeDialog_dontUseSource;
|
| }
|
| return ""; //$NON-NLS-1$
|
| }
|
|
|
| @Override
|
| public Color getForeground(final Object element) {
|
| if (!hasSourceAvailable(element)) {
|
| return Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY);
|
| }
|
| return null;
|
| }
|
| }
|
|
|
| /**
|
| * A column label provider which extends and delegates to the JDT label
|
| * provider.
|
| */
|
| protected class JDTDelegateColumnLabelProvider extends ColumnLabelProvider {
|
|
|
| private final JavaElementLabelProvider delegate = new JavaElementLabelProvider();
|
| private boolean displayShortName = true;
|
|
|
| public JDTDelegateColumnLabelProvider(final boolean displayShortName) {
|
| this.displayShortName = displayShortName;
|
| }
|
|
|
| @Override
|
| public void addListener(final ILabelProviderListener listener) {
|
| this.delegate.addListener(listener);
|
| }
|
|
|
| @Override
|
| public void dispose() {
|
| this.delegate.dispose();
|
| }
|
|
|
| @Override
|
| public boolean equals(final Object obj) {
|
| return this.delegate.equals(obj);
|
| }
|
|
|
| @Override
|
| public Image getImage(final Object element) {
|
| if (this.displayShortName) {
|
| return this.delegate.getImage(element);
|
| }
|
| return null;
|
| }
|
|
|
| @Override
|
| public String getText(final Object element) {
|
| String qualifiedName = this.delegate.getText(element);
|
| int lastSegmentindex = qualifiedName.lastIndexOf(File.separator);
|
| String text = null;
|
|
|
| if (this.displayShortName) {
|
| text = qualifiedName.substring(lastSegmentindex + 1);
|
| } else if (lastSegmentindex > -1) {
|
| text = qualifiedName.substring(0, lastSegmentindex);
|
| } else {
|
| text = ""; //$NON-NLS-1$
|
| }
|
| return text;
|
| }
|
|
|
| @Override
|
| public int hashCode() {
|
| return this.delegate.hashCode();
|
| }
|
|
|
| @Override
|
| public boolean isLabelProperty(final Object element,
|
| final String property) {
|
| return this.delegate.isLabelProperty(element, property);
|
| }
|
|
|
| @Override
|
| public void removeListener(final ILabelProviderListener listener) {
|
| this.delegate.removeListener(listener);
|
| }
|
|
|
| @Override
|
| public String toString() {
|
| return this.delegate.toString();
|
| }
|
|
|
| }
|
|
|
| /** Editing support for the "use source" column. */
|
| protected class UseSourceEditingSupport extends EditingSupport {
|
|
|
| public UseSourceEditingSupport(final ColumnViewer columnViewer) {
|
| super(columnViewer);
|
| }
|
|
|
| @Override
|
| protected CellEditor getCellEditor(final Object element) {
|
| return new CheckboxCellEditor();
|
| }
|
|
|
| @Override
|
| protected boolean canEdit(final Object element) {
|
| return hasSourceAvailable(element);
|
| }
|
|
|
| @Override
|
| protected Object getValue(final Object element) {
|
| Map<String, Object> discoveryOptions = getElementsToAnalyze()
|
| .getDiscoveryOptions(element);
|
| if (discoveryOptions != null) {
|
| Object option = discoveryOptions
|
| .get(JavaElementsToAnalyzeDialog.USE_SOURCES_OPTIONS);
|
| if (option instanceof Boolean) {
|
| return option;
|
| }
|
| }
|
| return Boolean.FALSE;
|
| }
|
|
|
| @Override
|
| protected void setValue(final Object element, final Object value) {
|
| Map<String, Object> discoveryOptions = getElementsToAnalyze()
|
| .getDiscoveryOptions(element);
|
| if (discoveryOptions != null) {
|
| discoveryOptions.put(
|
| JavaElementsToAnalyzeDialog.USE_SOURCES_OPTIONS, value);
|
| }
|
| getDependenciesTree().refresh();
|
| }
|
|
|
| }
|
|
|
| protected CheckboxTreeViewer getDependenciesTree() {
|
| return this.dependenciesTree;
|
| }
|
|
|
| public ElementsToAnalyze getElementsToAnalyze() {
|
| return this.elementsToAnalyze;
|
| }
|
|
|
| @Override
|
| protected IDialogSettings getDialogBoundsSettings() {
|
| final String sectionName = JavaElementsToAnalyzeDialog.class.getName();
|
| IDialogSettings settings = Activator.getDefault().getDialogSettings();
|
| IDialogSettings section = settings.getSection(sectionName);
|
| if (section == null) {
|
| section = settings.addNewSection(sectionName);
|
| section.put("DIALOG_WIDTH", JavaElementsToAnalyzeDialog.DIALOG_WIDTH); //$NON-NLS-1$
|
| section.put("DIALOG_HEIGHT", JavaElementsToAnalyzeDialog.DIALOG_HEIGHT); //$NON-NLS-1$
|
| }
|
| return section;
|
| }
|
|
|
| @Override
|
| protected boolean isResizable() {
|
| return true;
|
| }
|
|
|
| @Override
|
| public boolean isHelpAvailable() {
|
| return false;
|
| }
|
| }
|
