core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/internal/ui/wizards/buildpath/LibrariesWorkbookPage.java

/*******************************************************************************
 * Copyright (c) 2000, 2017 IBM Corporation and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.ui.wizards.buildpath;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.dltk.compiler.util.Util;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IAccessRule;
import org.eclipse.dltk.core.IBuildpathEntry;
import org.eclipse.dltk.core.IProjectFragment;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.environment.EnvironmentManager;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.internal.corext.util.Messages;
import org.eclipse.dltk.internal.ui.actions.WorkbenchRunnableAdapter;
import org.eclipse.dltk.internal.ui.wizards.BuildpathDialogAccess;
import org.eclipse.dltk.internal.ui.wizards.NewWizardMessages;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.ITreeListAdapter;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.ListDialogField;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.TreeListDialogField;
import org.eclipse.dltk.ui.DLTKUIPlugin;
import org.eclipse.dltk.ui.util.ExceptionHandler;
import org.eclipse.dltk.ui.util.PixelConverter;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;

public class LibrariesWorkbookPage extends BuildPathBasePage {
	private ListDialogField fBuildPathList;
	private IScriptProject fCurrJProject;
	private TreeListDialogField fLibrariesList;
	private Control fSWTControl;
	private final IWorkbenchPreferenceContainer fPageContainer;
	private final int IDX_ADDZIP = 0;
	private final int IDX_ADDEXT = 1;
	private final int IDX_ADDLIB = 2;
	// private final int IDX_ADDFOL = 3;
	private final int IDX_ADDEXTFOL = 3;
	private final int IDX_EDIT = 5;
	private final int IDX_REMOVE = 6;
	private final int IDX_REPLACE = 8;

	private final int IDX_WITHOUTZIP = -2;
	private int IDX_ADD = 0;
	private boolean fWithZip = false;

	public LibrariesWorkbookPage(boolean supportZips,
			ListDialogField classPathList,
			IWorkbenchPreferenceContainer pageContainer) {
		fBuildPathList = classPathList;
		fPageContainer = pageContainer;
		fSWTControl = null;

		String[] buttonLabelsWith = new String[] {
				NewWizardMessages.LibrariesWorkbookPage_libraries_addzip_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_addextzip_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_addlibrary_button,
				// NewWizardMessages.LibrariesWorkbookPage_libraries_add_source_folder_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_add_external_source_folder_button,
				/* */null,
				NewWizardMessages.LibrariesWorkbookPage_libraries_edit_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_remove_button,
				/* */null,
				NewWizardMessages.LibrariesWorkbookPage_libraries_replace_button };
		String[] buttonLabelsWithout = new String[] {
				NewWizardMessages.LibrariesWorkbookPage_libraries_addlibrary_button,
				// NewWizardMessages.LibrariesWorkbookPage_libraries_add_source_folder_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_add_external_source_folder_button,
				/* */null,
				NewWizardMessages.LibrariesWorkbookPage_libraries_edit_button,
				NewWizardMessages.LibrariesWorkbookPage_libraries_remove_button };
		String[] buttonLabels;
		buttonLabels = buttonLabelsWithout;
		IDX_ADD = IDX_WITHOUTZIP;
		fWithZip = supportZips;
		if (fWithZip) {
			buttonLabels = buttonLabelsWith;
			IDX_ADD = 0;
		}
		LibrariesAdapter adapter = new LibrariesAdapter();
		fLibrariesList = new TreeListDialogField(adapter, buttonLabels,
				new BPListLabelProvider());
		fLibrariesList.setDialogFieldListener(adapter);
		if (this.fWithZip) {
			fLibrariesList.setLabelText(
					NewWizardMessages.LibrariesWorkbookPage_libraries_label);
		} else {
			fLibrariesList.setLabelText(
					NewWizardMessages.LibrariesWorkbookPage_libraries_without_label);
		}
		fLibrariesList.enableButton(IDX_REMOVE + IDX_ADD, false);
		fLibrariesList.enableButton(IDX_EDIT + IDX_ADD, false);
		if (fWithZip) {
			fLibrariesList.enableButton(IDX_REPLACE + IDX_ADD, false);
		}
		fLibrariesList.setViewerComparator(new BPListElementSorter());
	}

	@Override
	public void setTitle(String title) {
		fLibrariesList.setLabelText(title);
	}

	@Override
	public void init(IScriptProject jproject) {
		fCurrJProject = jproject;
		if (Display.getCurrent() != null) {
			updateLibrariesList();
		} else {
			Display.getDefault().asyncExec(() -> updateLibrariesList());
		}
	}

	private void updateLibrariesList() {
		List cpelements = fBuildPathList.getElements();
		List libelements = new ArrayList(cpelements.size());
		int nElements = cpelements.size();
		for (int i = 0; i < nElements; i++) {
			BPListElement cpe = (BPListElement) cpelements.get(i);
			if (isEntryKind(cpe.getEntryKind())) {
				libelements.add(cpe);
			}
		}
		fLibrariesList.setElements(libelements);
	}

	// -------- UI creation
	@Override
	public Control getControl(Composite parent) {
		PixelConverter converter = new PixelConverter(parent);
		Composite composite = new Composite(parent, SWT.NONE);
		LayoutUtil.doDefaultLayout(composite,
				new DialogField[] { fLibrariesList }, true, SWT.DEFAULT,
				SWT.DEFAULT);
		LayoutUtil.setHorizontalGrabbing(fLibrariesList.getTreeControl(null));
		int buttonBarWidth = converter.convertWidthInCharsToPixels(24);
		fLibrariesList.setButtonsMinWidth(buttonBarWidth);
		fLibrariesList.getTreeViewer().setComparator(new BPListElementSorter());
		fSWTControl = composite;
		return composite;
	}

	private Shell getShell() {
		if (fSWTControl != null) {
			return fSWTControl.getShell();
		}
		return DLTKUIPlugin.getActiveWorkbenchShell();
	}

	private class LibrariesAdapter
			implements IDialogFieldListener, ITreeListAdapter {
		private final Object[] EMPTY_ARR = new Object[0];

		// -------- IListAdapter --------
		@Override
		public void customButtonPressed(TreeListDialogField field, int index) {
			libaryPageCustomButtonPressed(field, index);
		}

		@Override
		public void selectionChanged(TreeListDialogField field) {
			libaryPageSelectionChanged(field);
		}

		@Override
		public void doubleClicked(TreeListDialogField field) {
			libaryPageDoubleClicked(field);
		}

		@Override
		public void keyPressed(TreeListDialogField field, KeyEvent event) {
			libaryPageKeyPressed(field, event);
		}

		@Override
		public Object[] getChildren(TreeListDialogField field, Object element) {
			if (element instanceof BPListElement) {
				return ((BPListElement) element).getChildren();
			} else if (element instanceof BPListElementAttribute) {
				BPListElementAttribute attribute = (BPListElementAttribute) element;
				if (BPListElement.ACCESSRULES.equals(attribute.getKey())) {
					return (IAccessRule[]) attribute.getValue();
				}
			}
			return EMPTY_ARR;
		}

		@Override
		public Object getParent(TreeListDialogField field, Object element) {
			if (element instanceof BPListElementAttribute) {
				return ((BPListElementAttribute) element).getParent();
			}
			return null;
		}

		@Override
		public boolean hasChildren(TreeListDialogField field, Object element) {
			return getChildren(field, element).length > 0;
		}

		// ---------- IDialogFieldListener --------
		@Override
		public void dialogFieldChanged(DialogField field) {
			libaryPageDialogFieldChanged(field);
		}
	}

	private void libaryPageCustomButtonPressed(DialogField field, int index) {
		BPListElement[] libentries = null;
		IEnvironment environment = getEnvironment();
		switch (index - IDX_ADD) {
		case IDX_ADDZIP: /* add archive */
			if (fWithZip) {
				libentries = openZipFileDialog(null);
				break;
			}
		case IDX_ADDEXT: /* add external archive */
			if (fWithZip) {
				libentries = openExtZipFileDialog(null, environment);
				break;
			}
		case IDX_ADDLIB: /* add library */
			libentries = openContainerSelectionDialog(null);
			break;
		case IDX_ADDEXTFOL: /* add folder */
			libentries = opensExtSourceFolderDialog(null, environment);
			break;
		// case IDX_ADDFOL: /* add folder */
		// libentries = opensSourceFolderDialog(null);
		// break;
		case IDX_EDIT: /* edit */
			editEntry();
			return;
		case IDX_REMOVE: /* remove */
			removeEntry();
			return;
		case IDX_REPLACE: /* replace */
			replaceArchiveFile();
			return;
		}
		if (libentries != null) {
			int nElementsChosen = libentries.length;
			// remove duplicates
			List cplist = fLibrariesList.getElements();
			List elementsToAdd = new ArrayList(nElementsChosen);
			for (int i = 0; i < nElementsChosen; i++) {
				BPListElement curr = libentries[i];
				if (!cplist.contains(curr) && !elementsToAdd.contains(curr)) {
					elementsToAdd.add(curr);
				}
			}
			// if (!elementsToAdd.isEmpty() && (index == IDX_ADDFOL+IDX_ADD)) {
			// askForAddingExclusionPatternsDialog(elementsToAdd);
			// }
			fLibrariesList.addElements(elementsToAdd);
			if (index == IDX_ADDLIB + IDX_ADD) {
				fLibrariesList.refresh();
			}
			fLibrariesList
					.postSetSelection(new StructuredSelection(libentries));
		}
	}

	@Override
	public void addElement(BPListElement element) {
		fLibrariesList.addElement(element);
		fLibrariesList.postSetSelection(new StructuredSelection(element));
	}

	protected void libaryPageDoubleClicked(TreeListDialogField field) {
		List selection = fLibrariesList.getSelectedElements();
		if (canEdit(selection)) {
			editEntry();
		}
	}

	protected void libaryPageKeyPressed(TreeListDialogField field,
			KeyEvent event) {
		if (field == fLibrariesList) {
			if (event.character == SWT.DEL && event.stateMask == 0) {
				List selection = field.getSelectedElements();
				if (canRemove(selection)) {
					removeEntry();
				}
			}
		}
	}

	private void replaceArchiveFile() {
	}

	private IProjectFragment getSelectedProjectFragment() {
		final List elements = fLibrariesList.getSelectedElements();
		if (elements.size() == 1) {
			final Object object = elements.get(0);
			if (object instanceof BPListElement) {
				// final BPListElement element = (BPListElement) object;
				// final IBuildpathEntry entry = element.getBuildpathEntry();
				// if (JarImportWizard.isValidBuildPathEntry(entry)) {
				// final IScriptProject project = element.getScriptProject();
				// if (project != null) {
				// try {
				// final IProjectFragment[] roots = project
				// .getProjectFragments();
				// for (int index = 0; index < roots.length; index++) {
				// if (entry.equals(roots[index]
				// .getRawBuildpathEntry()))
				// return roots[index];
				// }
				// } catch (ModelException exception) {
				// DLTKUIPlugin.log(exception);
				// }
				// }
				// }
			}
		}
		return null;
	}

	private void removeEntry() {
		List selElements = fLibrariesList.getSelectedElements();
		HashMap containerEntriesToUpdate = new HashMap();
		for (int i = selElements.size() - 1; i >= 0; i--) {
			Object elem = selElements.get(i);
			if (elem instanceof BPListElementAttribute) {
				BPListElementAttribute attrib = (BPListElementAttribute) elem;
				String key = attrib.getKey();
				Object value = null;
				if (key.equals(BPListElement.ACCESSRULES)) {
					value = new IAccessRule[0];
				}
				attrib.getParent().setAttribute(key, value);
				selElements.remove(i);
				if (attrib.getParent()
						.getParentContainer() instanceof BPListElement) { // inside
					// a
					// container:
					// apply
					// changes
					// right
					// away
					BPListElement containerEntry = attrib.getParent();
					HashSet changedAttributes = (HashSet) containerEntriesToUpdate
							.get(containerEntry);
					if (changedAttributes == null) {
						changedAttributes = new HashSet();
						containerEntriesToUpdate.put(containerEntry,
								changedAttributes);
					}
					changedAttributes.add(key); // collect the changed
					// attributes
				}
			}
		}
		if (selElements.isEmpty()) {
			fLibrariesList.refresh();
			fBuildPathList.dialogFieldChanged(); // validate
		} else {
			fLibrariesList.removeElements(selElements);
		}
		for (Iterator iter = containerEntriesToUpdate.entrySet()
				.iterator(); iter.hasNext();) {
			Map.Entry entry = (Entry) iter.next();
			BPListElement curr = (BPListElement) entry.getKey();
			HashSet attribs = (HashSet) entry.getValue();
			String[] changedAttributes = (String[]) attribs
					.toArray(new String[attribs.size()]);
			IBuildpathEntry changedEntry = curr.getBuildpathEntry();
			updateContainerEntry(changedEntry, changedAttributes, fCurrJProject,
					((BPListElement) curr.getParentContainer()).getPath());
		}
	}

	private boolean canRemove(List selElements) {
		if (selElements.size() == 0) {
			return false;
		}
		for (int i = 0; i < selElements.size(); i++) {
			Object elem = selElements.get(i);
			if (elem instanceof BPListElementAttribute) {
				BPListElementAttribute attrib = (BPListElementAttribute) elem;
				if (attrib.isInNonModifiableContainer()) {
					return false;
				}
				if (attrib.getKey().equals(BPListElement.ACCESSRULES)) {
					return ((IAccessRule[]) attrib.getValue()).length > 0;
				}
				if (attrib.getValue() == null) {
					return false;
				}
			} else if (elem instanceof BPListElement) {
				BPListElement curr = (BPListElement) elem;
				if (curr.getParentContainer() != null) {
					return false;
				}
			} else { // unknown element
				return false;
			}
		}
		return true;
	}

	/**
	 * Method editEntry.
	 */
	private void editEntry() {
		List selElements = fLibrariesList.getSelectedElements();
		if (selElements.size() != 1) {
			return;
		}
		Object elem = selElements.get(0);
		if (fLibrariesList.getIndexOfElement(elem) != -1) {
			editElementEntry((BPListElement) elem);
		} else if (elem instanceof BPListElementAttribute) {
			editAttributeEntry((BPListElementAttribute) elem);
		}
	}

	private void editAttributeEntry(BPListElementAttribute elem) {
		String key = elem.getKey();
		BPListElement selElement = elem.getParent();
		if (key.equals(BPListElement.ACCESSRULES)) {
			AccessRulesDialog dialog = new AccessRulesDialog(getShell(),
					selElement, fCurrJProject, fPageContainer != null);
			int res = dialog.open();
			if (res == Window.OK || res == AccessRulesDialog.SWITCH_PAGE) {
				selElement.setAttribute(BPListElement.ACCESSRULES,
						dialog.getAccessRules());
				String[] changedAttributes = { BPListElement.ACCESSRULES };
				attributeUpdated(selElement, changedAttributes);
				fLibrariesList.refresh(elem);
				fBuildPathList.dialogFieldChanged(); // validate
				updateEnabledState();
				if (res == AccessRulesDialog.SWITCH_PAGE) { // switch after
					// updates and
					// validation
					dialog.performPageSwitch(fPageContainer);
				}
			}
		}
		// else if (key.equals(BPListElement.NATIVE_LIB_PATH)) {
		// NativeLibrariesDialog dialog= new NativeLibrariesDialog(getShell(),
		// selElement);
		// if (dialog.open() == Window.OK) {
		// selElement.setAttribute(BPListElement.NATIVE_LIB_PATH,
		// dialog.getNativeLibraryPath());
		// String[] changedAttributes= { BPListElement.NATIVE_LIB_PATH };
		// attributeUpdated(selElement, changedAttributes);
		//
		// fLibrariesList.refresh(elem);
		// fBuildPathList.dialogFieldChanged(); // validate
		// updateEnabledState();
		// }
		// }
	}

	private void attributeUpdated(BPListElement selElement,
			String[] changedAttributes) {
		Object parentContainer = selElement.getParentContainer();
		if (parentContainer instanceof BPListElement) { // inside a container:
			// apply changes right
			// away
			IBuildpathEntry updatedEntry = selElement.getBuildpathEntry();
			updateContainerEntry(updatedEntry, changedAttributes, fCurrJProject,
					((BPListElement) parentContainer).getPath());
		}
	}

	private void updateContainerEntry(final IBuildpathEntry newEntry,
			final String[] changedAttributes, final IScriptProject jproject,
			final IPath containerPath) {
		try {
			IWorkspaceRunnable runnable = monitor -> BuildPathSupport
					.modifyBuildpathEntry(null, newEntry, changedAttributes,
							jproject, containerPath, monitor);
			PlatformUI.getWorkbench().getProgressService().run(true, true,
					new WorkbenchRunnableAdapter(runnable));
		} catch (InvocationTargetException e) {
			String title = NewWizardMessages.LibrariesWorkbookPage_configurecontainer_error_title;
			String message = NewWizardMessages.LibrariesWorkbookPage_configurecontainer_error_message;
			ExceptionHandler.handle(e, getShell(), title, message);
		} catch (InterruptedException e) {
			//
		}
	}

	private void editElementEntry(BPListElement elem) {
		BPListElement[] res = null;
		switch (elem.getEntryKind()) {
		case IBuildpathEntry.BPE_CONTAINER:
			res = openContainerSelectionDialog(elem);
			break;
		case IBuildpathEntry.BPE_LIBRARY:
			IEnvironment environment = getEnvironment();
			IResource resource = elem.getResource();
			if (resource == null) {
				if (Util.isArchiveFileName(
						DLTKLanguageManager
								.getLanguageToolkit(elem.getScriptProject()),
						elem.getPath().toOSString())) {
					res = openExtZipFileDialog(elem, environment);
				} else {
					res = opensExtSourceFolderDialog(elem, environment);
				}
			} else if (resource.getType() == IResource.FOLDER) {
				if (resource.exists()) {
					res = opensSourceFolderDialog(elem);
				} else {
					res = openNewClassFolderDialog(elem);
				}
			} else if (resource.getType() == IResource.FILE) {
				res = openZipFileDialog(elem);
			}
			break;
		}
		if (res != null && res.length > 0) {
			BPListElement curr = res[0];
			curr.setExported(elem.isExported());
			fLibrariesList.replaceElement(elem, curr);
		}
	}

	private void libaryPageSelectionChanged(DialogField field) {
		updateEnabledState();
	}

	private void updateEnabledState() {
		List selElements = fLibrariesList.getSelectedElements();
		fLibrariesList.enableButton(IDX_EDIT + IDX_ADD, canEdit(selElements));
		fLibrariesList.enableButton(IDX_REMOVE + IDX_ADD,
				canRemove(selElements));
		boolean noAttributes = containsOnlyTopLevelEntries(selElements);
		if (fWithZip) {
			fLibrariesList.enableButton(IDX_ADDEXT + IDX_ADD, noAttributes);
			fLibrariesList.enableButton(IDX_ADDZIP + IDX_ADD, noAttributes);
			fLibrariesList.enableButton(IDX_REPLACE + IDX_ADD,
					getSelectedProjectFragment() != null);
		}
		// fLibrariesList.enableButton(IDX_ADDFOL+IDX_ADD, noAttributes);
		fLibrariesList.enableButton(IDX_ADDLIB + IDX_ADD, noAttributes);
	}

	private boolean canEdit(List selElements) {
		if (selElements.size() != 1) {
			return false;
		}
		Object elem = selElements.get(0);
		if (elem instanceof BPListElement) {
			BPListElement curr = (BPListElement) elem;
			return !(curr.getResource() instanceof IFolder
					|| curr.isExternalFolder())
					&& curr.getParentContainer() == null;
		}
		if (elem instanceof BPListElementAttribute) {
			BPListElementAttribute attrib = (BPListElementAttribute) elem;
			if (attrib.isInNonModifiableContainer()) {
				return false;
			}
			return true;
		}
		return false;
	}

	private void libaryPageDialogFieldChanged(DialogField field) {
		if (fCurrJProject != null) {
			// already initialized
			updateBuildpathList();
		}
	}

	private void updateBuildpathList() {
		List projelements = fLibrariesList.getElements();
		List cpelements = fBuildPathList.getElements();
		int nEntries = cpelements.size();
		// backwards, as entries will be deleted
		int lastRemovePos = nEntries;
		for (int i = nEntries - 1; i >= 0; i--) {
			BPListElement cpe = (BPListElement) cpelements.get(i);
			int kind = cpe.getEntryKind();
			if (isEntryKind(kind)) {
				if (!projelements.remove(cpe)) {
					cpelements.remove(i);
					lastRemovePos = i;
				}
			}
		}
		cpelements.addAll(lastRemovePos, projelements);
		if (lastRemovePos != nEntries || !projelements.isEmpty()) {
			fBuildPathList.setElements(cpelements);
		}
	}

	private BPListElement[] openNewClassFolderDialog(BPListElement existing) {
		String title = (existing == null)
				? NewWizardMessages.LibrariesWorkbookPage_NewClassFolderDialog_new_title
				: NewWizardMessages.LibrariesWorkbookPage_NewClassFolderDialog_edit_title;
		IProject currProject = fCurrJProject.getProject();
		NewContainerDialog dialog = new NewContainerDialog(getShell(), title,
				currProject, getUsedContainers(existing), existing);
		IPath projpath = currProject.getFullPath();
		dialog.setMessage(Messages.format(
				NewWizardMessages.LibrariesWorkbookPage_NewClassFolderDialog_description,
				projpath.toString()));
		if (dialog.open() == Window.OK) {
			IFolder folder = dialog.getFolder();
			return new BPListElement[] { newBPLibraryElement(folder, false) };
		}
		return null;
	}

	private BPListElement[] opensExtSourceFolderDialog(BPListElement existing,
			IEnvironment environment) {
		if (existing == null) {
			IPath[] selected = BuildpathDialogAccess
					.chooseExtSourceFolderEntries(getShell(),
							fCurrJProject.getPath(),
							getUsedContainers(existing), environment);
			if (selected != null) {
				// IWorkspaceRoot root =
				// fCurrJProject.getProject().getWorkspace().getRoot();
				ArrayList<BPListElement> res = new ArrayList<>();
				for (int i = 0; i < selected.length; i++) {
					// IPath curr = selected[i];
					res.add(new BPListElement(fCurrJProject,
							IBuildpathEntry.BPE_LIBRARY, selected[i], null,
							true));
				}
				return res.toArray(new BPListElement[res.size()]);
			}
		} else {
			// disabled
		}
		return null;
	}

	private BPListElement[] opensSourceFolderDialog(BPListElement existing) {
		if (existing == null) {
			IPath[] selected = BuildpathDialogAccess.chooseSourceFolderEntries(
					getShell(), fCurrJProject.getPath(),
					getUsedContainers(existing));
			if (selected != null) {
				IWorkspaceRoot root = fCurrJProject.getProject().getWorkspace()
						.getRoot();
				ArrayList<BPListElement> res = new ArrayList<>();
				for (int i = 0; i < selected.length; i++) {
					IPath curr = selected[i];
					IResource resource = root.findMember(curr);
					if (resource instanceof IContainer) {
						res.add(newBPLibraryElement(resource, false));
					}
				}
				return res.toArray(new BPListElement[res.size()]);
			}
		} else {
			// disabled
		}
		return null;
	}

	private BPListElement[] openZipFileDialog(BPListElement existing) {
		IWorkspaceRoot root = fCurrJProject.getProject().getWorkspace()
				.getRoot();
		if (existing == null) {
			IPath[] selected = BuildpathDialogAccess.chooseArchiveEntries(
					getShell(), fCurrJProject.getPath(),
					getUsedArchiveFiles(existing));
			if (selected != null) {
				ArrayList<BPListElement> res = new ArrayList<>();
				for (int i = 0; i < selected.length; i++) {
					IPath curr = selected[i];
					IResource resource = root.findMember(curr);
					if (resource instanceof IFile) {
						res.add(newBPLibraryElement(resource, false));
					}
				}
				return res.toArray(new BPListElement[res.size()]);
			}
		} else {
			IPath configured = BuildpathDialogAccess.configureArchiveEntry(
					getShell(), existing.getPath(),
					getUsedArchiveFiles(existing));
			if (configured != null) {
				IResource resource = root.findMember(configured);
				if (resource instanceof IFile) {
					return new BPListElement[] {
							newBPLibraryElement(resource, false) };
				}
			}
		}
		return null;
	}

	private IPath[] getUsedContainers(BPListElement existing) {
		ArrayList<IPath> res = new ArrayList<>();
		List cplist = fLibrariesList.getElements();
		for (int i = 0; i < cplist.size(); i++) {
			BPListElement elem = (BPListElement) cplist.get(i);
			if (elem.getEntryKind() == IBuildpathEntry.BPE_LIBRARY
					&& (elem != existing)) {
				IResource resource = elem.getResource();
				if (resource instanceof IContainer
						&& !resource.equals(existing)) {
					res.add(resource.getFullPath());
				}
			}
		}
		return res.toArray(new IPath[res.size()]);
	}

	private IPath[] getUsedArchiveFiles(BPListElement existing) {
		List<IPath> res = new ArrayList<>();
		List cplist = fLibrariesList.getElements();
		for (int i = 0; i < cplist.size(); i++) {
			BPListElement elem = (BPListElement) cplist.get(i);
			if (elem.getEntryKind() == IBuildpathEntry.BPE_LIBRARY
					&& (elem != existing)) {
				IResource resource = elem.getResource();
				if (resource instanceof IFile) {
					res.add(resource.getFullPath());
				}
			}
		}
		return res.toArray(new IPath[res.size()]);
	}

	private BPListElement newBPLibraryElement(IResource res, boolean external) {
		return new BPListElement(fCurrJProject, IBuildpathEntry.BPE_LIBRARY,
				res.getFullPath(), res, external);
	}

	private BPListElement[] openExtZipFileDialog(BPListElement existing,
			IEnvironment environment) {
		if (existing == null) {
			IPath[] selected = BuildpathDialogAccess
					.chooseExternalArchiveEntries(getShell(), environment);
			if (selected != null) {
				ArrayList<BPListElement> res = new ArrayList<>();
				for (int i = 0; i < selected.length; i++) {
					res.add(new BPListElement(fCurrJProject,
							IBuildpathEntry.BPE_LIBRARY, selected[i], null,
							true));
				}
				return res.toArray(new BPListElement[res.size()]);
			}
		} else {
			IPath configured = BuildpathDialogAccess
					.configureExternalArchiveEntry(getShell(),
							existing.getPath());
			if (configured != null) {
				return new BPListElement[] { new BPListElement(fCurrJProject,
						IBuildpathEntry.BPE_LIBRARY, configured, null, true) };
			}
		}
		return null;
	}

	private BPListElement[] openContainerSelectionDialog(
			BPListElement existing) {
		if (existing == null) {
			IBuildpathEntry[] created = BuildpathDialogAccess
					.chooseContainerEntries(getShell(), fCurrJProject,
							getRawBuildpath());
			if (created != null) {
				BPListElement[] res = new BPListElement[created.length];
				for (int i = 0; i < res.length; i++) {
					res[i] = new BPListElement(fCurrJProject,
							IBuildpathEntry.BPE_CONTAINER, created[i].getPath(),
							null, false);
				}
				return res;
			}
		} else {
			IBuildpathEntry created = BuildpathDialogAccess
					.configureContainerEntry(getShell(),
							existing.getBuildpathEntry(), fCurrJProject,
							getRawBuildpath());
			if (created != null) {
				BPListElement elem = BPListElement.createFromExisting(created,
						fCurrJProject);
				return new BPListElement[] { elem };
			}
		}
		return null;
	}

	private IBuildpathEntry[] getRawBuildpath() {
		IBuildpathEntry[] currEntries = new IBuildpathEntry[fBuildPathList
				.getSize()];
		for (int i = 0; i < currEntries.length; i++) {
			BPListElement curr = (BPListElement) fBuildPathList.getElement(i);
			currEntries[i] = curr.getBuildpathEntry();
		}
		return currEntries;
	}

	@Override
	public boolean isEntryKind(int kind) {
		return kind == IBuildpathEntry.BPE_LIBRARY
				|| kind == IBuildpathEntry.BPE_CONTAINER;
	}

	@Override
	public List getSelection() {
		return fLibrariesList.getSelectedElements();
	}

	@Override
	public void setSelection(List selElements, boolean expand) {
		fLibrariesList.selectElements(new StructuredSelection(selElements));
		if (expand) {
			for (int i = 0; i < selElements.size(); i++) {
				fLibrariesList.expandElement(selElements.get(i), 1);
			}
		}
	}

	private IEnvironment getEnvironment() {
		return EnvironmentManager.getEnvironment(this.fCurrJProject);
	}
}