;;; -*- Mode: Lisp; Package: DESIGN; Syntax: Ansi-common-lisp -*-

;; Visibility is a bit of a mess at the moment...need visibility of edges (for 
;; model editor)


;; Visibility values for design elements

#+ignore
(defun visibility-values ()
  '(:void :closeable-void :semi-void :solid nil)) 

(defun visibility-values ()
  '(:open :closeable :semi-open :opaque nil))

;; Edges are open, closeable if they correspond to doors, semi-open for windows and
;; half-walls, or opaque, which is the default.  Not clear how semi-open is to be used.

(defmethod visibility-value ((element design-element))
  ;; probably should write one method per design-element type...later
  ;; value for 2d plan drawn about eyelevel (i.e. ignore solid wall above door opening,
  ;; include windows)
  (typecase element
    (door :closeable)
    (window :semi-open)
    (half-wall :semi-open)
    (screen :semi-open)
    (wall :opaque)
    (fireplace :opaque)   	 ; should check materials of object, plus fplace may be open
    (steps :opaque)
    (otherwise nil))) 

;; method called by boundary code to distinguish voids from solids (e.g. for OPEN test)
(defmethod visibility-value ((thing (eql nil)))
  nil)

;; have to check for this one first if also checking voidp

(defmethod closeablep ((value symbol))
  (eql value :closeable))

(defmethod openp ((value symbol))
 (and value (member value '(:open :closeable)) t))

(defmethod semi-openp ((value symbol))
  (eql value :semi-open))

(defmethod strictly-openp ((value symbol))
  (eql value :open))

(defmethod opaquep ((value symbol))
  (or (null value) (eql value :opaque)))



;; For edges

(defun set-visibility-value (thing value)
  (setf (getf (plist thing) :visibility-value) value))

(defmethod visibility-value ((edge edge))
  (or (getf (plist edge) :visibility-value)
      (visibility-value (design-element edge))))

(defmethod openp ((edge edge))
  (openp (visibility-value edge)))

(defmethod closeablep ((edge edge))
  (closeablep (visibility-value edge)))

(defmethod strictly-openp ((edge edge))
  (strictly-openp (visibility-value edge)))

(defmethod opaquep ((edge edge))
  (opaquep (visibility-value edge)))

;; former methods:
(defmethod voidp (x)
  (openp x))

(defmethod closeable-void-p (x)
  (closeablep x))

(defmethod strictly-void-p (x)
  (strictly-openp x))

(defmethod solidp (x)
  (opaquep x))


(defvar *line-dashes* (clim::make-contrasting-dash-patterns 2))

(defvar *dashes-for-openings* (aref *line-dashes* 0))
(defvar *dashes-for-closeable-openings* (aref *line-dashes* 1))

(defun dashes-for-closeable-openings ()
  *dashes-for-closeable-openings*)

(defun dashes-for-openings ()
  *dashes-for-openings*)

;; For drawing

(defun line-dashes-for-thing (thing)
  (cond ((closeablep thing) (dashes-for-closeable-openings))
	((strictly-openp thing) (dashes-for-openings))
	(t nil)))