| /*=============================================================================# |
| # Copyright (c) 2000, 2018 IBM Corporation and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 |
| # |
| # Contributors: |
| # IBM Corporation - org.eclipse.jdt: initial API and implementation |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.ltk.buildpaths.ui; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.databinding.observable.list.WritableList; |
| import org.eclipse.core.databinding.observable.value.IObservableValue; |
| import org.eclipse.core.databinding.observable.value.ValueChangeEvent; |
| import org.eclipse.core.databinding.observable.value.WritableValue; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.jface.databinding.swt.WidgetProperties; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.jface.wizard.WizardDialog; |
| import org.eclipse.swt.SWT; |
| 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.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| |
| import org.eclipse.statet.jcommons.collections.ImCollections; |
| import org.eclipse.statet.jcommons.collections.ImIdentitySet; |
| |
| import org.eclipse.statet.ecommons.databinding.jface.DataBindingSupport; |
| import org.eclipse.statet.ecommons.ui.components.ButtonGroup; |
| import org.eclipse.statet.ecommons.ui.components.DataAdapter; |
| import org.eclipse.statet.ecommons.ui.util.LayoutUtils; |
| import org.eclipse.statet.ecommons.ui.util.UIAccess; |
| |
| import org.eclipse.statet.internal.ltk.buildpaths.ui.Messages; |
| import org.eclipse.statet.ltk.buildpaths.core.BuildpathElementType; |
| import org.eclipse.statet.ltk.buildpaths.core.IBuildpathAttribute; |
| import org.eclipse.statet.ltk.buildpaths.core.IBuildpathElement; |
| import org.eclipse.statet.ltk.buildpaths.ui.wizards.EditFilterWizard; |
| |
| |
| public class SourceContainerComponent implements ButtonGroup.IActions<Object> { |
| |
| |
| private static final ImIdentitySet<String> FILTER_NO= ImCollections.emptyIdentitySet(); |
| |
| private static final ImIdentitySet<String> FILTER_OUTPUT= ImCollections.newIdentitySet( |
| IBuildpathAttribute.OUTPUT ); |
| |
| private static final Object[] NO_CHILDREN= new Object[0]; |
| |
| |
| private class TreeContentProvider implements ITreeContentProvider { |
| |
| |
| public TreeContentProvider() { |
| } |
| |
| @Override |
| public void dispose() { |
| } |
| |
| |
| @Override |
| public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) { |
| } |
| |
| @Override |
| public Object[] getElements(final Object inputElement) { |
| return SourceContainerComponent.this.containerList.toArray(); |
| } |
| |
| @Override |
| public Object getParent(final Object element) { |
| if (element instanceof BuildpathListElementAttribute) { |
| return ((BuildpathListElementAttribute) element).getParent(); |
| } |
| return null; |
| } |
| |
| @Override |
| public boolean hasChildren(final Object element) { |
| if (element instanceof BuildpathListElement) { |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean isFilterOutputAttribute() { |
| return (SourceContainerComponent.this.outputByContainerValue == null |
| || !((boolean) SourceContainerComponent.this.outputByContainerValue.getValue()) ); |
| } |
| |
| @Override |
| public Object[] getChildren(final Object element) { |
| if (element instanceof BuildpathListElement) { |
| final ImIdentitySet<String> filter= (isFilterOutputAttribute()) ? |
| FILTER_OUTPUT : FILTER_NO; |
| return ((BuildpathListElement) element).getFilteredChildren(filter).toArray(); |
| } |
| return NO_CHILDREN; |
| } |
| |
| } |
| |
| private class ListElementDataAdapter extends DataAdapter.TreeAdapter<Object> { |
| |
| |
| public ListElementDataAdapter(final ITreeContentProvider contentProvider) { |
| super(contentProvider, null); |
| } |
| |
| |
| @Override |
| public boolean isModifyAllowed(final Object element) { |
| if (element instanceof BuildpathListElement) { |
| final BuildpathListElement listElement= (BuildpathListElement) element; |
| if (listElement.getType().getName() == IBuildpathElement.SOURCE) { |
| if (listElement.getPath().equals(SourceContainerComponent.this.project.getFullPath())) { |
| return false; |
| } |
| } |
| return (SourceContainerComponent.this.uiDescription.getAllowEdit(listElement)); |
| } |
| if (element instanceof BuildpathListElementAttribute) { |
| final BuildpathListElementAttribute attribute= (BuildpathListElementAttribute) element; |
| if (attribute.isBuiltin()) { |
| return (SourceContainerComponent.this.uiDescription.getAllowEdit(attribute)); |
| } |
| else { |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean isDeleteAllowed(final Object element) { |
| if (element instanceof BuildpathListElement) { |
| final BuildpathListElement listElement= (BuildpathListElement) element; |
| return (SourceContainerComponent.this.uiDescription.getAllowEdit(listElement)); |
| } |
| if (element instanceof BuildpathListElementAttribute) { |
| final BuildpathListElementAttribute attribute= (BuildpathListElementAttribute) element; |
| if (SourceContainerComponent.this.uiDescription.getAllowEdit(attribute)) { |
| if (attribute.isBuiltin()) { |
| switch (attribute.getName()) { |
| case IBuildpathAttribute.FILTER_INCLUSIONS: |
| case IBuildpathAttribute.FILTER_EXCLUSIONS: |
| return (!((List<?>) attribute.getValue()).isEmpty()); |
| default: |
| return (attribute.getValue() != null); |
| } |
| } |
| else { |
| return true; |
| } |
| } |
| return false; |
| } |
| return false; |
| } |
| |
| @Override |
| public void delete(final List<? extends Object> elements) { |
| for (final Object object : elements) { |
| if (object instanceof BuildpathListElement) { |
| final BuildpathListElement element= (BuildpathListElement) object; |
| SourceContainerComponent.this.containerList.remove(element); |
| continue; |
| } |
| if (object instanceof BuildpathListElementAttribute) { |
| final BuildpathListElementAttribute attribute= (BuildpathListElementAttribute) object; |
| final String key= attribute.getName(); |
| if (attribute.isBuiltin()) { |
| final Object value; |
| switch (attribute.getName()) { |
| case IBuildpathAttribute.FILTER_INCLUSIONS: |
| case IBuildpathAttribute.FILTER_EXCLUSIONS: |
| value= ImCollections.emptyList(); |
| break; |
| default: |
| value= null; |
| break; |
| } |
| attribute.getParent().setAttribute(key, value); |
| SourceContainerComponent.this.changedContainers.add(attribute.getParent()); |
| continue; |
| } |
| else { |
| throw new UnsupportedOperationException("Not yet implemented"); |
| // continue; |
| } |
| } |
| } |
| updateBuildpathList(); |
| } |
| |
| } |
| |
| |
| private final WritableList<BuildpathListElement> buildpathList; |
| |
| private final BuildpathElementType type; |
| |
| private final BuildpathsUIDescription uiDescription; |
| |
| private IProject project; |
| |
| private final WritableList<BuildpathListElement> containerList= new WritableList<>(); |
| |
| private final Set<BuildpathListElement> changedContainers= new HashSet<>(); |
| |
| private final IObservableValue<String> outputPathValue; |
| private final IObservableValue<Boolean> outputByContainerValue; |
| |
| private Control control; |
| |
| private TreeViewer containerListViewer; |
| private ButtonGroup<Object> containerListButtons; |
| |
| private Text outputPathControl; |
| private Button outputByFolderControl; |
| |
| |
| public SourceContainerComponent(final WritableList<BuildpathListElement> buildpathList, |
| final BuildpathElementType sourceType, final BuildpathElementType outputType, |
| final BuildpathsUIDescription uiDescription) { |
| this.buildpathList= buildpathList; |
| this.type= sourceType; |
| |
| this.uiDescription= uiDescription; |
| |
| this.outputPathValue= (outputType != null) ? |
| new WritableValue<>(null, String.class) : null; |
| this.outputByContainerValue= (outputType != null |
| && this.type.isAttributeBuiltin(IBuildpathAttribute.OUTPUT) ) ? |
| new WritableValue<>(false, Boolean.TYPE) : null; |
| } |
| |
| public void init(final IProject project) { |
| this.project= project; |
| if (Display.getCurrent() != null) { |
| updateTargets(true); |
| } |
| else { |
| Display.getDefault().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| updateTargets(true); |
| } |
| }); |
| } |
| } |
| |
| |
| private Shell getShell() { |
| if (this.control != null) { |
| return this.control.getShell(); |
| } |
| return UIAccess.getActiveWorkbenchShell(true); |
| } |
| |
| public Control create(final Composite parent) { |
| final Composite composite= new Composite(parent, SWT.NONE); |
| composite.setLayout(LayoutUtils.newCompositeGrid(2)); |
| |
| { final Label label= new Label(composite, SWT.NONE); |
| label.setText(Messages.SourceContainers_SourceFolders_label); |
| |
| label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| } |
| { final TreeViewer viewer= new TreeViewer(composite, |
| SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL ); |
| final TreeContentProvider contentProvider= new TreeContentProvider(); |
| viewer.setContentProvider(contentProvider); |
| viewer.setComparator(this.uiDescription.createListElementComparator()); |
| viewer.setLabelProvider(this.uiDescription.createListLabelProvider()); |
| viewer.setInput(this.containerList); |
| |
| final GridData gd= new GridData(SWT.FILL, SWT.FILL, true, true); |
| gd.heightHint= LayoutUtils.hintHeight(viewer.getTree(), 8); |
| gd.widthHint= LayoutUtils.hintWidth(viewer.getTree(), 60); |
| viewer.getControl().setLayoutData(gd); |
| this.containerListViewer= viewer; |
| |
| final ButtonGroup<Object> buttonGroup= new ButtonGroup<>(composite, this, false); |
| buttonGroup.addAddButton(new ButtonGroup.AddHandler() { |
| @Override |
| public void update(final IStructuredSelection selection) { |
| setEnabled(SourceContainerComponent.this.uiDescription.getAllowAdd( |
| SourceContainerComponent.this.project, SourceContainerComponent.this.type )); |
| } |
| }); |
| buttonGroup.addEditButton(null); |
| buttonGroup.addDeleteButton(null); |
| buttonGroup.connectTo(viewer, new ListElementDataAdapter(contentProvider)); |
| |
| buttonGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true)); |
| this.containerListButtons= buttonGroup; |
| } |
| |
| if (this.outputPathValue != null) { |
| { final Label label= new Label(composite, SWT.NONE); |
| label.setText(Messages.SourceContainers_OutputFolder_label); |
| |
| label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| } |
| { final Text text= new Text(composite, SWT.BORDER | SWT.SINGLE); |
| |
| text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| this.outputPathControl= text; |
| |
| final Button button= new Button(composite, SWT.PUSH); |
| button.setText(Messages.SourceContainers_OutputFolder_Choose_label); |
| } |
| if (this.outputByContainerValue != null) { |
| final Button button= new Button(composite, SWT.CHECK); |
| button.setText(Messages.SourceContainers_OutputBySourceFolders_label); |
| button.setSelection(false); |
| |
| button.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| this.outputByFolderControl= button; |
| } |
| } |
| |
| this.control= composite; |
| |
| return this.control; |
| } |
| |
| public void bind(final DataBindingSupport db) { |
| if (this.outputPathValue != null) { |
| db.getContext().bindValue( |
| WidgetProperties.text(SWT.Modify).observe(this.outputPathValue), |
| this.outputPathValue ); |
| |
| if (this.outputByContainerValue != null) { |
| db.getContext().bindValue( |
| WidgetProperties.selection().observe(this.outputByFolderControl), |
| this.outputByContainerValue ); |
| |
| this.outputByContainerValue.addValueChangeListener( |
| (final ValueChangeEvent<? extends Boolean> event) -> { |
| if (!(event.diff.getNewValue())) { |
| for (final Object object : SourceContainerComponent.this.containerList) { |
| final BuildpathListElement element= (BuildpathListElement) object; |
| final BuildpathListElementAttribute attribute= element |
| .setAttribute(IBuildpathAttribute.OUTPUT, null); |
| |
| if (attribute != null) { |
| SourceContainerComponent.this.changedContainers.add(element); |
| } |
| } |
| SourceContainerComponent.this.containerListButtons.refresh(); |
| } |
| } ); |
| } |
| } |
| |
| updateExpandStates(); |
| } |
| |
| private void updateTargets(final boolean reset) { |
| if (UIAccess.isOkToUse(this.control)) { |
| if (reset) { |
| this.containerListViewer.collapseAll(); |
| } |
| this.containerList.clear(); |
| this.changedContainers.clear(); |
| |
| final List<BuildpathListElement> folders= new ArrayList<>(); |
| boolean outputLocationByFolder= false; |
| |
| for (final BuildpathListElement element : this.buildpathList) { |
| if (isElement(element)) { |
| folders.add(element); |
| outputLocationByFolder|= (element.getAttributeValue(IBuildpathAttribute.OUTPUT) != null); |
| } |
| } |
| this.containerList.addAll(folders); |
| this.containerListButtons.refresh(); |
| updateExpandStates(); |
| |
| if (this.outputByContainerValue != null) { |
| this.outputByContainerValue.setValue(outputLocationByFolder); |
| } |
| } |
| } |
| |
| private void updateBuildpathList() { |
| final List<BuildpathListElement> workingList= new ArrayList<>(this.containerList); |
| |
| for (int idx= 0; idx < this.buildpathList.size();) { |
| final BuildpathListElement element= this.buildpathList.get(idx); |
| if (isElement(element)) { |
| if (workingList.remove(element)) { |
| if (this.changedContainers.remove(element)) { |
| this.buildpathList.set(idx, element); |
| } |
| idx++; |
| } |
| else { |
| this.buildpathList.remove(idx); |
| } |
| } |
| else { |
| idx++; |
| } |
| } |
| if (!workingList.isEmpty()) { |
| this.buildpathList.addAll(workingList); |
| } |
| this.changedContainers.clear(); |
| } |
| |
| private void updateExpandStates() { |
| for (int i= 0; i < this.containerList.size(); i++) { |
| final BuildpathListElement element= this.containerList.get(i); |
| final List<IPath> inclusionPatterns= (List<IPath>) element.getAttributeValue(IBuildpathAttribute.FILTER_INCLUSIONS); |
| final List<IPath> exclusionPatterns= (List<IPath>) element.getAttributeValue(IBuildpathAttribute.FILTER_EXCLUSIONS); |
| final IPath outputFolder= (IPath) element.getAttributeValue(IBuildpathAttribute.OUTPUT); |
| if (!inclusionPatterns.isEmpty() || !exclusionPatterns.isEmpty() || outputFolder != null) { |
| this.containerListViewer.expandToLevel(element, 1); |
| } |
| } |
| } |
| |
| protected boolean isElement(final BuildpathListElement element) { |
| return (element.getType() == this.type); |
| } |
| |
| |
| public void setFocus() { |
| this.containerListViewer.getTree().setFocus(); |
| } |
| |
| |
| public List<Object> getSelection() { |
| return ImCollections.toList( |
| ((StructuredSelection) this.containerListViewer.getSelection()).toList() ); |
| } |
| |
| public void setSelection(final List<BuildpathListElement> elements, final boolean expand) { |
| this.containerListViewer.setSelection(new StructuredSelection(elements)); |
| if (expand) { |
| for (final BuildpathListElement element : elements) { |
| this.containerListViewer.expandToLevel(element, 1); |
| } |
| } |
| } |
| |
| |
| @Override |
| public Object edit(final int command, final Object item, final Object parent) { |
| if (command == ButtonGroup.ADD_NEW) { |
| throw new UnsupportedOperationException(); |
| } |
| else { |
| if (item instanceof BuildpathListElement) { |
| return editElement((BuildpathListElement) item); |
| } |
| if (item instanceof BuildpathListElementAttribute) { |
| return editAttribute((BuildpathListElementAttribute) item); |
| } |
| throw new IllegalStateException(); |
| } |
| } |
| |
| @Override |
| public void updateState(final IStructuredSelection selection) { |
| } |
| |
| private BuildpathListElement editElement(final BuildpathListElement element) { |
| throw new UnsupportedOperationException("Not yet implemented"); |
| } |
| |
| private BuildpathListElementAttribute editAttribute(final BuildpathListElementAttribute attribute) { |
| switch (attribute.getName()) { |
| case IBuildpathAttribute.FILTER_INCLUSIONS: |
| case IBuildpathAttribute.FILTER_EXCLUSIONS: { |
| final EditFilterWizard wizard= new EditFilterWizard( |
| ImCollections.toList((List<BuildpathListElement>) this.containerList), |
| attribute.getParent(), this.uiDescription ); |
| final WizardDialog dialog= new WizardDialog(getShell(), wizard); |
| dialog.create(); |
| wizard.setFocus(attribute.getName()); |
| if (dialog.open() == Window.OK) { |
| this.containerListButtons.refresh(null); |
| this.changedContainers.add(attribute.getParent()); |
| updateBuildpathList(); |
| } |
| return null; |
| } |
| default: |
| throw new UnsupportedOperationException("Not yet implemented"); |
| } |
| } |
| |
| } |
