Examples with IRunnableContext org.eclipse.jface.operation.IRunnableContext used on opensource projects

Example 6 with IRunnableContext

use of org.eclipse.jface.operation.IRunnableContext in project dbeaver by dbeaver.

the class UIUtils method runInUI.

public static void runInUI(final DBRRunnableWithProgress runnable) {
    IWorkbench workbench = PlatformUI.getWorkbench();
    IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
    IRunnableContext context = window != null ? window : DummyRunnableContext.INSTANCE;
    runInUI(context, runnable);
}

Example 7 with IRunnableContext

use of org.eclipse.jface.operation.IRunnableContext in project dbeaver by dbeaver.

the class CreateLinkHandler method execute.

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    ISelection structured = HandlerUtil.getCurrentSelection(event);
    if (structured.isEmpty() || !(structured instanceof IStructuredSelection)) {
        return null;
    }
    Object first = ((IStructuredSelection) structured).getFirstElement();
    IResource resource = GeneralUtils.adapt(first, IResource.class);
    IContainer container = extractContainer(resource);
    if (container == null) {
        IStatus error = GeneralUtils.makeErrorStatus(NLS.bind(UINavigatorMessages.CreateLinkHandler_e_create_link_validation, resource));
        StatusAdapter statusAdapter = new StatusAdapter(error);
        statusAdapter.setProperty(IStatusAdapterConstants.TITLE_PROPERTY, UINavigatorMessages.CreateLinkHandler_e_create_link_title);
        StatusManager.getManager().handle(statusAdapter, StatusManager.SHOW);
        return null;
    }
    Path[] locations = selectTargets(event);
    if (locations == null || locations.length == 0) {
        return null;
    }
    WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {

        @Override
        protected void execute(IProgressMonitor monitor) throws CoreException {
            if (container instanceof IFolder && !container.exists()) {
                // Create parent folder
                ((IFolder) container).create(true, true, monitor);
            }
            IStatus linked = createLink(container, monitor, locations);
            int severity = linked.getSeverity();
            switch(severity) {
                case IStatus.CANCEL:
                    throw new OperationCanceledException(linked.getMessage());
                case IStatus.ERROR:
                    throw new CoreException(linked);
                default:
                    break;
            }
        }
    };
    IRunnableContext context = getRunnableContext(event);
    try {
        context.run(true, true, operation);
    } catch (InvocationTargetException e) {
        IStatus error = GeneralUtils.makeErrorStatus(UINavigatorMessages.CreateLinkHandler_e_create_link_message, e.getTargetException());
        StatusAdapter statusAdapter = new StatusAdapter(error);
        statusAdapter.setProperty(IStatusAdapterConstants.TITLE_PROPERTY, UINavigatorMessages.CreateLinkHandler_e_create_link_title);
        StatusManager.getManager().handle(statusAdapter, StatusManager.LOG | StatusManager.SHOW);
    } catch (InterruptedException e) {
    // skip
    }
    return null;
}

Example 8 with IRunnableContext

use of org.eclipse.jface.operation.IRunnableContext in project egit by eclipse.

the class GitMergeEditorInput method buildDiffContainer.

private IDiffContainer buildDiffContainer(Repository repository, RevCommit headCommit, RevCommit ancestorCommit, List<String> filterPaths, RevWalk rw, IProgressMonitor monitor) throws IOException, InterruptedException {
    monitor.setTaskName(UIText.GitMergeEditorInput_CalculatingDiffTaskName);
    IDiffContainer result = new DiffNode(Differencer.CONFLICTING);
    try (TreeWalk tw = new TreeWalk(repository)) {
        int dirCacheIndex = tw.addTree(new DirCacheIterator(repository.readDirCache()));
        int fileTreeIndex = tw.addTree(new FileTreeIterator(repository));
        int repositoryTreeIndex = tw.addTree(rw.parseTree(repository.resolve(Constants.HEAD)));
        // skip ignored resources
        NotIgnoredFilter notIgnoredFilter = new NotIgnoredFilter(fileTreeIndex);
        // filter by selected resources
        if (filterPaths.size() > 1) {
            List<TreeFilter> suffixFilters = new ArrayList<>();
            for (String filterPath : filterPaths) suffixFilters.add(PathFilter.create(filterPath));
            TreeFilter otf = OrTreeFilter.create(suffixFilters);
            tw.setFilter(AndTreeFilter.create(otf, notIgnoredFilter));
        } else if (filterPaths.size() > 0) {
            String path = filterPaths.get(0);
            if (path.length() == 0)
                tw.setFilter(notIgnoredFilter);
            else
                tw.setFilter(AndTreeFilter.create(PathFilter.create(path), notIgnoredFilter));
        } else
            tw.setFilter(notIgnoredFilter);
        tw.setRecursive(true);
        while (tw.next()) {
            if (monitor.isCanceled())
                throw new InterruptedException();
            String gitPath = tw.getPathString();
            monitor.setTaskName(gitPath);
            FileTreeIterator fit = tw.getTree(fileTreeIndex, FileTreeIterator.class);
            if (fit == null)
                continue;
            DirCacheIterator dit = tw.getTree(dirCacheIndex, DirCacheIterator.class);
            final DirCacheEntry dirCacheEntry = dit == null ? null : dit.getDirCacheEntry();
            boolean conflicting = dirCacheEntry != null && dirCacheEntry.getStage() > 0;
            AbstractTreeIterator rt = tw.getTree(repositoryTreeIndex, AbstractTreeIterator.class);
            // compare local file against HEAD to see if it was modified
            boolean modified = rt != null && !fit.getEntryObjectId().equals(rt.getEntryObjectId());
            // if this is neither conflicting nor changed, we skip it
            if (!conflicting && !modified)
                continue;
            ITypedElement right;
            if (conflicting) {
                GitFileRevision revision = GitFileRevision.inIndex(repository, gitPath, DirCacheEntry.STAGE_3);
                String encoding = CompareCoreUtils.getResourceEncoding(repository, gitPath);
                right = new FileRevisionTypedElement(revision, encoding);
            } else
                right = CompareUtils.getFileRevisionTypedElement(gitPath, headCommit, repository);
            // can this really happen?
            if (right instanceof EmptyTypedElement)
                continue;
            IFileRevision rev;
            // if the file is not conflicting (as it was auto-merged)
            // we will show the auto-merged (local) version
            Path repositoryPath = new Path(repository.getWorkTree().getAbsolutePath());
            IPath location = repositoryPath.append(fit.getEntryPathString());
            IFile file = ResourceUtil.getFileForLocation(location, false);
            if (!conflicting || useWorkspace) {
                if (file != null)
                    rev = new LocalFileRevision(file);
                else
                    rev = new WorkingTreeFileRevision(location.toFile());
            } else {
                rev = GitFileRevision.inIndex(repository, gitPath, DirCacheEntry.STAGE_2);
            }
            IRunnableContext runnableContext = getContainer();
            if (runnableContext == null)
                runnableContext = PlatformUI.getWorkbench().getProgressService();
            EditableRevision leftEditable;
            if (file != null)
                leftEditable = new ResourceEditableRevision(rev, file, runnableContext);
            else
                leftEditable = new LocationEditableRevision(rev, location, runnableContext);
            // make sure we don't need a round trip later
            try {
                leftEditable.cacheContents(monitor);
            } catch (CoreException e) {
                throw new IOException(e.getMessage());
            }
            int kind = Differencer.NO_CHANGE;
            if (conflicting)
                kind = Differencer.CONFLICTING;
            else if (modified)
                kind = Differencer.PSEUDO_CONFLICT;
            IDiffContainer fileParent = getFileParent(result, repositoryPath, file, location);
            ITypedElement anc;
            if (ancestorCommit != null)
                anc = CompareUtils.getFileRevisionTypedElement(gitPath, ancestorCommit, repository);
            else
                anc = null;
            // instead of null
            if (anc instanceof EmptyTypedElement)
                anc = null;
            // create the node as child
            new DiffNode(fileParent, kind, anc, leftEditable, right);
        }
        return result;
    }
}

Example 9 with IRunnableContext

use of org.eclipse.jface.operation.IRunnableContext in project egradle by de-jcup.

the class GradleResourceHyperlink method open.

@Override
public void open() {
    String[] packageNames = fetchImportedPackages(fullText);
    Shell shell = EclipseUtil.getActiveWorkbenchShell();
    if (shell == null) {
        return;
    }
    IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    JDTDataAccess access = JDTDataAccess.SHARED;
    List<String> typesFound = access.scanForJavaType(resourceName, scope, packageNames);
    SelectionDialog dialog = null;
    if (!typesFound.isEmpty()) {
        if (typesFound.size() == 1) {
            /* exact macht possible */
            String found = typesFound.get(0);
            IType type = access.findType(found, new NullProgressMonitor());
            if (type instanceof IJavaElement) {
                IJavaElement javaElement = type;
                openInEditor(javaElement);
                return;
            } else {
            /* keep on going - use type dialog as fallback... */
            }
        }
        int style = IJavaElementSearchConstants.CONSIDER_ALL_TYPES;
        try {
            String found = typesFound.get(0);
            IRunnableContext runnableContext = EclipseUtil.getActiveWorkbenchWindow();
            dialog = JavaUI.createTypeDialog(shell, runnableContext, scope, style, false, found);
            dialog.setTitle("Potential Java types found:");
        } catch (JavaModelException e) {
            EditorUtil.INSTANCE.logError("Cannot create java type dialog", e);
        }
    } else {
        dialog = createResourceDialog(shell);
    }
    final int resultCode = dialog.open();
    if (resultCode != Window.OK) {
        return;
    }
    Object[] result = dialog.getResult();
    List<IFile> files = new ArrayList<>();
    List<IJavaElement> javaElements = new ArrayList<>();
    if (result != null) {
        for (int i = 0; i < result.length; i++) {
            Object object = result[i];
            if (object instanceof IFile) {
                files.add((IFile) object);
            } else if (object instanceof IJavaElement) {
                IJavaElement javaElement = (IJavaElement) object;
                javaElements.add(javaElement);
            }
        }
    }
    if (files.size() > 0) {
        final IWorkbenchPage page = EclipseUtil.getActivePage();
        if (page == null) {
            return;
        }
        IFile currentFile = null;
        try {
            for (Iterator<IFile> it = files.iterator(); it.hasNext(); ) {
                currentFile = it.next();
                IDE.openEditor(page, currentFile, true);
            }
        } catch (final PartInitException e) {
            EditorUtil.INSTANCE.logError("Cannot open file:" + currentFile, e);
        }
    } else if (javaElements.size() > 0) {
        IJavaElement javaElement = javaElements.get(0);
        openInEditor(javaElement);
    }
}

Example 10 with IRunnableContext

use of org.eclipse.jface.operation.IRunnableContext in project eclipse.jdt.ui by eclipse-jdt.

the class CallHierarchyContentProvider method fetchChildren.

protected Object[] fetchChildren(final MethodWrapper methodWrapper) {
    IRunnableContext context = JavaPlugin.getActiveWorkbenchWindow();
    MethodWrapperRunnable runnable = new MethodWrapperRunnable(methodWrapper);
    try {
        context.run(true, true, runnable);
    } catch (InvocationTargetException e) {
        ExceptionHandler.handle(e, CallHierarchyMessages.CallHierarchyContentProvider_searchError_title, CallHierarchyMessages.CallHierarchyContentProvider_searchError_message);
        return EMPTY_ARRAY;
    } catch (InterruptedException e) {
        final CallerMethodWrapper element = (CallerMethodWrapper) methodWrapper;
        if (!isExpandWithConstructors(element)) {
            Display.getDefault().asyncExec(() -> collapseAndRefresh(element));
        }
    }
    return runnable.getCalls();
}