Java 类org.eclipse.ui.progress.IWorkbenchSiteProgressService 实例源码

protected void readTargetDefinition() {
    OpenTargetFileDialog rd = new OpenTargetFileDialog(getSite().getShell(),
            ResourcesPlugin.getWorkspace().getRoot(), IResource.FILE);
    int result = rd.open();
    if(result == Window.OK){
        Object[] selection = rd.getResult();
        if (selection == null || selection.length != 1 || !(selection[0] instanceof IFile)) {
            viewer.setInput(null);
            return;
        }
        TargetData td = new TargetData((IFile) selection[0]);

        ViewContentProvider provider = getContentProvider();
        IWorkbenchSiteProgressService progressService = getProgressService();
        progressService.schedule(provider.getJob(td));
    }

}

@Override
public void run() {
    if (isChecked()) {
        for (TargetAction targetAction : targetActions) {
            targetAction.setChecked(false);
        }
        ViewContentProvider provider = getContentProvider();
        IWorkbenchSiteProgressService progressService = getProgressService();
        progressService.schedule(provider.getJob(targetDef));
        lastTargetDef = targetDef;
        setChecked(true);
    } else {
        lastTargetDef = null;
        viewer.setInput(null);
        setChecked(false);
    }
}

public static void schedule(Job job, IWorkbenchSite site) {
    if (site != null) {
        IWorkbenchSiteProgressService siteProgress = (IWorkbenchSiteProgressService) site.getAdapter(IWorkbenchSiteProgressService.class);
        if (siteProgress != null) {
            siteProgress.schedule(job, 0, true /* use half-busy cursor */);
            return;
        }
    }
    job.schedule();
}

protected void runJob(Job job) {
    IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) editorPage.getEditorSite()
            .getService(IWorkbenchSiteProgressService.class);
    if (service != null) {
        service.schedule(job, 0L, true);
    }
    else {
        job.schedule();
    }
}

protected void runJob(Job job) {
    IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) editorPage.getEditorSite().getService(
            IWorkbenchSiteProgressService.class);
    if (service != null) {
        service.schedule(job, 0L, true);
    }
    else {
        job.schedule();
    }
}

@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
  IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
  if (window != null) {
    IWorkbenchPage page = window.getActivePage();
    if (page != null) {
      IViewPart webAppView = page.findView(WebAppLaunchView.ID);
      if (webAppView == null) {
        try {
          webAppView = page.showView(WebAppLaunchView.ID);
        } catch (PartInitException e) {
          return StatusUtilities.newErrorStatus(e, Activator.PLUGIN_ID);
        }
      }

      if (webAppView != null) {
        synchronized(boldingLock) {
          if (bolding) {
            if (webAppView.getSite() != null) {
              IWorkbenchSiteProgressService service = 
                (IWorkbenchSiteProgressService) webAppView.getSite().getAdapter(
                  IWorkbenchSiteProgressService.class);
              if (service != null) {
                service.warnOfContentChange();
              }
            }
          } else {
            page.bringToTop(webAppView);
          }
        }
      }
    }
  }
  return Status.OK_STATUS;
}

public static void schedule(Job job, IWorkbenchSite site) {
    if (site != null) {
        IWorkbenchSiteProgressService siteProgress = (IWorkbenchSiteProgressService) site.getAdapter(IWorkbenchSiteProgressService.class);
        if (siteProgress != null) {
            siteProgress.schedule(job, 0, true /* use half-busy cursor */);
            return;
        }
    }
    job.schedule();
}

protected void hideWorkspacePlugins(boolean on) {
    isHideWorkspacePlugins = on;
    ViewContentProvider provider = getContentProvider();
    IWorkbenchSiteProgressService progressService = getProgressService();
    progressService.schedule(provider.getJob(lastTargetDef));
    refresh(new Object());
}

private IProgressService getProgressService() {
    IEditorPart editor= getTextEditor();
    if (editor != null) {
        IWorkbenchPartSite site= editor.getSite();
        if (site != null)
            return (IWorkbenchSiteProgressService) editor.getSite().getAdapter(IWorkbenchSiteProgressService.class);
    }
    return PlatformUI.getWorkbench().getProgressService();
}

private IProgressService getProgressService() {
    IEditorPart editor= getTextEditor();
    if (editor != null) {
        IWorkbenchPartSite site= editor.getSite();
        if (site != null)
            return (IWorkbenchSiteProgressService) editor.getSite().getAdapter(IWorkbenchSiteProgressService.class);
    }
    return PlatformUI.getWorkbench().getProgressService();
}

public final void run(final IAction action) {
    if (currentEditor != null) {
        IFile file = ((FileEditorInput) (currentEditor.getEditorInput())).getFile();
        Job job = new ClearMarkersJob(file, Arrays.asList(new WorkItem[] { new WorkItem(file) }));
        job.setUser(true);
        job.setPriority(Job.INTERACTIVE);
        IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) currentEditor.getEditorSite().getService(
                IWorkbenchSiteProgressService.class);
        service.schedule(job);
    }
}

@Test
public void scheduleWithDelegate() {
  IWorkbenchSiteProgressService delegate = mock( IWorkbenchSiteProgressService.class );
  ProgressService progressService = new ProgressService( delegate );
  Job job = mock( Job.class );

  progressService.schedule( job );

  verify( delegate ).schedule( job );
  verify( job, never() ).schedule();
}

public IWorkbenchSiteProgressService getProgressService() {
    return view.getProgressService();
}

public IWorkbenchSiteProgressService getProgressService() {
    IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) getSite()
            .getAdapter(IWorkbenchSiteProgressService.class);
    return service;
}

IWorkbenchSiteProgressService getProgressService() {
    return (IWorkbenchSiteProgressService) getSite()
            .getService(IWorkbenchSiteProgressService.class);
}

/**
 * Get the IWorkbenchSiteProgressService for the receiver.
 *
 * @return IWorkbenchSiteProgressService or <code>null</code>.
 */
protected IWorkbenchSiteProgressService getProgressService() {
    IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) getSite().getAdapter(
            IWorkbenchSiteProgressService.class);
    return service;
}

static IWorkbenchPartSite stubProgressServiceForDelayedSchedule() {
  IWorkbenchPartSite result = mock( IWorkbenchPartSite.class );
  IWorkbenchSiteProgressService progressService = stubProgressService( TestItem.FETCH_CHILDREN_DELAY );
  when( result.getAdapter( IWorkbenchSiteProgressService.class ) ).thenReturn( progressService );
  return result;
}

private static IWorkbenchSiteProgressService stubProgressService( int schedulingDelay ) {
  IWorkbenchSiteProgressService result = mock( IWorkbenchSiteProgressService.class );
  doAnswer( delay( schedulingDelay ) ).when( result ).schedule( any( Job.class ) );
  return result;
}

ProgressService( IWorkbenchSiteProgressService delegate ) {
  this.delegate = delegate;
}

private static ProgressService lookupProgressService( Adapters adapters, IWorkbenchPartSite site ) {
  return new ProgressService( adapters.getAdapter( site, IWorkbenchSiteProgressService.class ) );
}

@Override
public Object[] getElements(Object inputElement){
    if (bValid || bUpdating) {
        return pats;
    }
    if (pfilter != null) {
        pats = new String[] {
            Messages.PatListeContentProvider_LoadingData
        };
        ((TableViewer) viewer.getViewerWidget()).setItemCount(1);
    }

    if (!CoreHub.acl.request(AccessControlDefaults.PATIENT_DISPLAY)) {
        return new Object[0];
    }

    Job job = new Job(Messages.PatListeContentProvider_LoadingPatients) {

        @Override
        protected IStatus run(IProgressMonitor monitor){
            monitor.beginTask(Messages.PatListeContentProvider_LoadPatients,
                IProgressMonitor.UNKNOWN);
            if (pfilter != null) {
                if (pfilter.aboutToStart() == false) {
                    return Status.CANCEL_STATUS;
                }
            }
            syncRefresh();
            monitor.done();
            return Status.OK_STATUS;
        }

    };
    job.setPriority(Job.SHORT);
    job.setUser(false);
    bUpdating = true;
    IWorkbenchSiteProgressService siteService =
        (IWorkbenchSiteProgressService) site.getSite().getAdapter(
            IWorkbenchSiteProgressService.class);
    siteService.schedule(job, 0, true);

    job.setProperty(IProgressConstants.ICON_PROPERTY, Images.IMG_AUSRUFEZ_ROT.getImage());

    return pats;
}