DFL background tasks

[Scroph via Digitalmars-d-learn]

Briliant, thanks a lot ! Looks like I misunderstood Adam's reply, 
sorry about that !

I tried different things but I didn't think of calling invoke 
from within the worker thread, that solved the freezing problem. 
I ended up using the Thread class; spawn complained about the 
mutability of the given arguments. I realize what I did may be an 
ugly solution for the problem at hand, so I'll try to modify the 
code in order to avoid giving the thread UI elements altogether, 
thus being able to take advantage of more.. modern techniques 
like std.concurrency.

I'm using the Timer trick on another part of the project. Right 
now I'm running instances of a "Downloader" class in the 
background, a class that extends Thread and provides some useful 
functionality : a way to track the progress, to set rate limits, 
to abort the download, etc. It seems to be working fine, I'm 
using the (incomplete) program to download Visual Studio as we 
speak.

I set up a timer to periodically retrieve the progress of a 
download from the instances then update the ListView accordingly. 
Right now I'm hesitating between continuing with this approach vs 
using std.concurrency or even std.parallelism since the downloads 
are supposed to run in parallel without communicating with one 
another, but the only way I see would be to place the message 
handling code inside a loop, which for some reason doesn't sit 
right with me. I'm still learning concurrency (courtesy of Ali 
Çehreli and his book), so maybe my doubts are unfounded. Here's 
what I'll probably end up using, minus the error handling :

void dlWorker(HTTP client, string local, string remote, bool 
resume = true)
{
	auto fh = File(local, resume ? "a" : "w");
	scope(exit)
		fh.close;
	size_t size;
	size_t progress;
	client.onProgress = (size_t dlTotal, size_t dlNow, size_t 
ulTotal, size_t ulNow) {
		size = dlTotal;
		progress = dlNow;
	};
	client.onReceive = (ubyte[] data) {
		fh.rawWrite(data);
		return data.length;
	};	
	client.perform;
	while(!client.isStopped)
	{
		auto msg = receiveOnly!(MsgType, int)();
		switch(msg[0])
		{
			case MsgType.progress: send(ownerTid, progress); break;
			case MsgType.size: send(ownerTid, size); break;
			case MsgType.abort:
				client.shutdown;
				send(ownerTid, 1);
			break;
			default:
				client.handle.set(CurlOption.recv_rate_speed_large, msg[1]);
				send(ownerTid, 1);
			break;
		}
	}
}

enum MsgType
{
	progress, size, abort, limit;
}

Though I'm not entirely sure how I would tie the ListView rows to 
their respective workers. But I'll cross that bridge when I get 
to it.

Again, thanks for all the help. You guys are definitely going to 
be mentioned in the "About" section of the finished product.