Tuesday, April 10, 2012

Is there a way to make drawRect work right NOW?

The original question...............................................

If you are an advanced user of drawRect on your ipop*, you will know that of course drawRect will not actually run until "all processing is finished." setNeedsDisplay flags a view as invalidated and the OS, in a word, waits until all processing is done. This can be infuriating in the common situation where you want to have:

  • a view controller 1

  • starts some function 2

  • which incrementally 3

    • creates a more and more complicated artwork and 4

    • at each step, you setNeedsDisplay (wrong!) 5

  • until all the work is done 6

Of course, when you do that, all that happens is that drawRect is run once only after step 6. What you want is for the ^&£@%$@ view to be refreshed at point 5. This can lead to you smashing your ipops on the floor, scanning Stackoverflow for hours, screaming at the kids more than necessary about the dangers of crossing the street, etc etc. What to do?


* ipop: i Pad Or Phone !

Solution to the original question..............................................

In a word, you can (A) background the large painting, and call to the foreground for UI updates or (B) arguably controversially there are four 'immediate' methods suggested that do not use a background process. For the result of what works, run the demo program. It has #defines for all five methods.

Truly astounding alternate solution introduced by Tom Swift..................

Tom Swift has explained the amazing idea of quite simply manipulating the run loop . Here's how you trigger the run loop:

[[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: [NSDate date]];

This is a truly amazing piece of engineering. Of course one should be extremely careful when manipulating the run loop and as many pointed out this approach is strictly for experts.

The Bizarre Problem That Arises..............................................

Even though a number of the methods work, they don't actually "work" because there is a bizarre progressive-slow-down artifact you will see clearly in the demo.

Scroll to the 'answer' I pasted in below, showing the console output - you can see how it progressively slows.

Here's the new SO question:

Mysterious "progressive slowing" problem in run loop / drawRect.

Here is V2 of the demo app...


You will see it tests all five methods,

[self setNeedsDisplay];
[[NSRunLoop currentRunLoop]
runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]];
#ifdef HOTPAW
[self setNeedsDisplay];
[CATransaction flush];
[CATransaction begin];
[self setNeedsDisplay];
[CATransaction commit];
#ifdef DDLONG
[self setNeedsDisplay];
[[self layer] displayIfNeeded];
// here, the painting is being done in the bg, we have been
// called here in the foreground to inval
[self setNeedsDisplay];

  • You can see for yourself which methods work and which do not.

  • you can see the bizarre "progressive-slow-down". why does it happen?

  • you can see with the controversial TOMSWIFT method, there is actually no problem at all with responsiveness. tap for response at any time. (but still the bizarre "progressive-slow-down" problem)

So the overwhelming thing is this weird "progressive-slow-down": on each iteration, for unknown reasons, the time taken for a loop deceases. Note that this applies to both doing it "properly" (background look) or using one of the 'immediate' methods.

Practical solutions ........................

For anyone reading in the future, if you are actually unable to get this to work in production code because of the "mystery progressive slowdown" ... Felz and Void have each presented astounding solutions in the other specific question, hope it helps.

Source: Tips4all


  1. Updates to the user interface happen at the end of the current pass through the run loop. These updates are performed on the main thread, so anything that runs for a long time in the main thread (lengthy calculations, etc.) will prevent the interface updates from being started. Additionally, anything that runs for a while on the main thread will also cause your touch handling to be unresponsive.

    This means that there is no way to "force" a UI refresh to occur from some other point in a process running on the main thread. The previous statement is not entirely correct, as Tom's answer shows. You can allow the run loop to come to completion in the middle of operations performed on the main thread. However, this still may reduce the responsiveness of your application.

    In general, it is recommended that you move anything that takes a while to perform to a background thread so that the user interface can remain responsive. However, any updates you wish to perform to the UI need to be done back on the main thread.

    Perhaps the easiest way to do this under Snow Leopard and iOS 4.0+ is to use blocks, like in the following rudimentary sample:

    dispatch_queue_t main_queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
    // Do some work
    dispatch_async(main_queue, ^{
    // Update the UI

    The Do some work part of the above could be a lengthy calculation, or an operation that loops over multiple values. In this example, the UI is only updated at the end of the operation, but if you wanted continuous progress tracking in your UI, you could place the dispatch to the main queue where ever you needed a UI update to be performed.

    For older OS versions, you can break off a background thread manually or through an NSOperation. For manual background threading, you can use

    [NSThread detachNewThreadSelector:@selector(doWork) toTarget:self withObject:nil];


    [self performSelectorInBackground:@selector(doWork) withObject:nil];

    and then to update the UI you can use

    [self performSelectorOnMainThread:@selector(updateProgress) withObject:nil waitUntilDone:NO];

    Note that I've found the NO argument in the previous method to be needed to get constant UI updates while dealing with a continuous progress bar.

    This sample application I created for my class illustrates how to use both NSOperations and queues for performing background work and then updating the UI when done. Also, my Molecules application uses background threads for processing new structures, with a status bar that is updated as this progresses. You can download the source code to see how I achieved this.

  2. If I understand your question correctly, there is a simple solution to this. During your long-running routine you need to tell the current runloop to process for a single iteration (or more, of the runloop) at certain points in your own processing. e.g, when you want to update the display. Any views with dirty update regions will have their drawRect: methods called when you run the runloop.

    To tell the current runloop to process for one iteration (and then return to you...):

    [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: [NSDate date]];

    Here's an example of an (inefficient) long running routine with a corresponding drawRect - each in the context of a custom UIView:

    - (void) longRunningRoutine:(id)sender
    srand( time( NULL ) );

    CGFloat x = 0;
    CGFloat y = 0;

    [_path moveToPoint: CGPointMake(0, 0)];

    for ( int j = 0 ; j < 1000 ; j++ )
    x = 0;
    y = (CGFloat)(rand() % (int)self.bounds.size.height);

    [_path addLineToPoint: CGPointMake( x, y)];

    y = 0;
    x = (CGFloat)(rand() % (int)self.bounds.size.width);

    [_path addLineToPoint: CGPointMake( x, y)];

    x = self.bounds.size.width;
    y = (CGFloat)(rand() % (int)self.bounds.size.height);

    [_path addLineToPoint: CGPointMake( x, y)];

    y = self.bounds.size.height;
    x = (CGFloat)(rand() % (int)self.bounds.size.width);

    [_path addLineToPoint: CGPointMake( x, y)];

    [self setNeedsDisplay];
    [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode beforeDate: [NSDate date]];

    [_path removeAllPoints];

    - (void) drawRect:(CGRect)rect
    CGContextRef ctx = UIGraphicsGetCurrentContext();

    CGContextSetFillColorWithColor( ctx, [UIColor blueColor].CGColor );

    CGContextFillRect( ctx, rect);

    CGContextSetStrokeColorWithColor( ctx, [UIColor whiteColor].CGColor );

    [_path stroke];

    And here is a fully working sample demonstrating this technique.

    With some tweaking you can probably adjust this to make the rest of the UI (i.e. user-input) responsive as well.

    Update (caveat for using this technique)

    I just want to say that I agree with much of the feedback from others here saying this solution (calling runMode: to force a call to drawRect:) isn't necessarily a great idea. I've answered this question with what I feel is a factual "here's how" answer to the stated question, and I am not intending to promote this as "correct" architecture. Also, I'm not saying there might not be other (better?) ways to achieve the same effect - certainly there may be other approaches that I wasn't aware of.

    Update (response to the Joe's sample code and performance question)

    The performance slowdown you're seeing is the overhead of running the runloop on each iteration of your drawing code, which includes rendering the layer to the screen as well as all of the other processing the runloop does such as input gathering and processing.

    One option might be to invoke the runloop less frequently.

    Another option might be to optimize your drawing code. As it stands (and I don't know if this is your actual app, or just your sample...) there are a handful of things you could do to make it faster. The first thing I would do is move all the UIGraphicsGet/Save/Restore code outside the loop.

    From an architectural standpoint however, I would highly recommend considering some of the other approaches mentioned here. I see no reason why you can't structure your drawing to happen on a background thread (algorithm unchanged), and use a timer or other mechanism to signal the main thread to update it's UI on some frequency until the drawing is complete. I think most of the folks who've participated in the discussion would agree that this would be the "correct" approach.

  3. In order to get drawRect called the soonest (which is not necessarily immediately, as the OS may still wait until, for instance, the next hardware display refresh, etc.), an app should idle it's UI run loop as soon as possible, by exiting any and all methods in the UI thread, and for a non-zero amount of time.

    You can either do this in the main thread by chopping any processing that takes more than an animation frame time into shorter chunks and scheduling continuing work only after a short delay (so drawRect might run in the gaps), or by doing the processing in a background thread, with a periodic call to performSelectorOnMainThread to do a setNeedsDisplay at some reasonable animation frame rate.

    A non-OpenGL method to update the display near immediately (which means at the very next hardware display refresh or three) is by swapping visible CALayer contents with an image or CGBitmap that you have drawn into. An app can do Quartz drawing into a Core Graphics bitmap at pretty much at any time.

    New added answer:

    Please see Brad Larson's comments below and Christopher Lloyd's comment on another answer here as the hint leading towards this solution.

    [ CATransaction flush ];

    will cause drawRect to be called on views on which a setNeedsDisplay request has been done, even if the flush is done from inside a method that is blocking the UI run loop.

    Note that, when blocking the UI thread, a Core Animation flush is required to update changing CALayer contents as well. So, for animating graphic content to show progress, these may both end up being forms of the same thing.

    New added note to new added answer above:

    Do not flush faster than your drawRect or animation drawing can complete, as this might queue up flushes, causing weird animation effects.

  4. You can do this repeatedly in a loop and it'll work fine, no threads, no messing with the runloop, etc.

    [CATransaction begin];
    // modify view or views
    [view setNeedsDisplay];
    [CATransaction commit];

    If there is an implicit transaction already in place prior to the loop you need to commit that with [CATransaction commit] before this will work.

  5. Have you tried doing the heavy processing on a secondary thread and calling back to the main thread to schedule view updates? NSOperationQueue makes this sort of thing pretty easy.

    Sample code that takes an array of NSURLs as input and asynchronously downloads them all, notifying the main thread as each of them is finished and saved.

    - (void)fetchImageWithURLs:(NSArray *)urlArray {
    [self.retriveAvatarQueue cancelAllOperations];
    self.retriveAvatarQueue = nil;

    NSOperationQueue *opQueue = [[NSOperationQueue alloc] init];

    for (NSUInteger i=0; i<[urlArray count]; i++) {
    NSURL *url = [urlArray objectAtIndex:i];

    NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[self methodSignatureForSelector:@selector(cacheImageWithIndex:andURL:)]];
    [inv setTarget:self];
    [inv setSelector:@selector(cacheImageWithIndex:andURL:)];
    [inv setArgument:&i atIndex:2];
    [inv setArgument:&url atIndex:3];

    NSInvocationOperation *invOp = [[NSInvocationOperation alloc] initWithInvocation:inv];
    [opQueue addOperation:invOp];
    [invOp release];

    self.retriveAvatarQueue = opQueue;
    [opQueue release];

    - (void)cacheImageWithIndex:(NSUInteger)index andURL:(NSURL *)url {
    NSData *imageData = [NSData dataWithContentsOfURL:url];

    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSString *filePath = PATH_FOR_IMG_AT_INDEX(index);
    NSError *error = nil;

    // Save the file
    if (![fileManager createFileAtPath:filePath contents:imageData attributes:nil]) {
    DLog(@"Error saving file at %@", filePath);

    // Notifiy the main thread that our file is saved.
    [self performSelectorOnMainThread:@selector(imageLoadedAtPath:) withObject:filePath waitUntilDone:NO];


  6. Without questioning the wisdom of this (which you ought to do), you can do:

    [myView setNeedsDisplay];
    [[myView layer] displayIfNeeded];

    -setNeedsDisplay will mark the view as needing to be redrawn.
    -displayIfNeeded will force the view's backing layer to redraw, but only if it has been marked as needing to be displayed.

    I will emphasize, however, that your question is indicative of an architecture that could use some re-working. In all but exceptionally rare cases, you should never need to or want to force a view to redraw immediately. UIKit with not built with that use-case in mind, and if it works, consider yourself lucky.