[cells-devel] Cells 3 and Celtk committed to CVS

[Ken Tilton]

This is weird, I know I sent this but did not get it as a list
subscriber nor do I see it in my sent folder. Anyway, at pain of
repeating myself.

Cells 3 has been committed to CVS (not a new module, just Cells updated).

Celtk is a new module, a portable Cells Inside GUI built atop the core
of LTk. It requires Cells3.

I may actually do a little Cells doc by way of explaining Cells3
differences. The big deal can be sorted out by examining the
"finish-business" function. It makes apparent how Cells orchestrates
orderly state change. Cells3 also enforces that, by yelping if one
attempts a SETF in an observer -- you have to wrap the setf and any
computation relevant to that setf:

   (with-integrity (:change)
       <be safe, wrap the whole observer form>)

If this helps, here is what I had to do to port the test suite:
    [s/old/new/w is the VAX EDT editor command for subsitute/old/new/whole]


s/def-c-output/defobserver/w
   The syntax is unchanged. Any setfs of input Cells you have in the
body will cause a runtime error unless you wrap the form in
with-integrity as discussed above.

s/with-deference/with-integrity (:change)/w
   turns out all the wrapped forms were SETFs. I kinda like the idea
of with-deference since, in the case of an observer setf, one really
is asking for a deferred action. with-integrity is a "maybe" deal --
it says "go ahead if not already under integrity handling.

s/make-be/make-instance/w
  special handling now handled in shared-initialize

Forget to-be, not needed anymore

When the Family code squawks about :fm-parent being required, add:

   :fm-parent self

...to the make-instance argument list. In some cases the instances
were being made without a surrounding (c? ...) form. That is needed to
have access to the parent instance self. btw, there is a make-kid
macro that is just (make-instance ',class :fm-parent self ...).

again, the cells engine yelps if it encounters a SETF needing wrapping
in: (with-integrity (:change) (setf ...))

Celtk shows a complicated example of using the client queue to get a
declarative Cells app to talk coherently to an imperative,
order-sensitive system.


kt