/*******************************************************************************
* Copyright (c) 2014 Hussein Mhanna
*
* 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:
* Hussein Mhanna - initial API and implementation
******************************************************************************/
package org.eclipse.rmf.reqif10.search.ui;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.ui.util.EditUIUtil;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.rmf.reqif10.pror.editor.IReqifEditor;
import org.eclipse.rmf.reqif10.pror.editor.presentation.Reqif10Editor;
import org.eclipse.rmf.reqif10.search.criteria.Criteria;
import org.eclipse.rmf.reqif10.search.edit.util.ReqIFEditSearcher;
import org.eclipse.rmf.reqif10.search.ui.masterdetails.CriteriasMasterDetailsBlock;
import org.eclipse.search.ui.IReplacePage;
import org.eclipse.search.ui.ISearchPage;
import org.eclipse.search.ui.ISearchPageContainer;
import org.eclipse.search.ui.ISearchQuery;
import org.eclipse.search.ui.NewSearchUI;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.ManagedForm;
public class ReqIFSearchPage extends DialogPage implements ISearchPage,
IReplacePage {
private static final String REQIF_EXTENSION = "reqif";
private ISearchPageContainer container;
private CriteriasMasterDetailsBlock masterDetailsBlock;
public ReqIFSearchPage() {
}
@Override
public void createControl(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
composite.setLayoutData(new GridData(GridData.FILL, GridData.FILL,
true, true));
composite.setLayout(new FillLayout());
IManagedForm managedForm = new ManagedForm(composite);
masterDetailsBlock = new CriteriasMasterDetailsBlock();
masterDetailsBlock.createContent(managedForm);
container.setPerformActionEnabled(true);
setControl(parent);
}
private List<IResource> getResources() {
IResource[] resources = new IResource[0];
switch (container.getSelectedScope()) {
case ISearchPageContainer.SELECTION_SCOPE:
Object[] objects = ((IStructuredSelection) (container
.getSelection())).toArray();
Set<IResource> resList = new HashSet<IResource>(objects.length);
for (Object object : objects) {
if (object instanceof IResource) {
resList.add((IResource) object);
} else if (object instanceof EObject) {
EObject eObject = (EObject) object;
Resource eResource = eObject.eResource();
if (eResource != null) {
URI eUri = eResource.getURI();
if (eUri.isPlatformResource()) {
String platformString = eUri.toPlatformString(true);
IResource resource = ResourcesPlugin.getWorkspace()
.getRoot().findMember(platformString);
resList.add(resource);
}
}
}
}
resources = resList.toArray(new IResource[0]);
break;
case ISearchPageContainer.WORKSPACE_SCOPE:
resources = ResourcesPlugin.getWorkspace().getRoot().getProjects();
break;
case ISearchPageContainer.WORKING_SET_SCOPE:
resources = convertToResources(container.getSelectedWorkingSets());
break;
}
return getReqIFResources(resources);
}
private List<IResource> getReqIFResources(IResource[] resources) {
List<IResource> reqIFResources = new ArrayList<IResource>();
for (IResource resource : resources) {
if (resource instanceof IFile
&& resource.getFileExtension() != null
&& resource.getFileExtension().equals(REQIF_EXTENSION)) {
reqIFResources.add(resource);
} else if (resource instanceof IContainer) {
try {
reqIFResources
.addAll(getReqIFResources(((IContainer) resource)
.members()));
} catch (CoreException e) {
e.printStackTrace();
}
}
}
return reqIFResources;
}
private static IResource[] convertToResources(IWorkingSet[] workingSets) {
List<IResource> res = new ArrayList<IResource>();
for (int i = 0; i < workingSets.length; i++) {
IWorkingSet workingSet = workingSets[i];
if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
return new IResource[] { ResourcesPlugin.getWorkspace()
.getRoot() };
}
IAdaptable[] elements = workingSet.getElements();
for (int k = 0; k < elements.length; k++) {
IResource curr = (IResource) elements[k]
.getAdapter(IResource.class);
if (curr != null) {
res.add(curr);
}
}
}
return (IResource[]) res.toArray(new IResource[res.size()]);
}
final void updateOKStatus() {
container.setPerformActionEnabled(true);
}
public Map<URI, EditingDomain> getEditorsURIMap() {
final Map<URI, EditingDomain> uriMap = new HashMap<URI, EditingDomain>();
PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
@Override
public void run() {
IEditorReference[] editorReferences = PlatformUI.getWorkbench()
.getActiveWorkbenchWindow().getActivePage()
.getEditorReferences();
for (IEditorReference editorReference : editorReferences) {
IEditorPart editorPart = editorReference.getEditor(false);
if (editorPart instanceof IReqifEditor) {
try {
uriMap.put(EditUIUtil.getURI(editorReference
.getEditorInput()),
((IEditingDomainProvider) editorPart)
.getEditingDomain());
} catch (PartInitException e) {
e.printStackTrace();
}
}
}
}
});
return uriMap;
}
public List<Resource> getEMFResources(Map<URI, EditingDomain> uriMap) {
ResourceSet resourceSet = new ResourceSetImpl();
List<IResource> resources = getResources();
List<Resource> emfResources = new ArrayList<Resource>();
for (IResource resource : resources) {
URI uri = URI.createPlatformResourceURI(resource.getFullPath()
.toOSString(), true);
EditingDomain editingDomain = uriMap.get(uri);
if (editingDomain != null) {
emfResources.addAll(editingDomain.getResourceSet()
.getResources());
} else {
Resource emfResource = resourceSet.getResource(uri, true);
if (emfResource != null) {
emfResources.add(emfResource);
}
}
}
return emfResources;
}
@Override
public boolean performReplace() {
IRunnableWithProgress runnable = new IRunnableWithProgress() {
@Override
public void run(final IProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
monitor.beginTask("Start Searching ...",
IProgressMonitor.UNKNOWN);
final Map<URI, EditingDomain> uriMap = getEditorsURIMap();
final List<Resource> resources = getEMFResources(uriMap);
ExtendedReqIFEdit reqIFEditSearcher = new ExtendedReqIFEdit(
uriMap);
reqIFEditSearcher.search(monitor, resources,
masterDetailsBlock.getCriterias(), true);
}
};
try {
new ProgressMonitorDialog(getShell()).run(true, true, runnable);
} catch (InvocationTargetException e) {
ReqIFSearchUIPlugin.getPlugin().log(e);
} catch (InterruptedException e) {
ReqIFSearchUIPlugin.getPlugin().log(e);
}
return true;
}
@SuppressWarnings("restriction")
@Override
public boolean performAction() {
ISearchQuery query = newQuery();
// Note : In the javadoc its explaned that we need to only call
// NewSearchUI.runQueryInForeground but due to a bug this doesn't work
// so I had to do the code below.
org.eclipse.search2.internal.ui.SearchView searchView = null;
try {
searchView = (org.eclipse.search2.internal.ui.SearchView) PlatformUI
.getWorkbench().getActiveWorkbenchWindow().getActivePage()
.showView(NewSearchUI.SEARCH_VIEW_ID);
} catch (final PartInitException e) {
ReqIFSearchUIPlugin.INSTANCE.log(e);
}
NewSearchUI.runQueryInForeground(new ProgressMonitorDialog(getShell()),
query);
if (searchView != null) {
searchView.showSearchResult(query.getSearchResult());
}
return true;
}
private ISearchQuery newQuery() {
return new ReqIFSearchQuery(this,
masterDetailsBlock.getCriterias());
}
@Override
public void setContainer(ISearchPageContainer container) {
this.container = container;
}
protected class ExtendedReqIFEdit extends ReqIFEditSearcher {
private final Map<URI, EditingDomain> uriMap;
public ExtendedReqIFEdit(Map<URI, EditingDomain> uriMap) {
this.uriMap = uriMap;
}
@Override
protected Collection<EObject> search(IProgressMonitor monitor,
Resource resource, Collection<Criteria> criterias,
boolean replace) {
final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED,
Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
Collection<EObject> result = super.search(monitor, resource,
criterias, replace);
if (false == uriMap.containsKey(resource.getURI())) {
try {
resource.save(saveOptions);
} catch (IOException e) {
ReqIFSearchUIPlugin.getPlugin().log(e);
}
}
return result;
}
public void executeCommand(final EditingDomain editingDomain,
final Command command) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
ExtendedReqIFEdit.super.executeCommand(editingDomain,
command);
}
});
}
}
}