Racket refresh-now, thread, and yield

I've been writing some simple racket GUI programs to prepare for a class I'm teaching in the fall. I'm having some problems with animation. I'm using a basic canvas, and using the model for animation in which the entire canvas is refreshed each frame, by calling the paint procedure. An example program is below.

My problem is that I have to either run the a开发者_开发技巧nimation as a separate thread, or call yield after each instance of refresh-now. Why is this? I expected the refresh-now to cause the image to refresh right away, without additional work on my part.

I have read the animation examples on the racket pages, and see that they usually draw directly to the canvas. I understand that since the canvas is double-buffered this works fine ... but for my application it's easier to just have the paint procedure carry the load, since I need a working paint procedure anyway in case of minimizing, etc. (Of course, the yield is not a huge burden, but it would be easier to teach if it were not needed.)

Thanks,

John

#lang racket

; Demonstrate simple animation in Racket

(require racket/gui)

(define min-x 0)
(define min-y 0)
(define max-x 200)
(define max-y 200)

; Three vertexes of the triangle, expressed relative to a starting x and y location.
(define triangle-vertexes [list 
(list 10 0) 
(list 0 20) 
(list 20 20)])

(define triangle-x 20)
(define triangle-y 20)

; Move a triangle by a (delta-x, delta-y) pair
(define (move-triangle adjust)
(set! triangle-x (+ triangle-x (first adjust)))
(set! triangle-y (+ triangle-y (second adjust))))

; Adjust the location of a vertex by adding an (x,y) adjustment to it.
; Could also be defined using map.
(define (triangle-adjust adjust vertex)
(list (+ (first adjust) (first vertex))
(+ (second adjust) (second vertex))))

; Create the paint-callback function.
; It should:
; - draw a triangle at the current location
(define (draw-triangle dc)
(let ((vertex1 (triangle-adjust (list triangle-x triangle-y) (first  triangle-vertexes)))
(vertex2 (triangle-adjust (list triangle-x triangle-y) (second triangle-vertexes)))
(vertex3 (triangle-adjust (list triangle-x triangle-y) (third  triangle-vertexes))))
(send dc draw-line (first vertex1) (second vertex1) (first vertex2) (second vertex2))
(send dc draw-line (first vertex2) (second vertex2) (first vertex3) (second vertex3))
(send dc draw-line (first vertex3) (second vertex3) (first vertex1) (second vertex1))))


(define frame (new frame%
[label "Animation Example"]
[width 800]
[height 800]))

(define triangle-canvas (new canvas% [parent frame]
[paint-callback
(lambda (canvas dc)
(display "callback called")
(draw-triangle dc))]))

(send frame show #t)

; run a thunk (a procedure of zero arguments) n times
; only useful if thunk has side-effects
(define (loop n thunk)
(cond 
((> n 0) (thunk)
(loop (- n 1) thunk))
(else false)))

; Animate the triangle.  We have to either run this in a different thread from
; the event loop or yield each time we want something to be drawn.
(define (animate-triangle)
(loop 30 
(lambda ()
(move-triangle (list 10 10))
(send triangle-canvas refresh-now)
;      (send triangle-canvas flush)
(yield)
;      (sleep 0.1)
)))

This isn't an answer to your question about refresh-now, but a better alternative to an explicit thread and loop is the timer% class:

;; This goes after (send frame show #t), replacing loop and animate-triangle
(define timer-counter 0)
(define timer
  (new timer%
       (interval 100)  ;; update every 100 ms
       (notify-callback
        (lambda ()
          (cond [(< timer-counter 30)
                 (set! timer-counter (add1 timer-counter))
                 (move-triangle (list 10 10))
                 (send triangle-canvas refresh)]
                [else
                 (send timer stop)])))))

If you redefine your stopping condition based on the triangle's state, you can get rid of the auxiliary timer-counter; I put it in to mimic the behavior of your original code.

The timer is created in the same eventspace as the frame, and the eventspace has an event-handling thread, which is why you don't have to create your own thread explicitly.

How to Design Programs, 2nd ed has another approach to animation, where the canvas and updates are managed automatically. You just call big-bang with functions to (functionally) update the "state of the world" and render the "state of the world" as an image. Depending on exactly what you're teaching, it may or may not be useful to you.