How to know when an Image finished updating it's source

public partial class Window1 : Window
{
	fastbitmap fastbm;//own made class
	WriteableBitmap bitmapBuffer;//WriteableBitmap
	volatile bool IsWorking = false;
	
	public Window1()
	{
		//load a new image
		fastbm = new fastbitmap("Some Image.jpg");
		//throw a working copy in the writeablebitmap
		bitmapBuffer = fastbm.toWriteableBitmap();
		
		Photo p = new Photo();//photo control contains an Image
		//Sets the Image.Source
		//right now the Source is bound with the writeablebitmap
		//this will cause the Image to update automatically after an update
		//of the writeablebitmap's back buffer
		System.Windows.Controls.Image i = p.SetPicture(ref writeablebm);
		//use high quality scaling
		RenderOptions.SetBitmapScalingMode(i, BitmapScalingMode.HighQuality);
		
		//finally: put the photo in a grid
		p.HorizontalAlignment = HorizontalAlignment.Center;
		p.VerticalAlignment = VerticalAlignment.Center;
		this.myGrid.Children.Add(p);
		
		
		//Also an event, which will be thrown up from a different thread
		Some.Event += new Some.Event(Someevent);
	}
	
	//the event will init a new update of the writeablebitmap
	void Someevent(object sender, Eventargs args)
	{
		//this event will be called ~30 times per second
		//make sure this isn't running already
		if(!IsWorking)
		{
			MyDelegate instance = new MyDelegate(UpdateBitmap);
			this.Dispatcher.Invoke(instance, null);
		}
	}
	
	delegate void MyDelegate();
	void UpdateBitmap()
	{
		IsWorking = true;
		//do some effects to the image etc.
		fastbm.dosomething();
		//write the new updated image to the backbuffer.
		//this is done via unsafe code, and the bitmapBuffer's 
		//back buffer will be locked at that time.
		fastbm.toWriteableBitmap(ref bitmapBuffer);
		//let other work happen again
		IsWorking = false;
	}
}

public WriteableBitmap toWriteableBitmap()
{
	WriteableBitmap bm = new WriteableBitmap(this.Width, this.Height, 300, 300, PixelFormats.Bgr24, null);
	unsafe
	{
		bm.Lock();
		int currentPixel = -1;
		byte* pStart = (byte*)(void*)bm.BackBuffer;
		
		Colour c;
		for (int y = 0; y < Height; y++)
		{
			for (int x = 0; x < Width; x++)
			{
				currentPixel++;
				c = bmdata[x][y];
                                //Note: B,G and R are bytes
				*(pStart + currentPixel * 3) = c.B;
				*(pStart + currentPixel * 3 + 1) = c.G;
				*(pStart + currentPixel * 3 + 2) = c.R;
			}
		}

		bm.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
		bm.Unlock();
	}
	return bm;
}

public void toWriteableBitmap(ref WriteableBitmap bm)
{
	if (bm == null)
	{
		bm = toWriteableBitmap();
		return;
	}
	if (bm.Format != PixelFormats.Bgr24)
		throw new Exception("Pixelformat should be Bgr24!");
	if (bm.PixelWidth!= this.Width || bm.PixelHeight != this.Height)
		throw new Exception("WriteableBitmap doesn't have the same size as fastbitmap");

	unsafe
	{
		bm.Lock();
		int currentPixel = -1;
		byte* pStart = (byte*)(void*)bm.BackBuffer;

		Colour c;
		for (int y = 0; y < Height; y++)
		{
			for (int x = 0; x < Width; x++)
			{
				currentPixel++;
				c = bmdata[x][y];
				*(pStart + currentPixel * 3) = c.B;
				*(pStart + currentPixel * 3 + 1) = c.G;
				*(pStart + currentPixel * 3 + 2) = c.R;
			}
		}

		bm.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
		bm.Unlock();
	}
}