How to stop a background thread when an image window is closed in dm-script - dm-script

Question

I'm trying to write a dm-script containing a background thread as following example code. In this code, I want to stop the background thread when the image window is closed. I think that some event-listener is probably required in this case. Could you advise me about how to control (i.e., stop) a background thread by closing event of an image window? If you could suggest some revision of my code or show your example code, I would be grateful for your cooperation.
// $BACKGROUND$
//
Class CBackground : Thread
{
Number isRunning
Number imgID
Image tmpIMG
//
Void Init( Object self, Number iID ){
imgID = iID
tmpIMG := GetImageFromID( imgID )
}
//
Void StopRunning( Object self ){
isRunning = 0
}
//
Number GetIsRunning( Object self ){
return isRunning
}
//
Void RunThread( Object self ){
Result("Background thread is starting ......")
isRunning = 1
while (isRunning)
{
tmpIMG = random()
sleep(0.5)
}
Result(" finished !!" + "\n")
}
}
//
Void Main(){
Object cbkg = alloc(CBackground)
Image IMG := RealImage("test",4,64,64)
IMG = random()
IMG.ShowImage()
IMG.SetWindowSize(512,512)
cbkg.Init(IMG.GetImageID())
cbkg.StartThread()
}
//
Main()

Answer 1

And here is an example of a script which uses a window-closed listener to abort the task.
Class CBackgroundWithListeners
{
Number isRunning
Number imgID
Image tmpIMG
Number winListenID
// Constructor and Destructor method for debugging reason
// Always automatically called when object gets created or removed from memory
CBackgroundWithListeners(object self) {
Result( "\n Creating object " + self.ScriptObjectGetClassName() )
Result( " with ID: " + self.ScriptObjectGetID() )
}
~CBackgroundWithListeners(object self) {
Result( "\n Destroying object " + self.ScriptObjectGetClassName() )
Result( " with ID: " + self.ScriptObjectGetID() )
}
// Init Method
Void Init( Object self, Number iID ){
imgID = iID
tmpIMG := GetImageFromID( imgID )
If ( !tmpIMG.ImageIsValid() )
Throw( "Image of ID " + imgID + " not found." )
if ( 0 == tmpIMG.ImageCountImageDisplays() )
Throw( "Image of ID " + imgID + " has no display." )
DocumentWindow win = tmpIMG.ImageGetOrCreateImageDocument().ImageDocumentGetWindow()
if ( !win.WindowIsValid() )
Throw( "Image of ID " + imgID + " has no window." )
winListenID = win.WindowAddWindowListener( self, "window_closed:HandleClosedAction;" )
}
//
Void StopRunning( Object self ){
isRunning = 0
}
//
Number GetIsRunning( Object self ){
return isRunning
}
//
Void HandleClosedAction(object self, number e_fl, DocumentWindow Win)
{
self.StopRunning()
win.WindowRemoveWindowListener( winListenID )
}
//
Void RunThread( Object self ){
Result("Background thread is starting ......")
isRunning = 1
while (isRunning)
{
tmpIMG = random()
sleep(0.5)
}
Result(" finished !!" + "\n")
}
}
//
Void Main(){
Object cbkg = alloc(CBackgroundWithListeners)
Image IMG := RealImage("test",4,64,64)
IMG = random()
IMG.ShowImage()
IMG.SetWindowSize(512,512)
cbkg.Init(IMG.GetImageID())
cbkg.StartThread()
}
//
Main()

Answer 2

You can not stop a background thread from outside that thread, i.e. you can not interrupt a thread. In order to stop a background thread, the according code needs to have a stop-condition and exit itself.
In order to steer this stop-condition from another thread, you need to "communicate" somehow between two threads. This can be done in many different ways. The easiest is to use a simple number variable which is checked by the background running code but can be set via any other "outside" code. An example for this can be found in this answer here.
Instead of a simple variable, one could also use some commonly accessible place like f.e. the global tags. Alternatively, some more sophistacted threading synchronisation objects like signals, mutexes and semphores are defined for the scripting language and describe in the help documentation here:
How an external thread inserts the 'break' into the background running thread can also be done in many different ways. One is - as in the exampe above - have a user interaction via some open dialog. Another, as mentioned by the author, is to have some event-listener code to trigger this.
The following example attaches a key-listener to the image, so that (with this image frontmost and selected) a user can press the ESC button to stop the thread.
I am using the provided script with minimum modifications for showing this:
// $BACKGROUND$
//
Class CBackground : Thread
{
Number isRunning
Number imgID
Number keyListenID
Image tmpIMG
//
Void Init( Object self, Number iID ){
imgID = iID
tmpIMG := GetImageFromID( imgID )
ImageDisplay disp = tmpIMG.ImageGetImageDisplay(0)
keyListenID = disp.ImageDisplayAddKeyHandler( self, "KeyListenAction" )
}
//
Void StopRunning( Object self ){
isRunning = 0
}
//
Number GetIsRunning( Object self ){
return isRunning
}
/////////////////////////////////////////////////////////////////////////////
Number KeyListenAction(Object self, ImageDisplay disp, Object keydesc )
{
number b_keyhandled = 0
If ( keydesc.MatchesKeyDescriptor("esc") )
{
disp.ImageDisplayRemoveKeyHandler( keyListenID )
self.StopRunning()
Result( "\nSend stopping flag, unregister Key-Listeners" )
b_keyhandled = 1
}
return b_keyhandled;
}
//
Void RunThread( Object self ){
Result("Background thread is starting ......")
isRunning = 1
while (isRunning)
{
tmpIMG = random()
sleep(0.5)
}
Result(" finished !!" + "\n")
}
}
//
Void Main(){
Object cbkg = alloc(CBackground)
Image IMG := RealImage("test",4,64,64)
IMG = random()
IMG.ShowImage()
IMG.SetWindowSize(512,512)
cbkg.Init(IMG.GetImageID())
cbkg.StartThread()
}
//
Main()
However, there are a few things I would do differently:
Start the background thread with the proper command rather then the old '$$BACKGROUND$$' method.
Encapsulate as much as possible into the class
Add a few security checkes
Also add a windows closed event listener, so that closing the image window also stops the thread
Add some debug-code to show when an object is created and when it is removed from memory
Have the keylistener to pause/unpause the action.