; An example of using Zowie with zorphs

(load "zowie-all.scm")

; --------------------------------------------------
;
; A (soon to be) resizable rectangle
; --------------------------------------------------

(define-class <zorph.rect> (<zorph.base>) ())

(define-method (initialize (zorph <zorph.rect>) args)
  (call-next-method)
  (or (zorph-model zorph)
      (zorph-model-set! zorph (make <zowie.model.rect>))))

(define-method (calculate-bounds (zorph <zorph.rect>))
  (rect-model-rect (zorph-model zorph)))

(define-method (handle-model-changed (zorph <zorph.rect>) model args)
  (if (and (not (null? args)) (eq? (car args) 'bounds))
      (let ((newbounds (rect-model-rect model)))
        (invalidate-bounds zorph)
        (invalidate zorph))
      #f))

(define-method (paint (zorph <zorph.rect>) context)
  ;(display "draw rect: ")(display (rect-model-rect (zorph-model zorph)))(newline)
  (let ((args (cons cairo
                    (rect->bounds
                     (rect-model-rect (zorph-model zorph))))))
    (cairo-new-path cairo)
    (cairo-set-rgb-color context 1.0 0.0 0.0)
    (apply cairo-rectangle args)
    (cairo-fill context))
  (call-next-method))

(define-class <example-controller> (<zorph.default.world-controller>) (zooming))

(define-method (handle-input-event (contro <example-controller>) event)
  (let ((t (sdl-event-type event)))
    (cond ((= t SDL_MOUSEBUTTONUP)
           (slot-set! contro 'zooming #f))
          ((= t SDL_MOUSEBUTTONDOWN)
           (if (mousebutton-down?/state SDL_BUTTON_LMASK (sdl-event-state event))
               (let* ((cx (sdl-event-x event))
                      (cy (sdl-event-y event))
                      (center (make-point2d cx cy)))
                 (letrec ((loop
                           (lambda ()
                             (if (slot-ref contro 'zooming)
                                 (let* ((pos (mouse-position))
                                        (scale (+ 1 (/ (- (point2d-x pos) cx) maxx)))
                                        (center (point2d-transform-fro center (camera-model-view-transform (controller-model contro)))))
                                   (call/camera-view
                                    (controller-model contro)
                                    (cut transform-scale-about-point <> (point2d-x center) (point2d-y center) scale scale))
                                   (sdl-add-relative-timer! 0.05 loop))))))
                   (slot-set! contro 'zooming #t)
                   (sdl-add-relative-timer! 0.05 loop)))))
          ((= t SDL_KEYUP)
           (let* ((pos (mouse-position))
                  (x (point2d-x pos))
                  (y (point2d-y pos))
                  (m (controller-model contro))
                  (vt (camera-model-view-transform m))
                  ;; I'll have to transform the /distance/, not a rectangle
;                  (r (rect-transform-fro (bounds->rect 0 0 20 20) vt))
                  (p (point2d-transform-fro pos vt))
                  (layer (car (camera-model-layers m)))
                  (rect (make <zorph.rect>)))
             (apply rect-model-set! `(,(zorph-model rect)  0 0 20 20))
             (zorph-translate rect (point2d-x p) (point2d-y p))
             (zorph-child-add! layer rect)))
          (else
            (call-next-method)))))

(sdl-init SDL_INIT_EVERYTHING)

(define maxx 800)
(define maxy 600)

(sdl-wm-set-caption "TestZowie" "TestZowie")
(define s (sdl-set-video-mode maxx maxy 0 (+ SDL_HWSURFACE
                                             SDL_HWPALETTE
                                             SDL_DOUBLEBUF
                                             SDL_RESIZABLE)))

(define cairo (cairo-create))
(cairo-set-target-image cairo
                        (sdl-surface-pixels s)
                        CAIRO_FORMAT_RGB24 maxx maxy
                        (sdl-surface-pitch s))

(define context (make-gfx-context s cairo))

(define world-controller (make <example-controller>))
(slot-set! world-controller 'gfx context)

(define world (make <zorph.world> 'context context))
(zorph-model-controller-set!
 world
 (make <zowie.model.camera>)
 world-controller)
(rect-model-set! (zorph-model world) 0 0 maxx maxy)
(define layer (make <zorph.base>))
(camera-model-lookat! (zorph-model world) layer)

(define-class <thumbnail> (<zorph.lens>) ())

(define-class <thumbnail-adapter> () (thumbnail lag dx dy))

(define (thumbnail-adapter thumbnail lag offsetx offsety)
  (let ((adapter (make <thumbnail-adapter>)))
    (initialize-slots adapter
                      (list
                       'thumbnail thumbnail
                       'lag lag
                       'dx offsetx
                       'dy offsety))
    adapter))

(define-method (handle-model-changed (adapter <thumbnail-adapter>) model args)
  (let ((lag (slot-ref adapter 'lag))
        (thumb (slot-ref adapter 'thumbnail)))
    (if (eq? (car args) 'view-transform)
        (call/camera-view
         (zorph-model thumb)
         (lambda (t)
           (transform-copy (camera-model-view-transform model) t)
           (transform-scale t lag lag))))))

(define-method (paint (zorph <thumbnail>) context)
  (apply cairo-rectangle (cons context (rect->bounds
                                  (rect-model-rect (zorph-model zorph)))))
  (cairo-set-rgb-color context 1.0 1.0 1.0)
  (cairo-set-alpha context 0.7)
  (cairo-fill context)
  (call-next-method))

(define thumb
  (let ((lens (make <thumbnail>)))
    (rect-model-set! (zorph-model lens) 0 0 200 200)
;    (zorph-translate lens (- maxx 200) 0)
    (call/camera-view (zorph-model lens)
                      (cut transform-scale <> 0.5 0.5))
    (camera-model-lookat! (zorph-model lens) layer)
    lens))
(zorph-child-add! world thumb)

(model-listener-add!
 (zorph-model world)
 (thumbnail-adapter thumb 0.5 0 0))