(define-type real (or integer float ratnum))  ;not complex
(define-type pathname string)

;; Canvas

(define-type cmap (vector-of char))
(define-type char-canvas (struct char-canvas))
(define-type canvas (struct canvas))

;; Config

;FIXME plt-cfg needs a definition
(define-type plotter-configuration (list-of (or false char)))
(define-type plotter-config-arg (or char plotter-configuration))

(define-type box-frame-chars (vector char char char char char char char char))

(define-inline (frame-th f) (vector-ref f 0))
(define-inline (frame-bh f) (vector-ref f 1))
(define-inline (frame-lv f) (vector-ref f 2))
(define-inline (frame-rv f) (vector-ref f 3))
(define-inline (frame-tl f) (vector-ref f 4))
(define-inline (frame-tr f) (vector-ref f 5))
(define-inline (frame-bl f) (vector-ref f 6))
(define-inline (frame-br f) (vector-ref f 7))

;; Shape

(define-type shape-plotter (#!optional canvas fixnum fixnum -> (or canvas list)))
(define-type virtual-shape-plotter (#!optional canvas integer integer -> (or canvas list)))

;; Region

;; rect < vector

(define-type rect (vector integer integer integer integer))

(define-inline (*rect x y w h) (vector x y w h))
(define-inline (*rect-null) (vector 0 0 0 0))

(define-inline (*rect-c? obj)
  (and (integer? (vector-ref obj 0))
       (integer? (vector-ref obj 1))
       (integer? (vector-ref obj 2))
       (integer? (vector-ref obj 3))) )
(define-inline (*rect-s? obj)
  (and (vector? obj)
       (fx<= 4 (vector-length obj))) )
(define-inline (*rect? obj) (and (*rect-s? obj) (*rect-c? obj)))

(define-inline (*rect-x rt) (vector-ref rt 0))
(define-inline (*rect-y rt) (vector-ref rt 1))
(define-inline (*rect-wd rt) (vector-ref rt 2))
(define-inline (*rect-ht rt) (vector-ref rt 3))

(define-inline (*rect-null? rt) (or (zero? (*rect-wd rt)) (zero? (*rect-ht rt))))

(define-inline (*rect-x-end rt) (+ (*rect-x rt) (*rect-wd rt)))
(define-inline (*rect-y-end rt) (+ (*rect-y rt) (*rect-ht rt)))

(define-inline (*rect-x-min rt) (*rect-x rt))
(define-inline (*rect-y-min rt) (*rect-y rt))
(define-inline (*rect-x-max rt) (- (*rect-x-end rt) 1))
(define-inline (*rect-y-max rt) (- (*rect-y-end rt) 1))

(define-inline (*rect-area rt) (* (*rect-wd rt) (*rect-ht rt)))

;@ in ctor arg order; *rect
(define-inline (*rect->list rt)
  (list (*rect-x rt) (*rect-y rt)
        (*rect-wd rt) (*rect-ht rt)) )
(define-inline (*list->rect ls)
  (*rect (car ls) (cadr ls) (caddr ls) (cadddr ls)) )

;canvas interaction

(define-inline (*canvas->rect cv) (*rect 0 0 (canvas-width cv) (canvas-height cv)))

;; char-rect < rect

;of dubious utility since fixnum range is big
(define-type char-rect (vector fixnum fixnum fixnum fixnum))

(define-inline (*char-rect-c? obj)
  (and (fixnum? (vector-ref obj 0))
       (fixnum? (vector-ref obj 1))
       (fixnum? (vector-ref obj 2))
       (fixnum? (vector-ref obj 3))) )
(define-inline (*char-rect-s? obj)
  (and (vector? obj)
       (fx<= 4 (vector-length obj))) )
(define-inline (*char-rect? obj) (and (*char-rect-s? obj) (*char-rect-c? obj)))

(define-inline (*char-canvas->rect cv) (*rect 0 0 (canvas-rows cv) (canvas-columns cv)))

;; wndw < rect

(define-type wndw (vector integer integer integer integer canvas))

(define-inline (*wndw cv x y w h) (vector x y w h cv))

(define-inline (*wndw/rect cv rect)
  (*wndw cv (*rect-x rect) (*rect-y rect)
            (*rect-wd rect) (*rect-ht rect)) )

(define-inline (*wndw-c? obj)
  (and (*rect-c? obj)
       (canvas? (vector-ref obj 4))) )
(define-inline (*wndw-s? obj)
  (and (*rect-s? obj)
       (fx<= 5 (vector-length obj))) )
(define-inline (*wndw? obj) (and (*wndw-s? obj) (*wndw-c? obj)))

(define-inline (*wndw-canvas cwin) (vector-ref cwin 4))

;@ in ctor arg order; *wndw
(define-inline (*wndw->list cwin)
  (list (*wndw-canvas cwin)
        (*rect-x cwin) (*rect-y cwin)
        (*rect-wd cwin) (*rect-ht cwin)) )

(define-inline (*canvas->wndw cv) (*wndw/rect cv (*canvas->rect cv)))

;; char-wndw < wndw( char-canvas char-rect )

(define-type char-wndw (vector fixnum fixnum fixnum fixnum canvas))

(define-inline (*char-wndw-c? obj)
  (and (*char-rect-c? obj)
       (char-canvas? (vector-ref obj 4))) )
(define-inline (*char-wndw-s? obj)
  (and (*char-rect-s? obj)
       (fx<= 5 (vector-length obj))) )
(define-inline (*char-wndw? obj) (and (*char-wndw-s? obj) (*char-wndw-c? obj)))

(define-inline (*char-canvas->wndw cv) (*wndw/rect cv (*char-canvas->rect cv)))