org.eclipse.core.runtime.IProgressMonitor java code examples

Refine search

Common ways to obtain IProgressMonitor

private void myMethod () {
 IProgressMonitor i =new NullProgressMonitor()
Policy.monitorFor(null)
JavaModelOperation javaModelOperation;javaModelOperation.getSubProgressMonitor(workAmount)
Smart code suggestions by Tabnine
}

@SuppressWarnings( "unchecked" )
private RowMetaAndData[] doScan( IProgressMonitor monitor ) throws Exception {
 monitor.beginTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.ScanningFile",
   filename ), 1 );
 monitor.worked( 1 );
 if ( monitor.isCanceled() ) {
  return null;
 monitor.worked( 1 );
 monitor
   .beginTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.ReadingDocument" ), 1 );
 if ( monitor.isCanceled() ) {
  return null;
  monitor.worked( 1 );
  monitor.beginTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.DocumentOpened" ),
    1 );
  monitor.worked( 1 );
  monitor.beginTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.ReadingNode" ), 1 );
  if ( monitor.isCanceled() ) {
   return null;
  monitor.worked( 1 );
  monitor.subTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.FetchNodes" ) );
  if ( monitor.isCanceled() ) {
   return null;

private void addLoopXPath( Node node, IProgressMonitor monitor ) {
 Element ce = (Element) node;
 monitor.worked( 1 );
 // List child
 for ( int j = 0; j < ce.nodeCount(); j++ ) {
  if ( monitor.isCanceled() ) {
   return;
  }
  Node cnode = ce.node( j );
  if ( !Utils.isEmpty( cnode.getName() ) ) {
   Element cce = (Element) cnode;
   if ( !listpath.contains( cnode.getPath() ) ) {
    nr++;
    monitor.subTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.FetchNodes",
      String.valueOf( nr ) ) );
    monitor.subTask( BaseMessages.getString( PKG, "GetXMLDateLoopNodesImportProgressDialog.Task.AddingNode",
      cnode.getPath() ) );
    listpath.add( cnode.getPath() );
   }
   // let's get child nodes
   if ( cce.nodeCount() > 1 ) {
    addLoopXPath( cnode, monitor );
   }
  }
 }
}

public void run( IProgressMonitor monitor ) throws InvocationTargetException, InterruptedException {
 int size = transMeta.findNrPrevSteps( stepInfo );
 try {
  if ( before ) {
   monitor.beginTask( BaseMessages.getString(
    PKG, "SearchFieldsProgressDialog.Dialog.SearchInputFields.Message" ), size ); // Searching
                                           // for
                                           // input
                                           // fields...
   fields = transMeta.getPrevStepFields( stepInfo, new ProgressMonitorAdapter( monitor ) );
  } else {
   monitor.beginTask( BaseMessages.getString(
    PKG, "SearchFieldsProgressDialog.Dialog.SearchOutputFields.Message" ), size ); // Searching
                                            // for
                                            // output
                                            // fields...
   fields = transMeta.getStepFields( stepInfo, new ProgressMonitorAdapter( monitor ) );
  }
 } catch ( KettleStepException kse ) {
  throw new InvocationTargetException( kse, BaseMessages.getString(
   PKG, "SearchFieldsProgressDialog.Log.UnableToGetFields", stepInfo.toString(), kse.getMessage() ) );
 }
 monitor.done();
}

private void validateManifestFile(IFile file, IProgressMonitor monitor) {
  if (monitor.isCanceled())
    return;
  String message = NLS.bind(PDECoreMessages.Builders_verifying, file.getFullPath().toString());
  monitor.subTask(message);
  BundleErrorReporter reporter = new BundleErrorReporter(file);
  if (reporter != null) {
    reporter.validateContent(monitor);
    monitor.subTask(PDECoreMessages.Builders_updating);
  }
  monitor.done();
}

try {
  monitor = ProgressUtil.getMonitorFor(monitor);
  monitor.beginTask(Messages.loadingTask, 5);
  InputStream in = new FileInputStream(path.append("catalina.policy").toFile());
  in.read();
  in.close();
  monitor.worked(1);
  server = (Server) serverFactory.loadDocument(new FileInputStream(path.append("server.xml").toFile()));
  serverInstance = new ServerInstance(server, null, null);
  monitor.worked(1);
  webAppDocument = new WebAppDocument(path.append("web.xml"));
  monitor.worked(1);
  tomcatUsersDocument = XMLUtil.getDocumentBuilder().parse(new InputSource(new FileInputStream(path.append("tomcat-users.xml").toFile())));
  monitor.worked(1);
  policyFile = TomcatVersionHelper.getFileContents(new FileInputStream(path.append("catalina.policy").toFile()));
  monitor.worked(1);
  if (monitor.isCanceled())
    return;
  monitor.done();
} catch (Exception e) {
  Trace.trace(Trace.WARNING, "Could not load Tomcat v4.0 configuration from " + path.toOSString() + ": " + e.getMessage());
  throw new CoreException(new Status(IStatus.ERROR, TomcatPlugin.PLUGIN_ID, 0, NLS.bind(Messages.errorCouldNotLoadConfiguration, path.toOSString()), e));

  protected void worked(IProgressMonitor monitor, int work) {
    if (monitor != null) {
      if (monitor.isCanceled()) {
        throw new OperationCanceledException();
      } else {
        monitor.worked(work);
      }
    }
  }
/**

@Override
protected void collectAll(IResource resource, int depth,
    final IProgressMonitor monitor) {
  Policy.checkCanceled(monitor);
  monitor.beginTask(null, IProgressMonitor.UNKNOWN);
  ResourceTraversal[] traversals = new ResourceTraversal[] { new ResourceTraversal(new IResource[] { resource }, depth, IResource.NONE) };
  try {
    getSubscriber().accept(traversals, diff -> {
      Policy.checkCanceled(monitor);
      monitor.subTask(NLS.bind(Messages.SubscriberDiffTreeEventHandler_0, tree.getResource(diff).getFullPath().toString()));
      // Queue up any found diffs for inclusion into the output tree
      queueDispatchEvent(
          new SubscriberDiffChangedEvent(tree.getResource(diff), SubscriberEvent.CHANGE, IResource.DEPTH_ZERO, diff));
      // Handle any pending dispatches
      handlePreemptiveEvents(monitor);
      handlePendingDispatch(monitor);
      return true;
    });
  } catch (CoreException e) {
    if (resource.getProject().isAccessible())
      handleException(e, resource, ITeamStatus.SYNC_INFO_SET_ERROR, e.getMessage());
  } finally {
    monitor.done();
  }
}

@Override
public void run(IProgressMonitor mon) throws InvocationTargetException, InterruptedException {
  mon.beginTask(PDEUIMessages.FormatManifestOperation_task, fObjects.length);
  for (int i = 0; !mon.isCanceled() && i < fObjects.length; i++) {
    Object obj = fObjects[i];
    if (obj instanceof IFileEditorInput)
      obj = ((IFileEditorInput) obj).getFile();
    if (obj instanceof IFile) {
      mon.subTask(NLS.bind(PDEUIMessages.FormatManifestOperation_subtask, ((IFile) obj).getFullPath().toString()));
      format((IFile) obj, mon);
    }
    mon.worked(1);
  }
}

private void createExecFile(IProgressMonitor monitor) throws IOException,
  CoreException {
 monitor.beginTask(
   NLS.bind(CoreMessages.ExportingSession_task, session.getDescription()),
   1);
 final OutputStream out = new BufferedOutputStream(new FileOutputStream(
   destination));
 final ExecutionDataWriter writer = new ExecutionDataWriter(out);
 session.accept(writer, writer);
 out.close();
 monitor.done();
}

  private void modifyClassPaths(IProgressMonitor pm) throws JavaModelException {
    IProject[] referencing= getProject().getReferencingProjects();
    pm.beginTask(RefactoringCoreMessages.RenameJavaProjectChange_update, referencing.length);
    for (int i= 0; i < referencing.length; i++) {
      IJavaProject jp= JavaCore.create(referencing[i]);
      if (jp != null && jp.exists()) {
        modifyClassPath(jp, new SubProgressMonitor(pm, 1));
      } else {
        pm.worked(1);
      }
    }
    pm.done();
  }
}

  protected IStatus run(IProgressMonitor monitor) {
    IStatus status = Status.OK_STATUS;
    monitor.beginTask(getName(), IProgressMonitor.UNKNOWN);
    try {
      mListener.closeConnection(mEvent);
    }
    catch (CoreException e) {
      status = e.getStatus();
    }
    monitor.done();
    return status;
  }
}

private IStatus refresh(IResource resource, int depth, IProgressMonitor monitor) {
  monitor = Policy.monitorFor(monitor);
  try {
    monitor.beginTask(null, 100);
    Set<IResource> allChanges = new HashSet<>();
    if (getResourceComparator().isThreeWay()) {
      IResource[] baseChanges = getBaseTree().refresh(new IResource[] {resource}, depth, Policy.subMonitorFor(monitor, 25));
      allChanges.addAll(Arrays.asList(baseChanges));
    }
    IResource[] remoteChanges = getRemoteTree().refresh(new IResource[] {resource}, depth, Policy.subMonitorFor(monitor, 75));
    allChanges.addAll(Arrays.asList(remoteChanges));
    IResource[] changedResources = allChanges.toArray(new IResource[allChanges.size()]);
    fireTeamResourceChange(SubscriberChangeEvent.asSyncChangedDeltas(this, changedResources));
    return Status.OK_STATUS;
  } catch (TeamException e) {
    return new TeamStatus(IStatus.ERROR, TeamPlugin.ID, 0, NLS.bind(Messages.ResourceVariantTreeSubscriber_2, new String[] { resource.getFullPath().toString(), e.getMessage() }), e, resource);
  } catch (OperationCanceledException e) {
    return new TeamStatus(IStatus.CANCEL, TeamPlugin.ID, 0, NLS.bind(
        Messages.ResourceVariantTreeSubscriber_4,
        new String[] { resource.getFullPath().toString() }), e,
        resource);
  } finally {
    monitor.done();
  }
}

public final void acceptAST(final ICompilationUnit unit, final CompilationUnit node) {
  final IProgressMonitor subsubsubMonitor= new SubProgressMonitor(subsubMonitor, 100);
  try {
    subsubsubMonitor.beginTask("", 100); //$NON-NLS-1$
    subsubsubMonitor.setTaskName(RefactoringCoreMessages.SuperTypeRefactoringProcessor_creating);
    if (sourceRewrite != null)
      rewriteTypeOccurrences(manager, this, sourceRewrite, unit, node, replacements, new SubProgressMonitor(subsubsubMonitor, 100));
  } catch (CoreException exception) {
    status.merge(RefactoringStatus.createFatalErrorStatus(exception.getLocalizedMessage()));
  } finally {
    subsubsubMonitor.done();
  }
}

/**
 * Check whether the build has been canceled.
 */
public void checkCancel() {
  if (this.monitor != null && this.monitor.isCanceled())
    throw new OperationCanceledException();
}

  @Override
  public IStatus run(IProgressMonitor monitor) {
    if (monitor.isCanceled())
      return Status.CANCEL_STATUS;
    notificationRequested = true;
    try {
      workspace.run(noop, null, IResource.NONE, null);
    } catch (CoreException e) {
      return e.getStatus();
    }
    return Status.OK_STATUS;
  }
}

public boolean isCanceled() {
 return monitor.isCanceled();
}

public static void convertToOSGIFormat(IProject project, String target, Dictionary dictionary, HashMap newProps, IProgressMonitor monitor) throws CoreException {
  try {
    File outputFile = new File(project.getLocation().append(
        "META-INF/MANIFEST.MF").toOSString()); //$NON-NLS-1$
    File inputFile = new File(project.getLocation().toOSString());
    PluginConverter converter = PluginConverter.getDefault();
    converter.convertManifest(inputFile, outputFile, false, target, true, dictionary);
    if (newProps != null && newProps.size() > 0)
      converter.writeManifest(outputFile, getProperties(outputFile, newProps), false);
  
    project.refreshLocal(IResource.DEPTH_INFINITE, null);
  } catch (PluginConversionException e) {
  }  finally {
    monitor.done();
  }
}

@Override
protected IStatus run(IProgressMonitor monitor) {
  try {
    removeOperation.execute(monitor);
  } catch (CoreException e) {
    return Activator.createErrorStatus(e.getStatus()
        .getMessage(), e);
  } finally {
    monitor.done();
  }
  return Status.OK_STATUS;
}

public final Change perform(IProgressMonitor pm) throws CoreException, OperationCanceledException {
  pm.beginTask(getName(), 2);
  try {
    String newName= getNewResourceName();
    IPackageFragmentRoot root= getRoot();
    ResourceMapping mapping= JavaElementResourceMapping.create(root);
    final Change result= doPerformReorg(getDestinationProjectPath().append(newName), new SubProgressMonitor(pm, 1));
    markAsExecuted(root, mapping);
    return result;
  } finally {
    pm.done();
  }
}

protected IStatus run(IProgressMonitor monitor) {
  monitor.beginTask("", 10); //$NON-NLS-1$
  try {
    JavaCore.initializeAfterLoad(new SubProgressMonitor(monitor, 6));
    JavaPlugin.initializeAfterLoad(new SubProgressMonitor(monitor, 4));
  } catch (CoreException e) {
    JavaPlugin.log(e);
    return e.getStatus();
  }
  return new Status(IStatus.OK, JavaPlugin.getPluginId(), IStatus.OK, "", null); //$NON-NLS-1$
}
public boolean belongsTo(Object family) {

Javadoc

The IProgressMonitor interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

All activity is broken down into a linear sequence of tasks against which progress is reported. When a task begins, a beginTask(String, int) notification is reported, followed by any number and mixture of progress reports (worked()) and subtask notifications (subTask(String)). When the task is eventually completed, a done() notification is reported. After the done() notification, the progress monitor cannot be reused; i.e., beginTask(String, int) cannot be called again after the call to done().

A request to cancel an operation can be signaled using the setCanceled method. Operations taking a progress monitor are expected to poll the monitor (using isCanceled) periodically and abort at their earliest convenience. Operation can however choose to ignore cancelation requests.

Since notification is synchronous with the activity itself, the listener should provide a fast and robust implementation. If the handling of notifications would involve blocking operations, or operations which might throw uncaught exceptions, the notifications should be queued, and the actual processing deferred (or perhaps delegated to a separate thread).

This interface can be used without OSGi running.

Clients may implement this interface.

Most used methods

done
Notifies that the work is done; that is, either the main task is completed or the user canceled it.
beginTask
Notifies that the main task is beginning. This must only be called once on a given progress monitor
isCanceled
Returns whether cancelation of current operation has been requested. Long-running operations should
worked
Notifies that a given number of work unit of the main task has been completed. Note that this amount
subTask
Notifies that a subtask of the main task is beginning. Subtasks are optional; the main task might no
setTaskName
Sets the task name to the given value. This method is used to restore the task label after a nested
setCanceled
Sets the cancel state to the given value.
internalWorked
Internal method to handle scaling correctly. This method must not be called by a client. Clients sho

Popular in Java

Start an intent from android
requestLocationUpdates (LocationManager)
setContentView (Activity)
scheduleAtFixedRate (Timer)
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
Proxy (java.net)
This class represents proxy server settings. A created instance of Proxy stores a type and an addres
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
Deque (java.util)
A linear collection that supports element insertion and removal at both ends. The name deque is shor
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin
Top 15 Vim Plugins

How to useIProgressMonitor in org.eclipse.core.runtime

Best Java code snippets using org.eclipse.core.runtime.IProgressMonitor (Showing top 20 results out of 2,331)

Refine search

How to use
IProgressMonitor
in
org.eclipse.core.runtime