Incremental Redisplay

[Scott McKay <SWM%sapsucker.scrc.symbolics.com@RELAY.CS.NET>]

    Date: Thu, 26 Jan 89 11:59:00 EST
    From: owens-christopher@YALE.ARPA (Christopher Owens)


    I am getting some unexpected processing overhead when using
    incremental redisplay of a pane within a program framework defined by
    dw:define-program-framework. 

    This particular pane is designed to display a list of objects,
    presented one per line.  When I defined the pane, I used options
     :redisplay-after-commands T
     :incremental-redisplay T
     :redisplay-function 'foo-display


    (defmethod (foo-display my-program) (stream)
      (dw:with-redisplayable-output
	  (:stream stream
	   :cache-value *list*
	   :unique-id 'list)
	 (formatting-table (stream)
	   (dolist (thing *list*)
	     (formatting-row (stream)
	       (formatting-cell (stream)
		 (dw:with-redisplayable-output (:cache-value thing)
		   (dw:redisplayable-present thing 'thing-presentation
					     stream))))))))


Does *LIST* remain EQ between commands, or EQUAL?  You might try a
:CACHE-TEST of EQUAL.

Also, the DW:REDISPLAYABLE-PRESENT inside the
DW:WITH-REDISPLAYABLE-OUTPUT is probably not needed.

    This has the right behavior in that if *list* changes the display
    updates, and if *list* does not change, the display does not update.
    But, in the cases where *list* does not change, the code runs almost
    as long as it does when *list* does change.  I do not understand this,
    since I was under the impression that the outermost
    dw:with-redisplayable-output form prevents any code inside it from
    executing when the cache-value has not changed.  I find that if I
    recompile the program frame, shutting off the redisplay-after-commands
    option, the code runs nice and fast.

    So what am I doing?  Do I not understand something correctly here?

    Thank you,

    /c