Java Cancellable类代码示例

import org.openide.util.Cancellable; //导入依赖的package包/类
public void searchStarted() {

        progressHandle = ProgressHandleFactory.createHandle(
                NbBundle.getMessage(ResultView.class,
                "TEXT_SEARCHING___"), new Cancellable() {               //NOI18N

            @Override
            public boolean cancel() {
                searchComposition.terminate();
                return true;
            }
        });
        progressHandle.start();
        resultViewPanel.searchStarted();
        searchComposition.getSearchResultsDisplayer().searchStarted();
        Collection<? extends Savable> unsaved =
                Savable.REGISTRY.lookupAll(Savable.class);
        if (unsaved.size() > 0) {
            String msg = NbBundle.getMessage(ResultView.class,
                    "TEXT_INFO_WARNING_UNSAVED");
            eventChildren.addEvent(new EventNode(EventType.WARNING, msg));
        }
    }
 

import org.openide.util.Cancellable; //导入依赖的package包/类
private void cleanup(final List<InputReaderTask> tasks, final ExecutorService processingExecutor) {
    boolean interrupted = false;
    if (processingExecutor != null) {
        try {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    processingExecutor.shutdown();
                    return null;
                }
            });
            for (Cancellable cancellable : tasks) {
                cancellable.cancel();
            }
            while (!processingExecutor.awaitTermination(EXECUTOR_SHUTDOWN_SLICE, TimeUnit.MILLISECONDS)) {
                LOGGER.log(Level.INFO, "Awaiting processing finish");
            }
        } catch (InterruptedException ex) {
            interrupted = true;
        }
    }

    if (interrupted) {
        Thread.currentThread().interrupt();
    }
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
private void showDetailsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_showDetailsActionPerformed
     Container c = this;
     while (!(c instanceof ParametersPanel)) {
         c = c.getParent();
     }
     final ParametersPanel parametersPanel = (ParametersPanel) c;
     Cancellable doCloseParent = new Cancellable() {
        @Override
         public boolean cancel() {
             parametersPanel.cancel.doClick();
             return true;
         }
     };
     ProblemDetails details = problem.getDetails();
     if (details != null) {
         details.showDetails(new CallbackAction(ui), doCloseParent);
     }
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
private ProgressHandle createProgressHandle(InputOutput inputOutput,
        String displayName, Cancellable cancellable) {

    if (!descriptor.showProgress() && !descriptor.showSuspended()) {
        return null;
    }

    ProgressHandle handle = ProgressHandleFactory.createHandle(displayName,
            cancellable, new ProgressAction(inputOutput));

    handle.setInitialDelay(0);
    handle.start();
    handle.switchToIndeterminate();

    if (descriptor.showSuspended()) {
        handle.suspend(NbBundle.getMessage(ExecutionService.class, "Running"));
    }

    return handle;
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
/**
 * Check that if a Swing component is extracted, the progress
 * reports 'customPlaced' = true.
 * @throws Exception 
 */
public void testHandleIsCustomPlaced() throws Exception {
    C c = new C();
    A a = new A();
    Constructor ctor = InternalHandle.class.getConstructor(
            String.class,
            Cancellable.class,
            Boolean.TYPE,
            Action.class
        );
    InternalHandle h = (InternalHandle)ctor.newInstance("Foobar", c, true, a);
    ProgressHandle p = h.createProgressHandle();
    
    Method m = InternalHandle.class.getMethod("extractComponent");
    JComponent comp = (JComponent)m.invoke(h);
    
    assertTrue(h.isCustomPlaced());
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
static void refreshSilentUpdateProvider() {
    UpdateUnitProvider silentUpdateProvider = getSilentUpdateProvider();
    if (silentUpdateProvider == null) {
        // have a problem => cannot continue
        WakaTime.info("Missing Silent Update Provider => cannot continue.");
        return ;
    }
    try {
        final String displayName = "Checking for updates to WakaTime plugin...";
        silentUpdateProvider.refresh(
            ProgressHandleFactory.createHandle(
                displayName,
                new Cancellable () {
                    @Override
                    public boolean cancel () {
                        return true;
                    }
                }
            ),
            true
        );
    } catch (IOException ex) {
        // caught a exception
        WakaTime.error("A problem caught while refreshing Update Centers, cause: " + ex.toString());
    }
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
ScaleToolWorker() throws Exception {
   updateScaleTool();
 
   progressHandle = ProgressHandleFactory.createHandle("Executing scaling...",
                        new Cancellable() {
                           public boolean cancel() {
                              result = false;
                              finished();
                              return true;
                           }
                        });
   progressHandle.start();
   // Crash here
   processedModel = new Model(unscaledModel);
   processedModel.setName(scaleTool.getName());
   processedModel.setInputFileName("");
   processedModel.setOriginalModelPathFromModel(unscaledModel); // important to keep track of the original path so bone loading works
   //processedModel.setup();

   setExecuting(true);
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
@NbBundle.Messages({
    "TXT_JavadocSearch=Searching Javadoc in {0}"
})
private static Collection<? extends URL> findRoot(final File file, final int type) throws MalformedURLException {
    if (type != CLASSPATH) {                
        final FileObject fo = URLMapper.findFileObject(FileUtil.urlForArchiveOrDir(file));
        if (fo != null) {
            final Collection<FileObject> result = Collections.synchronizedCollection(new ArrayList<FileObject>());
            if (type == SOURCES) {
                final FileObject root = JavadocAndSourceRootDetection.findSourceRoot(fo);
                if (root != null) {
                    result.add(root);
                }
            } else if (type == JAVADOC) {
                final AtomicBoolean cancel = new AtomicBoolean();
                class Task implements ProgressRunnable<Void>, Cancellable {
                    @Override
                    public Void run(ProgressHandle handle) {
                        result.addAll(JavadocAndSourceRootDetection.findJavadocRoots(fo, cancel));
                        return null;
                    }

                    @Override
                    public boolean cancel() {
                        cancel.set(true);
                        return true;
                    }
                }
                final ProgressRunnable<Void> task = new Task();
                ProgressUtils.showProgressDialogAndRun(task, Bundle.TXT_JavadocSearch(file.getAbsolutePath()), false);
            }
            if (!result.isEmpty()) {
                return result.stream()
                        .map(FileObject::toURL)
                        .collect(Collectors.toList());
            }                    
        }
    }
    return Collections.singleton(Utilities.toURI(file).toURL());
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
private boolean waitStart(final ExecSupport execSupport, int waitTime) {
    boolean started = false;
    final Holder<Boolean> forceExit = new Holder<>(false);
    String waitMessage = NbBundle.getMessage(RegisterDerby.class, "MSG_StartingDerby");
    ProgressHandle progress = ProgressHandleFactory.createHandle(waitMessage, new Cancellable() {
        @Override
        public boolean cancel() {
            forceExit.value = true;
            return execSupport.interruptWaiting();
        }
    });
    progress.start();
    try {
        while (!started) {
            started = execSupport.waitForMessage(waitTime * 1000);
            if (!started) {
                if (waitTime > 0 && (!forceExit.value)) {
                    String title = NbBundle.getMessage(RegisterDerby.class, "LBL_DerbyDatabase");
                    String message = NbBundle.getMessage(RegisterDerby.class, "MSG_WaitStart", waitTime);
                    NotifyDescriptor waitConfirmation = new NotifyDescriptor.Confirmation(message, title, NotifyDescriptor.YES_NO_OPTION);
                    if (DialogDisplayer.getDefault().notify(waitConfirmation)
                            != NotifyDescriptor.YES_OPTION) {
                        break;
                    }
                } else {
                    break;
                }
            }
        }
        if (!started) {
            execSupport.terminate();
            LOGGER.log(Level.WARNING, "Derby server failed to start"); // NOI18N
        }
    } finally {
        progress.finish();
    }
    return started;
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
@Override
public ProgressHandle createHandle(String displayname, Cancellable c, boolean userInit) {
    if (userInit) {
        return ProgressHandleFactory.createHandle(displayname, c, null);
    } else {
        return ProgressHandleFactory.createSystemHandle(displayname, c, null);
    }
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
public void run() {
    ProgressHandle ph = ProgressHandleFactory.createHandle(
            NbBundle.getMessage(RetrieverEngineImpl.class,"LBL_PROGRESSBAR_Retrieve_XML"),
            new Cancellable(){
        public boolean cancel() {
            synchronized(RetrieverEngineImpl.this){
                if(!RetrieverEngineImpl.this.STOP_PULL){
                    RetrieverEngineImpl.this.STOP_PULL = true;
                    //taskThread.interrupt();
                }
            }
            return true;
        }
    }, new AbstractAction(){
        public void actionPerformed(ActionEvent e) {
            getOPWindow().setOutputVisible(true);
            getOPWindow().select();
        }
    });
    ph.start();
    ph.switchToIndeterminate();
    try{
        pullRecursively();
    }finally{
        ph.finish();
    }
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
public UIInternalHandle(String displayName, 
               Cancellable cancel,
               boolean userInitiated,
               Action view) {
    super(displayName, cancel, userInitiated);
    viewAction = view;
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    Controller.defaultInstance = new TestController();
    proghandle = ProgressHandleFactory.createHandle("displayName",new Cancellable() {
        public boolean cancel() {
            // empty
            return true;
        }
    });
    handle = (UIInternalHandle)proghandle.getInternalHandle();
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
private PropertyChangeListener createChangeListener() {
    return new PropertyChangeListener() {
        @Override
        public void propertyChange( PropertyChangeEvent e ) {
            synchronized( TaskListTopComponent.this ) {
                if( ((Boolean)e.getNewValue()).booleanValue() ) {
                    if( null == progress ) {
                        progress = ProgressHandleFactory.createHandle(
                                NbBundle.getMessage( TaskListTopComponent.class, "LBL_ScanProgress" ), //NOI18N
                                new Cancellable() { //NOI18N
                                    @Override
                                    public boolean cancel() {
                                        taskManager.abort();
                                        return true;
                                    }
                                });
                        progress.start();
                        progress.switchToIndeterminate();
                    }
                } else {
                    if( null != progress )
                        progress.finish();
                    progress = null;
                }
            }
        }
    };
}
 

import org.openide.util.Cancellable; //导入依赖的package包/类
public static void process(Lookup context, HintsSettings hintsSettings) {
    final AtomicBoolean abCancel = new AtomicBoolean();
    class Cancel implements Cancellable {
        public boolean cancel() {
            abCancel.set(true);
            return true;
        }
    }
    
    ProgressHandle h = ProgressHandleFactory.createHandle(NbBundle.getMessage(Analyzer.class, "LBL_AnalyzingJavadoc"), new Cancel()); // NOI18N

    RP.post(new Analyzer(context, abCancel, h, hintsSettings));
}