Java Status.CANCEL_STATUS属性代码示例

@Override
protected IStatus run(IProgressMonitor monitor) {
	try {
		if (editor!=null) editor.setSafeEnabled(false);
	    scannable.setPosition(value); // Blocking call
	    if (editor!=null && value instanceof Number) {
		editor.setSafeValue(((Number)value).doubleValue());
	    }
	    return Status.OK_STATUS;

	} catch (Exception e) {
		editor.setSafeText(e.getMessage());
		logger.error("Cannot set position!", e);
	    return Status.CANCEL_STATUS;

	} finally {
		editor.setSafeEnabled(true);
	}
}
 

/**
 * @param jobname
 * @param tasks
 * @return
 */
public static Job createJob(String jobname, List<UITask.Task> tasks) {
	Job job = new Job(jobname) {
		@Override
		protected IStatus run(IProgressMonitor monitor) {
			SubMonitor subMonitor = SubMonitor.convert(monitor, tasks.size());
			for (UITask.Task task : tasks) {
				try {
					subMonitor.setTaskName(task.getSummary());
					workOnTask(task, subMonitor.split(1));
				} catch (Exception e) {
					return Status.CANCEL_STATUS;
				}
			}
			return Status.OK_STATUS;
		}
	};
	job.setUser(true);
	return job;
}
 

@Override
protected IStatus run(IProgressMonitor monitor) {
    SubMonitor pm = SubMonitor.convert(
            monitor, Messages.commitPartDescr_commiting, 2);

    Log.log(Log.LOG_INFO, "Applying diff tree to db"); //$NON-NLS-1$
    pm.newChild(1).subTask(Messages.commitPartDescr_modifying_db_model); // 1
    pm.newChild(1).subTask(Messages.commitPartDescr_exporting_db_model); // 2

    try {
        Collection<TreeElement> checked = new TreeFlattener()
                .onlySelected()
                .onlyEdits(dbProject.getDbObject(), dbRemote.getDbObject())
                .flatten(tree);
        new ProjectUpdater(dbRemote.getDbObject(), dbProject.getDbObject(),
                checked, proj).updatePartial();
        monitor.done();
    } catch (IOException | CoreException e) {
        return new Status(Status.ERROR, PLUGIN_ID.THIS,
                Messages.ProjectEditorDiffer_commit_error, e);
    }
    if (monitor.isCanceled()) {
        return Status.CANCEL_STATUS;
    }
    return Status.OK_STATUS;
}
 

@Override
protected IStatus run(IProgressMonitor monitor) {
    try {
        Log.log(Log.LOG_INFO, "Update DDL starting"); //$NON-NLS-1$
        SubMonitor.convert(monitor).setTaskName(Messages.SqlEditor_update_ddl);

        scriptThread.start();

        while(scriptThread.isAlive()) {
            Thread.sleep(20);
            if(monitor.isCanceled()) {
                ConsoleFactory.write(Messages.sqlScriptDialog_script_execution_interrupted);
                Log.log(Log.LOG_INFO, "Script execution interrupted by user"); //$NON-NLS-1$

                scriptThread.interrupt();
                return Status.CANCEL_STATUS;
            }
        }
        return Status.OK_STATUS;
    } catch (InterruptedException ex) {
        scriptThread.interrupt();
        return Status.CANCEL_STATUS;
    } finally {
        monitor.done();
    }
}
 

/**
 * Performs a {@link ProfileChangeOperation}
 * 
 * @param operation the operation
 * @return the result status
 */
private IStatus performOperation(ProfileChangeOperation operation) {
	IStatus status = operation.resolveModal(this.getProgressMonitor());
	if (status.isOK()) {
		ProvisioningJob provisioningJob = operation.getProvisioningJob(this.getProgressMonitor());

		if (provisioningJob == null) {
			System.err.println("Trying to install from the Eclipse IDE? This won't work!");
			return Status.CANCEL_STATUS;
		}

		status = provisioningJob.runModal(this.getProgressMonitor());
	}
	return status;
}
 

/**
 * Installs available updates from all repositories.
 *
 * @return the result status
 */
public IStatus installAvailableUpdates() {
	ProvisioningJob provisioningJob = this.getUpdateOperation().getProvisioningJob(this.getProgressMonitor());
	if (provisioningJob == null) {
		System.err.println("Trying to update from the Eclipse IDE? This won't work!");
		return Status.CANCEL_STATUS;
	}

	return provisioningJob.runModal(this.getProgressMonitor());
}
 

/**
 * Return the the preference values for the passed project and key
 * 
 * @param project
 * @param key
 * @return
 */
public static String[] getValues(IProject project, String key, boolean projectScoped) {

	IEclipsePreferences projectPreferences = null;
	if (projectScoped) {
		projectPreferences = getProjectPreference(project);
	} else {
		projectPreferences = getGlobalPreference();
	}
	String values = projectPreferences.get(key, "");
	if ((values == null) || (values.trim().length() == 0) && projectScoped) {
		IEclipsePreferences globalPreferences = getGlobalPreference();
		values = globalPreferences.get(key, "");
		final String gloablValues = values;

		Job job = new WorkspaceJob("GW4E Configure Project Preference Job") {
			@Override
			public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
				SubMonitor subMonitor = SubMonitor.convert(monitor, 60);
				try {
					putValues(project, key, fromString(gloablValues), projectScoped);
					return Status.OK_STATUS;
				} catch (Exception e) {
					ResourceManager.logException(e);
					return Status.CANCEL_STATUS;
				} finally {
					subMonitor.done();
				}
			}
		};
		job.setRule(project);
		job.setUser(true);
		job.schedule();
	}
	String[] ret = fromString(values);
	return ret;
}
 

/**
 * @param graphFile
 * @throws CoreException
 * @throws IOException
 * @throws InterruptedException
 */
public void update(List<BuildPolicy> policies) throws CoreException, IOException, InterruptedException {
	Job job = new WorkspaceJob("Updating cache") {
		public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
			try {
				IFile fileCache = getCache();
				Properties p = ResourceManager.loadIFileAsProperties(fileCache,
						getFileCacheName(resource.getProject().getName()));
				String serialized = serialize(policies);
				if (serialized == null) {
					log("BuildPoliciesCache.update " + fileCache + " failed to updated for resource " + resource
							+ " " + policies.toString());
					return Status.OK_STATUS;
				}
				p.put(resource.getName(), System.currentTimeMillis() + ":" + serialized);
				log("BuildPoliciesCache.update " + fileCache + " updated for resource " + resource + " "
						+ p.toString());
				save(p, monitor);
				return Status.OK_STATUS;
			} catch (Exception e) {
				ResourceManager.logException(e);
				return Status.CANCEL_STATUS;
			}
		}
	};
	job.setRule(resource.getProject());
	job.setUser(true);
	job.schedule();
}
 

@Override
protected IStatus run(IProgressMonitor monitor) {
    if (monitor.isCanceled()) {
        return Status.CANCEL_STATUS;
    }
    monitor.beginTask(Messages.UsageReport_Querying_Enablement, 2);

    if (monitor.isCanceled()) {
        return Status.CANCEL_STATUS;
    }
    monitor.worked(1);
    try {
        lockToAskUser.lock();

        if (mainPrefs.getBoolean(USAGE_REPORT_PREF.ASK_USER_USAGEREPORT_ID)) {
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            askUser();
        }
    } finally {
        lockToAskUser.unlock();
    }
    report();
    monitor.worked(2);
    monitor.done();

    return Status.OK_STATUS;
}
 

/**
 * Runs provided File in Engine. Returns output of execution.
 */
public void execute(ILaunch launch, XpectRunConfiguration runConfiguration) throws RuntimeException {

	Job job = new Job(launch.getLaunchConfiguration().getName()) {

		@Override
		protected IStatus run(IProgressMonitor monitor) {
			XpectRunner xr;
			try {
				xr = new XpectRunner(N4IDEXpectTestClass.class);
			} catch (InitializationError e) {
				N4IDEXpectUIPlugin.logError("cannot initialize xpect runner", e);
				return Status.CANCEL_STATUS;
			}

			// TODO support multiple selection
			/*
			 * if Project provided, or package files should be discovered there. Also multiple selected files
			 */
			String testFileLocation = runConfiguration.getXtFileToRun();

			IXpectURIProvider uriprov = xr.getUriProvider();
			if (uriprov instanceof N4IDEXpectTestURIProvider) {
				((N4IDEXpectTestURIProvider) uriprov).addTestFileLocation(testFileLocation);
			}

			Result result = new Result();
			RunNotifier notifier = new RunNotifier();
			RunListener listener = result.createListener();
			N4IDEXpectRunListener n4Listener = new N4IDEXpectRunListener();

			notifier.addFirstListener(listener);
			notifier.addListener(n4Listener);

			try {
				notifier.fireTestRunStarted(xr.getDescription());
				xr.run(notifier);
				notifier.fireTestRunFinished(result);
			} finally {
				notifier.removeListener(n4Listener);
				notifier.removeListener(listener);
			}
			// Do something with test run result?
			// return result;

			return Status.OK_STATUS;
		}

	};
	job.setUser(true);
	job.schedule();
}
 

private IStatus storeExcel ( final File file, final List<Event> events, final List<Field> columns, final IProgressMonitor monitor ) throws IOException
{
    final HSSFWorkbook workbook = new HSSFWorkbook ();

    final HSSFDataFormat dateFormat = workbook.createDataFormat ();
    final HSSFCellStyle dateCellStyle = workbook.createCellStyle ();
    dateCellStyle.setDataFormat ( dateFormat.getFormat ( "YYYY-MM-DD hh:mm:ss.000" ) );

    try
    {
        monitor.beginTask ( Messages.ExportImpl_Progress_ExportingEvents, events.size () + 3 + columns.size () );

        try
        {
            monitor.subTask ( Messages.ExportImpl_Progress_CreateWorkbook );
            monitor.worked ( 1 );

            final HSSFSheet sheet = createSheet ( events, workbook, columns );
            monitor.worked ( 1 );

            monitor.setTaskName ( Messages.ExportImpl_Progress_ExportEvents );

            for ( int i = 0; i < events.size (); i++ )
            {
                final HSSFRow row = sheet.createRow ( i + 1 );

                final Event e = events.get ( i );
                for ( int j = 0; j < columns.size (); j++ )
                {
                    final Field field = columns.get ( j );
                    final ExcelCell cell = new ExcelCell ( row, j, dateCellStyle );
                    field.render ( e, cell );
                }
                monitor.worked ( 1 );
                if ( monitor.isCanceled () )
                {
                    return Status.CANCEL_STATUS;
                }
            }

            sheet.setRepeatingRows ( new CellRangeAddress ( 0, 1, -1, -1 ) );

            monitor.setTaskName ( "Auto sizing" );
            for ( int i = 0; i < columns.size (); i++ )
            {
                monitor.subTask ( String.format ( "Auto sizing column: %s", columns.get ( i ).getHeader () ) );
                sheet.autoSizeColumn ( i );
                monitor.worked ( 1 );

                if ( monitor.isCanceled () )
                {
                    return Status.CANCEL_STATUS;
                }
            }

        }
        finally
        {
            monitor.subTask ( Messages.ExportImpl_Progress_CloseFile );
            if ( workbook != null )
            {
                makeDocInfo ( workbook );

                final FileOutputStream stream = new FileOutputStream ( file );
                workbook.write ( stream );
                stream.close ();
            }
            monitor.worked ( 1 );
        }
    }
    finally
    {
        monitor.done ();
    }

    return Status.OK_STATUS;
}
 

private void createCenteringListener(final Label centeringValue, final Map<String, ScaleBox> boxes) {

		// We listen to the topic and when a complete bean comes through, we take this
		// as the current center for the UI
		// Use job because connection might timeout.
		final Job topicJob = new Job("Create topic listener") {

			@Override
			protected IStatus run(IProgressMonitor monitor) {
				try {
					topicMonitor = service.createSubscriber(new URI(Activator.getJmsUri()), "dataacq.xcen.STATUS_TOPIC");
					topicMonitor.addListener(new IBeanListener<XcenBean>() {
						@Override
						public void beanChangePerformed(BeanEvent<XcenBean> evt) {
							final XcenBean bean = evt.getBean();
							if (bean.getStatus()==org.eclipse.scanning.api.event.status.Status.COMPLETE) {
								Display.getDefault().syncExec(new Runnable() {
									@Override
									public void run() {
										centeringValue.setText(bean.getName());
										boxes.get("x").setValue(bean.getX());
										boxes.get("y").setValue(bean.getY());
										boxes.get("z").setValue(bean.getZ());
									}
								});
							}
						}

						@Override
						public Class<XcenBean> getBeanClass() {
							return XcenBean.class;
						}
					});
			        return Status.OK_STATUS;

				} catch (Exception ne) {
					logger.error("Cannot listen to topic changes because command server is not there", ne);
			        return Status.CANCEL_STATUS;
				}
			}


		};

		topicJob.setPriority(Job.INTERACTIVE);
		topicJob.setSystem(true);
		topicJob.setUser(false);
		topicJob.schedule();

	}
 

/**
 * @param selectedResource
 * @return
 * @throws CoreException
 * @throws InterruptedException
 */
public static void synchronizeBuildPolicies(final IResource selectedResource, IWorkbenchWindow aww)
		throws CoreException, InterruptedException {
	List<ICompilationUnit> executionContexts = new ArrayList<ICompilationUnit>();

	Job job = new WorkspaceJob("GW4E Synchronization Job") {
		@Override
		public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
			try {
				SubMonitor subMonitor = SubMonitor.convert(monitor, 120);
				selectedResource.accept(new IResourceVisitor() {
					@Override
					public boolean visit(IResource resource) throws CoreException {
						if (resource instanceof IFile) {
							IFile file = (IFile) resource;
							if ("java".equals(file.getFileExtension())) {
								ICompilationUnit cu = JavaCore.createCompilationUnitFrom(file);
								if (cu != null) {
									if (JDTManager.isGraphWalkerExecutionContextClass(cu)) {
										executionContexts.add(cu);
									}
								}
							}
						}
						return true;
					}
				});
				subMonitor.split(20);

				int max = executionContexts.size();
				int index = 1;
				subMonitor.setWorkRemaining(max);
				for (ICompilationUnit executionContext : executionContexts) {
					if (monitor.isCanceled())
						return Status.CANCEL_STATUS;
					subMonitor.subTask("Processing file #" + index++);
					SubMonitor child = subMonitor.split(1);
					ResourceManager.updateBuildPolicyFileForCompilatioUnit(executionContext);
				}
			} catch (Exception e) {
				ResourceManager.logException(e);
			}
			return Status.OK_STATUS;
		}
	};
	job.setRule(selectedResource.getProject());
	job.setUser(true);
	job.schedule();
}
 

public void downloadDebugFiles(final boolean filterApplied,final boolean remoteOkPressed) {
	Job job = new Job(Messages.LOADING_DEBUG_FILE) {
		
		@Override
		protected IStatus run(IProgressMonitor monitor) {
			disbleDataViewerUIControls();
			
			DataViewerFileManager dataViewerFileManager = new DataViewerFileManager(jobDetails);
			final StatusMessage statusMessage = dataViewerFileManager.downloadDataViewerFiles(filterApplied,getConditions(),isOverWritten);


			if (StatusConstants.ERROR == statusMessage.getReturnCode()) {
				Display.getDefault().asyncExec(new Runnable() {
					
					@Override
					public void run() {
						Utils.INSTANCE.showDetailErrorMessage(statusMessage.getStatusMessage(), statusMessage.getErrorStatus());
						getShell().close();
					}
				});
				return Status.CANCEL_STATUS;
			}

			debugFileName = dataViewerFileManager.getDataViewerFileName();
			debugFileLocation = dataViewerFileManager.getDataViewerFilePath();
			downlodedFileSize = dataViewerFileManager.getDebugFileSize();
			setDebugFileLocation(debugFileLocation);
			setDebugFileName(debugFileName);
			setDownloadedFileSize(downlodedFileSize);
			if (getConditions() != null) {
				if (getConditions().getRetainLocal() || getConditions().getRetainRemote()) {
					showDataInDebugViewer(true,remoteOkPressed);
				}
				 else {
					if (!filterApplied) {
						showDataInDebugViewer(false, false);
					} else {
						showDataInDebugViewer(false, remoteOkPressed);
					}
				}
			}
			else
			{
				showDataInDebugViewer(false, remoteOkPressed);
			}
			dataViewerFileSchema = ViewDataSchemaHelper.INSTANCE.getFieldsFromSchema(debugFileLocation + debugFileName + SCHEMA_FILE_EXTENTION);
			
			if(dataViewerFileSchema != null){
				syncSchemaWithReceivedDataFile();
			}
			return Status.OK_STATUS;
		}
	};
	job.schedule();
}
 

/**
 * Returns with the {@link Status#CANCEL_STATUS CANCEL status} instance.
 *
 * @return the shared singleton CANCEL status.
 */
public IStatus cancel() {
	return Status.CANCEL_STATUS;
}