org.eclipse.search.ui.ISearchQuery Java Examples

public CompositeSearchResult(CompositeSearchQuery compositeSearchQuery) {
	super(compositeSearchQuery);
	this.query = compositeSearchQuery;
	Assert.isLegal(!query.getChildren().isEmpty());
	childListener = new ISearchResultListener() {
		int removeAll = 0;
		@Override
		public void searchResultChanged(SearchResultEvent e) {
			if(!(e instanceof RemoveAllEvent) || removeAll++%query.getChildren().size() == 0)
				fireChange(e);
		}
	};
	for(ISearchQuery child: query.getChildren()) 
		child.getSearchResult().addListener(childListener);
}
 

/**
 * @see com.mulgasoft.emacsplus.commands.MinibufferExecHandler#doExecuteResult(org.eclipse.ui.texteditor.ITextEditor, java.lang.Object)
 */
public boolean doExecuteResult(ITextEditor editor, Object minibufferResult) {
	TextSearchQueryProvider provider= TextSearchQueryProvider.getPreferred();
	ISearchResult result = (ISearchResult)minibufferResult; 
	try {
		ISearchQuery query= provider.createQuery(getTextInput(result.getSearchStr(),result.isCaseSensitive(),getInputObject(editor)));
		if (query != null) {
			// and execute the search
			NewSearchUI.runQueryInBackground(query);
		}	
	} catch (OperationCanceledException ex) {
		// action canceled
	} catch (CoreException e) {}
	return true;
}
 

@Override
public void queryRemoved(ISearchQuery query) {
    if (fResult.equals(query.getSearchResult())) {
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
        NewSearchUI.removeQueryListener(this);
    }
}
 

@Override
public void queryRemoved(ISearchQuery query) {
    if (fResult.equals(query.getSearchResult())) {
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
        NewSearchUI.removeQueryListener(this);
    }
}
 

private static void performFind(final String searchText, final boolean caseSensitive, final boolean isRegEx,
		final FileTextSearchScope searchScope)
{
	try
	{
		ISearchQuery query = TextSearchQueryProvider.getPreferred().createQuery(new TextSearchInput()
		{

			public boolean isRegExSearch()
			{
				return isRegEx;
			}

			public boolean isCaseSensitiveSearch()
			{
				return caseSensitive;
			}

			public String getSearchText()
			{
				return searchText;
			}

			public FileTextSearchScope getScope()
			{
				return searchScope; //$NON-NLS-1$
			}
		});
		NewSearchUI.runQueryInBackground(query);
	}
	catch (CoreException e1)
	{
		FindBarPlugin.log(e1);
	}
}
 

@Override
public void run(IAction action) {
   	final String pattern = getPattern();
   	if (pattern.isEmpty()) {
   		return;
   	}
       
       try {
       	ISearchQuery query = TextSearchQueryProvider.getPreferred().createQuery(new TextSearchInput() {
			
			@Override
			public boolean isRegExSearch() {
				return true;
			}
			
			@Override
			public boolean isCaseSensitiveSearch() {
				return true;
			}
			
			@Override
			public String getSearchText() {
				return pattern;
			}
			
			@Override
			public FileTextSearchScope getScope() {
				return SearchWholeWordAction.this.getScope(); //$NON-NLS-1$
			}
		});
       	NewSearchUI.runQueryInBackground(query);
	} catch (CoreException e) {
		e.printStackTrace();
	}
       
	return;
}
 

@Override
public boolean canRunInBackground() {
	for(ISearchQuery child: children) 
		if(!child.canRunInBackground())
			return false;
	return true;
}
 

@Override
public IStatus run(IProgressMonitor monitor) throws OperationCanceledException {
	SubMonitor progress = SubMonitor.convert(monitor, children.size());
	MultiStatus multiStatus = new MultiStatus(getPluginId(), 
			IStatus.OK, "Composite search state", null);
	for(ISearchQuery child: children) {
		IStatus status = child.run(progress.newChild(1));
		multiStatus.add(status);
		if(progress.isCanceled()) {
			return Status.CANCEL_STATUS;
		}
	}
	return multiStatus;
}
 

@Override
public int getMatchCount(Object element) {
	int count = 0;
	for(ISearchQuery child: query.getChildren()) {
		ISearchResult childResult = child.getSearchResult();
		if(childResult instanceof AbstractTextSearchResult)
			count += ((AbstractTextSearchResult) childResult).getMatchCount(element);
	}
	return count;
}
 

@Override
public int getMatchCount() {
	int count = 0;
	for(ISearchQuery child: query.getChildren()) {
		ISearchResult childResult = child.getSearchResult();
		if(childResult instanceof AbstractTextSearchResult)
			count += ((AbstractTextSearchResult) childResult).getMatchCount();
	}
	return count;
}
 

@Override
public Match[] getMatches(Object element) {
	List<Match> matches = newArrayList();
	for(ISearchQuery child: query.getChildren()) {
		ISearchResult childResult = child.getSearchResult();
		if(childResult instanceof AbstractTextSearchResult) {
			for(Match match: ((AbstractTextSearchResult) childResult).getMatches(element)) 
				matches.add(match);
			
		}
	}
	return toArray(matches, Match.class);
}
 

@Override
public boolean canRerun() {
	for(ISearchQuery child: children) 
		if(!child.canRerun())
			return false;
	return true;
}
 

@Override
public ISearchQuery getQuery() {
	return query;
}
 

@Override
public ISearchQuery getQuery() {
    return fQuery;
}
 

private ISearchQuery newQuery(final IPyRefactoring2 r, final RefactoringRequest req) {
    return new FindOccurrencesSearchQuery(r, req);
}
 

@Override
public void queryFinished(ISearchQuery query) {
    // don't care
}
 

@Override
public void queryStarting(ISearchQuery query) {
    // don't care
}
 

/**
 * Here, all the editors available will be gotten and searched (if possible).
 *
 * Note that editors that are not in the workspace may not be searched (it should be possible
 * to do, but one may have to reimplement large portions of the search for that to work).
 */
public static void findInOpenDocuments(final String searchText, final boolean caseSensitive,
        final boolean wholeWord, final boolean isRegEx, IStatusLineManager statusLineManager) {

    final List<Object> opened = EditorUtils.getFilesInOpenEditors(statusLineManager);
    final List<IFile> files = new ArrayList<>(opened.size());
    for (Object object : opened) {
        if (object instanceof IFile) {
            files.add((IFile) object);
        }
    }

    if (files.size() == 0) {
        if (statusLineManager != null) {
            statusLineManager
                    .setMessage(
                            "No file was found to perform the search (editors not in the workspace cannot be searched).");
        }
        return;
    }

    try {
        ISearchQuery query = TextSearchQueryProvider.getPreferred().createQuery(new TextSearchInput() {

            @Override
            public boolean isRegExSearch() {
                return isRegEx;
            }

            @Override
            public boolean isCaseSensitiveSearch() {
                return caseSensitive;
            }

            @Override
            public String getSearchText() {
                return searchText;
            }

            @Override
            public FileTextSearchScope getScope() {
                return FileTextSearchScope.newSearchScope(files.toArray(new IResource[files.size()]),
                        new String[] { "*" }, true);
            }
        });
        NewSearchUI.runQueryInBackground(query);
    } catch (CoreException e1) {
        Log.log(e1);
    }
}
 

@Override
public void queryAdded(ISearchQuery query) {
    // don't care
}
 

@Override
public ISearchQuery getQuery() {
    return query;
}
 

@Override
public String getLabel() {
    StructuredViewer viewer = getViewer();
    if (viewer instanceof TreeViewer) {
        int count = 0;
        TreeViewer tv = (TreeViewer) viewer;

        final AbstractTextSearchResult input = getInput();
        if (input != null) {
            ViewerFilter[] filters = tv.getFilters();
            if (filters != null && filters.length > 0) {
                Object[] elements = input.getElements();
                for (int j = 0; j < elements.length; j++) {
                    Object element = elements[j];
                    Match[] matches = input.getMatches(element);
                    for (Match match : matches) {
                        for (int i = 0; i < filters.length; i++) {
                            ViewerFilter vf = filters[i];
                            if (vf instanceof AbstractSearchResultsViewerFilter) {
                                AbstractSearchResultsViewerFilter searchResultsViewerFilter = (AbstractSearchResultsViewerFilter) vf;
                                if (searchResultsViewerFilter.isLeafMatch(viewer, match)) {
                                    count += 1;
                                }
                            }
                        }
                    }
                }
            } else {
                // No active filters
                count = input.getMatchCount();
            }
        }
        AbstractTextSearchResult result = getInput();
        if (result == null) {
            return "";
        }
        ISearchQuery query = result.getQuery();
        if (query instanceof AbstractSearchIndexQuery) {
            AbstractSearchIndexQuery searchIndexQuery = (AbstractSearchIndexQuery) query;
            return searchIndexQuery.getResultLabel(count);
        }
    }
    return super.getLabel();
}
 

@Override
public void queryFinished(ISearchQuery query) {
    // don't care
}
 

@Override
public void queryStarting(ISearchQuery query) {
    // don't care
}
 

@Override
public void queryAdded(ISearchQuery query) {
    // don't care
}
 

private ISearchQuery newQuery() throws CoreException {
  SearchPatternData data = getPatternData();
  TextSearchPageInput input = new TextSearchPageInput(data.textPattern, data.isCaseSensitive,
      data.isRegExSearch, createTextSearchScope());
  return TextSearchQueryProvider.getPreferred().createQuery(input);
}
 

public ISearchQuery getQuery() {
	return fQuery;
}
 

public ISearchQuery getQuery() {
	return fQuery;
}
 

public void queryFinished(ISearchQuery query) {
	// not interested
}
 

public void queryStarting(ISearchQuery query) {
	// not interested
}
 

public void queryRemoved(ISearchQuery query) {
	if (fResult.equals(query.getSearchResult())) {
		JavaCore.removeElementChangedListener(this);
		NewSearchUI.removeQueryListener(this);
	}
}