That means you can't just rely on MainLoop magically stepping aside to check on your other threads, nor can you fiddle with Tk's structures from an external thread. You'll need to add a repeat timer event before calling MainLoop, and use queues to pass commands/data back and forth.

Here's some (untested) code snippets to get you going.

#!/usr/bin/perl -w  
use threads;
use Thread::Queue;
use Tk;
use strict;

my $cmdq = Thread::Queue->new();
my $respq = Thread::Queue->new();

my $thrd = threads->create(\&image_loader);

my $mw = MainWindow->new;

# ...the usual widget building here...

my $repeat_id = $mw->repeat($interval, \&image_handler);

$cmdq->enqueue('GO');

MainLoop;


sub image_handler { 
    return unless $respq->pending;
    
    my $buffer = $respq->dequeue();
    ...load into your frame here...
    $cmdq->enqueue('GO');
}
#
#    assumes your image loader persists
#
sub image_loader {
    while (1) {
        my $go = $cmdq->dequeue();
        last 
            if ($go eq 'STOP');
        ...do your image loading business here...
        $respq->enqueue($imagebuffers);
    }
}
[download]

OK thanks a lot guys.

So I need to use active waiting (timer). I was hoping for a passive waiting method (get a signal or sth) but this seems OK. I'll do as you advise. Thank you once again.

So the basic idea is to make your threads, before you invoke any Tk code, see PerlTk on a thread... for other precautions. Then setup your Tk gui. Then use shared variables to signal back and forth between the Tk in the main thread and the worker thread(s). To detect when a thread is done processing an image, have a shared var called for instance "$done", and have a timer in the main Tk thread, check $done every 10 ms. When $done == 1; transfer the image thru another shared var into the Tk main thread. Since Tk likes it's images to be base64encoded anyways, have the thread base64encode the image, before it puts it into the output shared var. See also Tk-with-worker-threads for an example of making reusable threads that sleep when not used. This technique prevents any increase in memory caused by continually creating and destroying threads.( You cannot create/destroy threads with Tk anyways, since Tk is not thread-safe, and you need to create ALL threads before any Tk code is invoked in the main thread).