Java Code Examples for org.eclipse.search.ui.NewSearchUI#runQueryInBackground()

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
	IEditorPart part = HandlerUtil.getActiveEditor(event);
	if (part instanceof ITextEditor) {
		Collection<LSPDocumentInfo> infos = LanguageServiceAccessor.getLSPDocumentInfosFor(
				LSPEclipseUtils.getDocument((ITextEditor) part),
				capabilities -> Boolean.TRUE.equals(capabilities.getReferencesProvider()));
		if (!infos.isEmpty()) {
			LSPDocumentInfo info = infos.iterator().next();
			ISelection sel = ((AbstractTextEditor) part).getSelectionProvider().getSelection();

			if (sel instanceof TextSelection) {
				try {
					int offset = ((TextSelection) sel).getOffset();
					ImplementationsSearchQuery query = new ImplementationsSearchQuery(offset, info);
					NewSearchUI.runQueryInBackground(query);
				} catch (BadLocationException e) {
					LanguageServerPlugin.logError(e);
				}
			}
		}
	}
	return null;
}
 

@Override
public void run() {
	ITextSelection textSelection = getSelectedStringFromEditor();
	if (textSelection != null) {
		ISourceViewer textViewer = (ISourceViewer)editor.getAdapter(ISourceViewer.class);
		
		PstLeafNode pstLeafNode = ModulaEditorSymbolUtils.getIdentifierPstLeafNode(editor, textSelection.getOffset());
	    if (pstLeafNode != null) {
	        IModulaSymbol symbol = ModulaEditorSymbolUtils.getModulaSymbol(
                   textViewer.getDocument(), pstLeafNode
               );
	        IResource searchScope = getSearchScope();
			if (symbol != null && searchScope != null) {
				NewSearchUI.activateSearchResultView();
		        NewSearchUI.runQueryInBackground(new ModulaSearchQuery(getInput(symbol, searchScope)));
			}
	    }
	}
}
 

@Override
public boolean performAction() {
    saveQueryData();
    NewSearchUI.activateSearchResultView();
    NewSearchUI.runQueryInBackground(new ModulaSearchQuery(getInput()));
    return true;
 }
 

@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 void open() {
	// Execute Search
	try {
		int offset = tsFile.getPosition(getRange().startLineNumber, getRange().startColumn);
		TypeScriptSearchQuery query = new TypeScriptSearchQuery(tsFile.getResource(), offset);
		NewSearchUI.runQueryInBackground(query);
	} catch (TypeScriptException e) {
		e.printStackTrace();
	}
}
 

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);
	}
}
 

/**
 * @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
protected String perform(IAction action, IProgressMonitor monitor) throws Exception {
    IPyRefactoring2 r = (IPyRefactoring2) AbstractPyRefactoring.getPyRefactoring();
    RefactoringRequest req = getRefactoringRequest(new NullProgressMonitor()); //as we're doing it in the background
    req.fillInitialNameAndOffset();
    if (req.initialName != null && req.initialName.trim().length() > 0) {
        NewSearchUI.runQueryInBackground(newQuery(r, req));
    }
    return null;
}
 

@Override
public boolean performAction() {
    ScopeAndData scopeAndData = getScopeAndData();
    SearchIndexData data = new SearchIndexData(fPattern.getText(), fIsCaseSensitiveCheckbox.getSelection(),
            fIsWholeWordCheckbox.getSelection(), scopeAndData.scope, scopeAndData.scopeData, "*"); // filenamePattern is always * for Python searches (we'll always be searching the whole index).
    PySearchIndexQuery query = new PySearchIndexQuery(data);
    NewSearchUI.runQueryInBackground(query);
    searchIndexDataHistory.add(data);
    searchIndexDataHistory.writeConfiguration();
    return true;
}
 

@Override
public boolean performAction() {
  try {
    NewSearchUI.runQueryInBackground(newQuery());
  } catch (CoreException e) {
    ErrorDialog.openError(getShell(), "Search",
        "Problems occurred while searching. The affected files will be skipped.", e.getStatus());
    return false;
  }
  return true;
}
 

public void execute() {
	NewSearchUI.activateSearchResultView();
	NewSearchUI.runQueryInBackground(referenceQuery);
}
 

protected void fillInSearchView() {
	NewSearchUI.runQueryInBackground(new ReferencesInBinarySearchQuery(fInput), null);
	fButton.setEnabled(false);
}
 

public static void search(String scopeName, IType[] accessorClasses, IFile[] propertieFiles) {
	NLSSearchQuery query= new NLSSearchQuery(accessorClasses, propertieFiles, SearchEngine.createWorkspaceScope(), scopeName);
	NewSearchUI.runQueryInBackground(query);
}
 

private void performNewSearch(IOccurrencesFinder finder, ITypeRoot element) {
	NewSearchUI.runQueryInBackground(new OccurrencesSearchQuery(finder, element));
}
 

/**
 * 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);
    }
}
 

/**
 * This helper method with Object as parameter is needed to prevent the loading
 * of the Search plug-in: the VM verifies the method call and hence loads the
 * types used in the method signature, eventually triggering the loading of
 * a plug-in (in this case ISearchQuery results in Search plug-in being loaded).
 *
 * @param query the search query
 */
public static void runQueryInBackground(Object query) {
	NewSearchUI.runQueryInBackground((ISearchQuery)query);
}