How to know when a control (or window) has been rendered (drawn) in WPF?

Question

I need to store the content of a Window into an image, save it and close the window. If I close the window on the Loaded event the image contains the Window with some items are drawn ok, some others are only half drawn or distorted while others are not on the image.

If I put a timer and close the window after a certain amount of time (something between 250ms and 1sec depending on the complexity of the window) the images are all ok.

Looks like the window needs some time to completely render itself. Is there a way to know when this rendering has been done to avoid using a Timer and closing the window when we know it has completed its rendering?

Thanks.

Conversion

How do you capture the window's image? – Phenocryst

With the RenderTargetBitmap class. – Conversion

Answer 1

I think you are looking for the ContentRendered event

Pelias

This only appears to work for when a Window is first rendered (not updates to controls on it) – Strew

Answer 2

I had the similar problem in the application I am working, I solved it by using following code, try it and let me know if it helps.

 using (new HwndSource(new HwndSourceParameters())
                   {
                       RootVisual =
                           (VisualTreeHelper.GetParent(objToBeRendered) == null
                                ? objToBeRendered
                                : null)
                   })
        {
            // Flush the dispatcher queue
            objToBeRendered.Dispatcher.Invoke(DispatcherPriority.SystemIdle, new Action(() => { }));

            var renderBitmap = new RenderTargetBitmap(requiredWidth, requiredHeight,
                                                      96d*requiredWidth/actualWidth, 96d*requiredHeight/actualHeight,
                                                      PixelFormats.Default);

            renderBitmap.Render(objToBeRendered);
            renderBitmap.Freeze();                

            return renderBitmap;
        }

Stableman

Uf. Looks like everyone has its own solution to the problem and there aren't two that looks the same. I'll take a look but why are you instantiating a HwndSource that is not used anywhere? – Conversion

It forces the parent window to wait till the children gets rendered. This works well for me...!!! – Stableman

I'll try, anyway the ContentRendered event looks the simplest way to me. – Conversion

Ok, if you are able to achieve it, please post it here, we will get know a solution which might be better than the one I had implemented. – Stableman

Answer 3

I used the method on SizeChanged.

public partial class MyUserControl: UserControl
{

    public MyUserControl()
    {
        InitializeComponent();
        SizeChanged += UserControl_DoOnce; //register
    }

    private void UserControl_DoOnce(object sender, SizeChangedEventArgs e)
    {
        if (ActualHeight > 0)//Once the object has size, it has been rendered.
        {
              SizeChanged -= UserControl_DoOnce; //Unregister so only done once
        }
    }
}

This is the only method that I found to work reliably from the control without referencing the Window.

Opposition

what if you update the control and want to know if the update has been rendered? – Strew

Answer 4

I know this is an old question but this might help a frustrated searcher (like I often am)

What worked for me is DispatcherTimer and Yield so it waits and gives the Render thread time to do the actual screen updates. In the debugger you can put a breakpoint at 'await longOperation()' and see the label has already been updated.

// update label you want user to see before longOperation starts
await UIFinishRender();
await longOperation();

public async Task UIFinishRender()
{
    // want to wait for render thread finish drawing
    RenderCount = 0;    // private int

    DispatcherTimer timer = new DispatcherTimer();
    timer.Interval = TimeSpan.FromMilliseconds(1);
    timer.Tick += timer_Tick;
    timer.Start();

    while (RenderCount < 30)
    {
        await Dispatcher.Yield();
    }
}

void timer_Tick(object sender, EventArgs e)
{
    RenderCount++;
}

Strew

How do you know how much time needs the screen to update? That's dependent on the context, the hardware, the complexity of the controls ... 30 seems an arbitrary number – Conversion

Yes, 30 is a an arbitrary number but as I cannot access the render thread to know that a control update has been rendered, it's all I've got. One could use settings to use different numbers based on view model, hardware etc. – Strew

I understand that the problem is complex but that does not mean this is a valid solution. This cannot be applied to an application that has to be distributed to customers. – Conversion

@Ignacio I'm open to better solutions, have you found a way to access the render thread to verify that something has been drawn? – Strew

The accepted answer about ContentRendered event is useful in certain scenarios – Conversion

Do not take it personally but this solution does not work, it depends on the workload of the CPU so customers cannot be adjusting one setting on the fly. Things that work with time are 99.99% of the time a bad idea. – Conversion

@Ignacio I don't take it personally but in the absence of a better solution I'm forced to stick with what I've got. – Strew

sometimes it is better to say that something cannot be done than to provide something that will not work. Again, 30 milliseconds will work only on your machine on certain workloads but not on others, so it is not a valid solution I'm afraid. – Conversion

@Ignacio - when you work for someone else and claim to be a software developer saying that drawing some text on the screen 'cannot be done' is not an option. – Strew