Example usage for org.eclipse.jface.operation ModalContext checkCanceled

List of usage examples for org.eclipse.jface.operation ModalContext checkCanceled

  1. HOME
  2. Java
  3. org.eclipse.jface
  4. org.eclipse.jface.operation.*
  5. ModalContext
  6. checkCanceled

Introduction

In this page you can find the example usage for org.eclipse.jface.operation ModalContext checkCanceled.

Prototype

public static void checkCanceled(IProgressMonitor monitor) throws InterruptedException

Source Link

Document

Checks with the given progress monitor and throws InterruptedException if it has been canceled.

Usage

From source file:eu.numberfour.n4js.ui.export.nfar.NFARExportOperation.java

License:Open Source License

/**
 * @param hasCompiledFiles//w  w w .  java  2s. c  om
 *            TODO this has to be evaluated
 */
private void exportResource(URI exportedResource, boolean hasCompiledFiles) throws InterruptedException {
    Path path = new Path(exportedResource.toPlatformString(true));
    IFile exportedFile = workspace.getRoot().getFile(path);
    if (!exportedFile.isAccessible()) {
        return;
    }
    URI localPath = exportedResource.deresolve(rootLocation);
    String nameInZip = localPath.toString();
    monitor.subTask(nameInZip);
    try {
        exporter.writeFile(exportedFile.getContents(), exportedFile.getLocalTimeStamp(), nameInZip);
        // todo export compiled files
    } catch (IOException e) {
        addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, nameInZip, e.getMessage()), e);
    } catch (CoreException e) {
        addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, nameInZip, e.getMessage()), e);
    }

    monitor.worked(1);
    ModalContext.checkCanceled(monitor);
}

From source file:ext.org.eclipse.jdt.internal.ui.jarpackager.JarFileExportOperation.java

License:Open Source License

/**
 * Exports the passed resource to the JAR file
 *
 * @param element the resource or JavaElement to export
 * @param progressMonitor the progress monitor
 * @throws InterruptedException thrown on cancel
 *///from   w w  w .j a  v  a  2  s . co  m
private void exportElement(Object element, IProgressMonitor progressMonitor) throws InterruptedException {
    int leadSegmentsToRemove = 1;
    IPackageFragmentRoot pkgRoot = null;
    boolean isInJavaProject = false;
    IResource resource = null;
    ITypeRoot typeRootElement = null;
    IJavaProject jProject = null;
    if (element instanceof IJavaElement) {
        isInJavaProject = true;
        IJavaElement je = (IJavaElement) element;
        if (!(je instanceof ITypeRoot)) {
            exportJavaElement(progressMonitor, je);
            return;
        }
        typeRootElement = (ITypeRoot) je;
        jProject = typeRootElement.getJavaProject();
        pkgRoot = JavaModelUtil.getPackageFragmentRoot(je);
        resource = typeRootElement.getResource();
    } else if (element instanceof IResource) {
        resource = (IResource) element;
    } else {
        return;
    }

    if (!resource.isAccessible()) {
        addWarning(Messages.format(JarPackagerMessages.JarFileExportOperation_resourceNotFound,
                BasicElementLabels.getPathLabel(resource.getFullPath(), false)), null);
        return;
    }

    if (resource.getType() == IResource.FILE) {
        if (!isInJavaProject) {
            // check if it's a Java resource
            try {
                isInJavaProject = resource.getProject().hasNature(JavaCore.NATURE_ID);
            } catch (CoreException ex) {
                addWarning(
                        Messages.format(JarPackagerMessages.JarFileExportOperation_projectNatureNotDeterminable,
                                BasicElementLabels.getPathLabel(resource.getFullPath(), false)),
                        ex);
                return;
            }
            if (isInJavaProject) {
                IJavaElement je = JavaCore.create(resource);
                if (je instanceof ITypeRoot && je.exists()) {
                    exportElement(je, progressMonitor);
                    return;
                }

                jProject = JavaCore.create(resource.getProject());
                try {
                    IPackageFragment pkgFragment = jProject
                            .findPackageFragment(resource.getFullPath().removeLastSegments(1));
                    if (pkgFragment != null)
                        pkgRoot = JavaModelUtil.getPackageFragmentRoot(pkgFragment);
                    else
                        pkgRoot = findPackageFragmentRoot(jProject,
                                resource.getFullPath().removeLastSegments(1));
                } catch (JavaModelException ex) {
                    addWarning(Messages.format(
                            JarPackagerMessages.JarFileExportOperation_javaPackageNotDeterminable,
                            BasicElementLabels.getPathLabel(resource.getFullPath(), false)), ex);
                    return;
                }
            }
        }

        if (pkgRoot != null && jProject != null) {
            leadSegmentsToRemove = pkgRoot.getPath().segmentCount();
            boolean isOnBuildPath;
            isOnBuildPath = jProject.isOnClasspath(resource);
            if (!isOnBuildPath || (mustUseSourceFolderHierarchy()
                    && !pkgRoot.getElementName().equals(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH)))
                leadSegmentsToRemove--;
        }

        IPath destinationPath = resource.getFullPath().removeFirstSegments(leadSegmentsToRemove);

        if (typeRootElement != null) {
            exportClassFiles(progressMonitor, typeRootElement, destinationPath);
        }

        exportResource(progressMonitor, pkgRoot, isInJavaProject, resource, destinationPath);

        progressMonitor.worked(1);
        ModalContext.checkCanceled(progressMonitor);

    } else
        exportContainer(progressMonitor, (IContainer) resource);
}

From source file:ext.org.eclipse.jdt.internal.ui.jarpackager.JarFileExportOperation.java

License:Open Source License

private void exportExternalClassFolderElement(IJavaElement javaElement, IPath classFolderPath,
        IProgressMonitor progressMonitor) throws JavaModelException, InterruptedException {
    if (javaElement instanceof IClassFile) {
        IClassFile classFile = (IClassFile) javaElement;
        IPath path = classFile.getPath();

        IPath destination = path.removeFirstSegments(classFolderPath.segmentCount()).setDevice(null);

        try {/*from w  ww  . j a v a  2  s  .  com*/
            ((IJarBuilderExtension) fJarBuilder).writeFile(path.toFile(), destination);
        } catch (CoreException e) {
            handleCoreExceptionOnExport(e);
        } finally {
            progressMonitor.worked(1);
            ModalContext.checkCanceled(progressMonitor);
        }
    } else if (javaElement instanceof IPackageFragment) {
        IJavaElement[] children = ((IPackageFragment) javaElement).getChildren();
        for (int i = 0; i < children.length; i++) {
            exportExternalClassFolderElement(children[i], classFolderPath, progressMonitor);
        }
    }
}

From source file:ext.org.eclipse.jdt.internal.ui.jarpackager.JarFileExportOperation.java

License:Open Source License

private void exportResource(IProgressMonitor progressMonitor, IResource resource, int leadingSegmentsToRemove)
        throws InterruptedException {
    if (resource instanceof IContainer) {
        IContainer container = (IContainer) resource;
        IResource[] children;//  w  w  w. j a  va2  s  . co m
        try {
            children = container.members();
        } catch (CoreException e) {
            // this should never happen because an #isAccessible check is done before #members is invoked
            addWarning(Messages.format(JarPackagerMessages.JarFileExportOperation_errorDuringExport,
                    BasicElementLabels.getPathLabel(container.getFullPath(), false)), e);
            return;
        }
        for (int i = 0; i < children.length; i++)
            exportResource(progressMonitor, children[i], leadingSegmentsToRemove);
    } else if (resource instanceof IFile) {
        try {
            IPath destinationPath = resource.getFullPath().removeFirstSegments(leadingSegmentsToRemove);
            progressMonitor.subTask(Messages.format(JarPackagerMessages.JarFileExportOperation_exporting,
                    BasicElementLabels.getPathLabel(destinationPath, false)));
            fJarBuilder.writeFile((IFile) resource, destinationPath);
        } catch (CoreException ex) {
            handleCoreExceptionOnExport(ex);
        } finally {
            progressMonitor.worked(1);
            ModalContext.checkCanceled(progressMonitor);
        }
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageExportOperation.java

License:Open Source License

/**
 * Run the operation. The status (result) of the operation can be obtained
 * with {@link #getStatus}/*from  w ww  . j  a  v a 2s.  c  o  m*/
 *
 * @param progressMonitor
 *            the progress monitor to use to display progress and receive
 *            requests for cancellation
 */
@Override
public void run(IProgressMonitor progressMonitor) {

    try {
        int totalWork = getNbCheckedElements(fTraceExportElements) * 2;
        progressMonitor.beginTask(Messages.TracePackageExportOperation_GeneratingPackage, totalWork);

        fExportFolder = createExportFolder(progressMonitor);

        Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        Element createElement = doc.createElement(ITracePackageConstants.TMF_EXPORT_ELEMENT);
        Node tmfNode = doc.appendChild(createElement);

        for (TracePackageTraceElement tracePackageElement : fTraceExportElements) {
            if (!isFilesChecked(tracePackageElement)) {
                continue;
            }

            exportTrace(progressMonitor, tmfNode, tracePackageElement);
        }

        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
        transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
        DOMSource source = new DOMSource(doc);
        StringWriter buffer = new StringWriter();
        StreamResult result = new StreamResult(buffer);
        transformer.transform(source, result);
        String content = buffer.getBuffer().toString();

        ModalContext.checkCanceled(progressMonitor);

        exportManifest(content);

        setStatus(exportToArchive(progressMonitor, totalWork));

        fExportFolder.delete(true,
                new SubProgressMonitor(progressMonitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));

        progressMonitor.done();

    } catch (Exception e) {
        if (e instanceof InterruptedException) {
            setStatus(Status.CANCEL_STATUS);
        } else {
            setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                    fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.Messages.TracePackage_ErrorOperation,
                    e));
        }
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageExportOperation.java

License:Open Source License

private void exportTrace(IProgressMonitor monitor, Node tmfNode, TracePackageTraceElement tracePackageElement)
        throws InterruptedException, CoreException {
    TmfTraceElement traceElement = tracePackageElement.getTraceElement();
    Element traceXmlElement = tmfNode.getOwnerDocument().createElement(ITracePackageConstants.TRACE_ELEMENT);
    traceXmlElement.setAttribute(ITracePackageConstants.TRACE_NAME_ATTRIB,
            traceElement.getResource().getName());
    traceXmlElement.setAttribute(ITracePackageConstants.TRACE_TYPE_ATTRIB, traceElement.getTraceType());
    Node traceNode = tmfNode.appendChild(traceXmlElement);

    for (TracePackageElement element : tracePackageElement.getChildren()) {
        ModalContext.checkCanceled(monitor);
        if (!element.isChecked()) {
            continue;
        }//from w  ww  .j av  a  2  s  .  co  m

        if (element instanceof TracePackageSupplFilesElement) {
            exportSupplementaryFiles(monitor, traceNode, traceElement, (TracePackageSupplFilesElement) element);
        } else if (element instanceof TracePackageBookmarkElement) {
            exportBookmarks(monitor, traceNode, (TracePackageBookmarkElement) element);
        } else if (element instanceof TracePackageFilesElement) {
            exportTraceFiles(monitor, traceNode, (TracePackageFilesElement) element);
        }

        monitor.worked(1);
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageExportOperation.java

License:Open Source License

private void exportSupplementaryFiles(IProgressMonitor monitor, Node traceNode, TmfTraceElement traceElement,
        TracePackageSupplFilesElement element) throws InterruptedException, CoreException {
    Document doc = traceNode.getOwnerDocument();
    if (element.getChildren().length > 0) {

        IPath projectPath = traceElement.getProject().getPath();

        for (TracePackageElement child : element.getChildren()) {
            TracePackageSupplFileElement supplFile = (TracePackageSupplFileElement) child;
            ModalContext.checkCanceled(monitor);
            IResource res = supplFile.getResource();
            // project/.tracing/A/B/statistics.ht -> .tracing/A/B/statistics.ht
            IPath relativeToExportFolder = res.getFullPath().makeRelativeTo(projectPath);

            // project/.traceExport/.tracing/A/B
            IFolder folder = fExportFolder.getFolder(relativeToExportFolder.removeLastSegments(1));
            TraceUtils.createFolder(folder,
                    new SubProgressMonitor(monitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));

            res.refreshLocal(0,/*from   www .j a  va2 s .  c om*/
                    new SubProgressMonitor(monitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));
            createExportResource(folder, res);
            Element suppFileElement = doc.createElement(ITracePackageConstants.SUPPLEMENTARY_FILE_ELEMENT);

            suppFileElement.setAttribute(ITracePackageConstants.SUPPLEMENTARY_FILE_NAME_ATTRIB,
                    relativeToExportFolder.toString());
            traceNode.appendChild(suppFileElement);
        }

        IFolder suppFilesFolder = fExportFolder.getFolder(TmfCommonConstants.TRACE_SUPPLEMENTARY_FOLDER_NAME);
        fResources.add(suppFilesFolder);
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageExportOperation.java

License:Open Source License

private static void exportBookmarks(IProgressMonitor monitor, Node traceNode,
        TracePackageBookmarkElement element) throws CoreException, InterruptedException {
    Document doc = traceNode.getOwnerDocument();
    IFile bookmarksFile = ((TracePackageTraceElement) element.getParent()).getTraceElement().getBookmarksFile();
    if (bookmarksFile != null && bookmarksFile.exists()) {
        IMarker[] findMarkers = bookmarksFile.findMarkers(IMarker.BOOKMARK, false, IResource.DEPTH_ZERO);
        if (findMarkers.length > 0) {
            Element bookmarksXmlElement = doc.createElement(ITracePackageConstants.BOOKMARKS_ELEMENT);
            Node bookmarksNode = traceNode.appendChild(bookmarksXmlElement);

            for (IMarker marker : findMarkers) {
                ModalContext.checkCanceled(monitor);

                Element singleBookmarkXmlElement = doc.createElement(ITracePackageConstants.BOOKMARK_ELEMENT);
                for (String key : marker.getAttributes().keySet()) {
                    singleBookmarkXmlElement.setAttribute(key, marker.getAttribute(key).toString());
                }//from w ww  . ja  va 2  s  .  co m

                bookmarksNode.appendChild(singleBookmarkXmlElement);
            }
        }
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageExtractManifestOperation.java

License:Open Source License

/**
 * Run extract the manifest operation. The status (result) of the operation
 * can be obtained with {@link #getStatus}
 *
 * @param progressMonitor/*from  w  ww.  jav a  2s . c  o m*/
 *            the progress monitor to use to display progress and receive
 *            requests for cancellation
 */
@Override
public void run(IProgressMonitor progressMonitor) {
    TracePackageElement[] elements = null;
    try {
        progressMonitor.worked(1);
        ArchiveFile archiveFile = getSpecifiedArchiveFile();
        progressMonitor.worked(1);
        if (archiveFile == null) {
            setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                    Messages.TracePackageExtractManifestOperation_InvalidFormat));
            return;
        }

        Enumeration<?> entries = archiveFile.entries();

        boolean found = false;
        while (entries.hasMoreElements()) {
            ModalContext.checkCanceled(progressMonitor);

            ArchiveEntry entry = (ArchiveEntry) entries.nextElement();
            IPath p = new Path(entry.getName());
            //Remove project name
            p = p.removeFirstSegments(1);

            if (entry.getName().endsWith(ITracePackageConstants.MANIFEST_FILENAME)) {
                found = true;
                InputStream inputStream = archiveFile.getInputStream(entry);
                ManifestReader.validateManifest(inputStream);

                inputStream = archiveFile.getInputStream(entry);
                elements = ManifestReader.loadElementsFromManifest(inputStream);
                break;
            }

            progressMonitor.worked(1);
        }

        if (found) {
            setStatus(Status.OK_STATUS);
        } else {
            elements = generateElementsFromArchive();
            if (elements.length > 0) {
                setStatus(Status.OK_STATUS);
            } else {
                setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                        MessageFormat.format(
                                Messages.TracePackageExtractManifestOperation_ErrorManifestNotFound,
                                ITracePackageConstants.MANIFEST_FILENAME)));
            }
        }

        setResultElements(elements);

    } catch (InterruptedException e) {
        setStatus(Status.CANCEL_STATUS);
    } catch (Exception e) {
        setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                Messages.TracePackageExtractManifestOperation_ErrorReadingManifest, e));
    }
}

From source file:fr.inria.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport.TracePackageImportOperation.java

License:Open Source License

private void doRun(IProgressMonitor progressMonitor) {
    try {//from w ww.  ja  v a2  s.c  o m
        setStatus(deleteExistingTraces(progressMonitor));
        if (getStatus().getSeverity() != IStatus.OK) {
            return;
        }

        TracePackageFilesElement traceFilesElement = null;
        for (TracePackageElement packageElement : fImportTraceElements) {
            TracePackageTraceElement traceElement = (TracePackageTraceElement) packageElement;
            if (!isFilesChecked(packageElement)) {
                continue;
            }

            TracePackageElement[] children = traceElement.getChildren();
            for (TracePackageElement element : children) {
                ModalContext.checkCanceled(progressMonitor);

                if (element instanceof TracePackageFilesElement) {
                    traceFilesElement = (TracePackageFilesElement) element;
                    setStatus(importTraceFiles(traceFilesElement, traceElement, progressMonitor));

                } else if (element instanceof TracePackageSupplFilesElement) {
                    TracePackageSupplFilesElement suppFilesElement = (TracePackageSupplFilesElement) element;
                    setStatus(importSupplFiles(suppFilesElement, traceElement, progressMonitor));
                }

                if (getStatus().getSeverity() != IStatus.OK) {
                    return;
                }
            }
        }

    } catch (InterruptedException e) {
        setStatus(Status.CANCEL_STATUS);
    }
}