package bluej.utility;

import javafx.application.Platform;

import threadchecker.OnThread;
import threadchecker.Tag;




| This is a copy from the SwingWorker, which is an abstract class
| that you subclass to perform GUI-related work in a dedicated thread.
|
public abstract class FXWorker
{       
private Object value;  

   
   

| Class to maintain reference to current worker thread
| under separate synchronization control.
|
private static class ThreadVar
{              
private Thread thread;
       
      ThreadVar(Thread t) { thread = t; 
         }
       
      synchronized Thread get() { return thread; 
         }
       
      synchronized void clear()
{
thread = null; 
         }     
      }

   
   private ThreadVar threadVar;

   
   


| Start a thread that will call the <code>construct</code> method
| and then exit.
|
public FXWorker()
   {        
      Runnable doConstruct = new Runnable() {            
         @Override
         @OnThread(value = Tag.Worker, ignoreParent = true)
           
         public void run()
           {                
            try {
            setValue(construct());                 
            }
               
         finally {
         threadVar.clear();                 
         }

      Platform.runLater(() -> finished());             
      }         
   };
Thread t = new Thread(doConstruct);
       
threadVar = new ThreadVar(t);     
}

   



| Get the value produced by the worker thread, or null if it
| hasn't been constructed yet.
|
protected synchronized Object getValue()
   {        
   return value;     
   }

   



| Set the value produced by worker thread
|
private synchronized void setValue(Object x)
   {        
   value = x;     
   }

   



| Compute the value to be returned by the <code>get</code> method.
|
@OnThread(Tag.Worker)
   
public abstract Object construct();

   



| Called on the event dispatching thread (not on the worker thread)
| after the <code>construct</code> method has returned.
|
@OnThread(Tag.FXPlatform)
   
public void finished()
{ 
}

   



| A new method that interrupts the worker thread.  Call this method
| to force the worker to stop what it's doing.
|
public void interrupt()
   {
   Thread t = threadVar.get();
   if (t != null) {
      t.interrupt();         
      }
   threadVar.clear();     
   }

   



| Return the value created by the <code>construct</code> method.
| Returns null if either the constructing thread or the current
| thread was interrupted before a value was produced.
|
| @return the value created by the <code>construct</code> method
|
public Object get()
   {
   while (true){
      Thread t = threadVar.get();
      if (t == null) {
         return getValue();             
         }
           
      try {
      t.join();             
      }
           
   catch (InterruptedException e) {
      Thread.currentThread().interrupt(); 
      return null;             
      }         
   }     
}

   



| Start the worker thread.
|
public void start()
   {
   Thread t = threadVar.get();
   if (t != null) {
      t.start();         
      }     
   }

@OnThread(Tag.FXPlatform)
   
public abstract void abort(); 
}