Matthew Butterick 3 years ago
commit 4a0e7d18bb

@ -0,0 +1,174 @@
#lang debug racket/base
(require (for-syntax racket/base racket/syntax)
racket/struct
racket/format
racket/list
racket/string
racket/promise
racket/dict
racket/match
"param.rkt"
"rebase.rkt")
(provide (all-defined-out))
(module+ test (require rackunit))
(define-syntax (define-quad-attribute stx)
(syntax-case stx ()
[(_ ATTR)
(with-syntax ([QUAD-ATTR (format-id #'ATTR "quad-~a" #'ATTR)]
[QUAD-ATTR-SET! (format-id #'ATTR "quad-~a-set!" #'ATTR)])
#'(begin
(define (QUAD-ATTR q) (hash-ref q 'ATTR #false))
(define (QUAD-ATTR-SET! q val) (hash-set! q 'ATTR val) q)))]
[(_ ATTR ...)
#'(begin
(define-quad-attribute ATTR) ...)]))
(define-quad-attribute size)
(define (size q)
(match (quad-size q)
[(? procedure? proc) proc (proc q)]
[(? promise? prom) (force prom)]
[val val]))
(define-quad-attribute printable)
(define (printable? q [signal #f])
(match (quad-printable q)
[(? procedure? proc) (proc q signal)]
[val val]))
(define-quad-attribute draw-start draw draw-end)
(define (draw q [surface (current-output-port)])
((or (quad-draw-start q) void) q surface)
((or (quad-draw q) void) q surface)
((or (quad-draw-end q) void) q surface))
(define-quad-attribute elems shift from-parent from to shift-elems origin)
(define quad=? equal?)
;; keep this param here so you don't have to import quad/param to get it
(define verbose-quad-printing? (make-parameter #f))
(define quad? hash?)
#;(struct quad (
;; WARNING
;; atomize procedure depends on attrs & elems
;; being first two fields of struct.
attrs ; key-value pairs, arbitrary
elems ; subquads or text
;; size is a two-dim pt
size ; outer size of quad for layout (though not necessarily the bounding box for drawing)
;; from-parent, from, to are phrased in terms of cardinal position
from-parent ; alignment point on parent. if not #f, supersedes `from`
;; (this way, `from` doens't change, so a quad can "remember" its default `from` attachment point)
from ; alignment point on ref quad
to ; alignment point on this quad that is matched to `from` on previous quad
;; shift-elements, shift are two-dim pts
;; shift-elements = Similar to `relative` CSS positioning
;; moves origin for elements . Does NOT change layout position of parent.
shift-elems
;; shift = shift between previous out point and current in point.
;; DOES change the layout position.
shift
;; reference point (in absolute coordinates)
;; for all subsequent drawing ops in the quad. Calculated, not set directly
origin
printable ; whether the quad will print
draw-start ; func called at the beginning of every draw event (for setup ops)
draw ; func called in the middle of every daw event
draw-end ; func called at the end of every draw event (for teardown ops)
name ; for anchor resolution
tag) ; from q-expr, maybe
#:mutable
#:transparent
#:property prop:custom-write
(λ (q p w?) (display
(format "<~a-~a~a~a>"
(quad-tag q)
(object-name q)
(if (verbose-quad-printing?)
(string-join (map ~v (flatten (hash->list (quad-attrs q))))
" " #:before-first "(" #:after-last ")")
"")
(match (quad-elems q)
[(? pair?) (string-join (map ~v (quad-elems q)) " " #:before-first " ")]
[_ ""])) p))
#:methods gen:equal+hash
[(define equal-proc quad=?)
(define (hash-proc h recur) (equal-hash-code h))
(define (hash2-proc h recur) (equal-secondary-hash-code h))])
#;(struct quad-attr (key default-val) #:transparent)
#;(define (make-quad-attr key [default-val #f])
(quad-attr key default-val))
(define quad-ref hash-ref)
(define quad-set! hash-set!)
(define-syntax (quad-copy stx)
(syntax-case stx ()
[(_ QUAD-TYPE ID [K V] ...)
(if (free-identifier=? #'quad #'QUAD-TYPE)
#'(struct-copy QUAD-TYPE ID
[K V] ...)
#'(struct-copy QUAD-TYPE ID
[K #:parent quad V] ...))]))
#;(define-syntax (quad-update! stx)
(syntax-case stx ()
[(_ ID [K V] ...)
(with-syntax ([(K-SETTER ...) (for/list ([kstx (in-list (syntax->list #'(K ...)))])
(format-id kstx "set-quad-~a!" kstx))])
#'(let ([q ID])
(K-SETTER q V) ...
q))]))
(define (default-printable q [sig #f]) #t)
(define (default-draw q surface)
(for-each (λ (qi) (draw qi surface)) (quad-elems q)))
;; why 'nw and 'ne as defaults for in and out points:
;; if size is '(0 0), 'nw and 'ne are the same point,
;; and everything piles up at the origin
;; if size is otherwise, the items don't pile up (but rather lay out in a row)
#;(define (make-quad-constructor type)
(make-keyword-procedure (λ (kws kw-args . rest)
(keyword-apply make-quad #:type type kws kw-args rest))))
(define (derive-quad-constructor q)
(define-values (x-structure-type _) (struct-info q))
(struct-type-make-constructor x-structure-type))
(define q make-hash)
(define only-prints-in-middle (λ (q sig) (not (memq sig '(start end)))))
(define/match (from-parent qs [where #f])
;; doesn't change any positioning. doesn't depend on state. can happen anytime.
;; can be repeated without damage.
[((? null?) _) null]
[((cons q rest) where)
(quad-set! q [from-parent (or where (quad-from q))])
(cons q rest)])
(module+ test
(require racket/port)
(define q1 (q '((elems #\H #\e #\l #\o))))
(define q2 (q '((elems #\H #\e #\l #\o))))
(define q3 (q '((elems #\H #\e #\l))))
(check-true (equal? q1 q1))
(check-true (equal? q1 q2))
(check-false (equal? q1 q3))
(define q4 (quad-draw-set! (hash-copy q1) (λ (q surface) (display "foo" surface))))
(check-equal? (with-output-to-string (λ () (draw q4))) "foo"))
Loading…
Cancel
Save