;; Copyright (C) 1996 DIMACS Center, Rutgers, The State University of New Jersey
;; Author(s): Jonathan Berry

;; This software is copyrighted by the DIMACS Center at Rutgers, The State
;; University of New Jersey.  IT IS PROVIDED AS IS, AND THE AUTHORS, DIMACS, AND
;; RUTGERS, THE STATE UNIVERSITY OF NEW JERSEY  DISCLAIM
;; ALL LIABILITY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
;; DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
;; DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
;; POSSIBILITY OF SUCH DAMAGE.

;; THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
;; INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
;; FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
;; IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
;; NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
;; MODIFICATIONS.

;; The authors hereby grant permission to use, copy, modify, distribute,
;; and license this software and its documentation for any purpose, provided
;; that existing copyright notices are retained in all copies and that this
;; notice is included verbatim in any distributions. No written agreement,
;; license, or royalty fee is required for any of the authorized uses.
;; Modifications to this software may be copyrighted by their authors
;; and need not follow the licensing terms described here, provided that
;; the new terms are clearly indicated on the first page of each file where
;; they apply.

;; Last File Update: 31-Jul-1996
;; 

;(require "graph-view")

(define-generic vertex-item)
;(define-method vertex-item ((v <vertex*>) (gv <graph-view>))
;	(let ((vtab (slot-ref gv 'vertex-table)))
;		(hash-table-get vtab v)))

(define-method vertex-item ((v <vertex*>))
	(let* ((gv (hash-table-get *link:graph-view-table* (owner v)))
	       (vtab (slot-ref gv 'vertex-table)))
		(hash-table-get vtab v)))

(define-generic edge-item)
;(define-method edge-item ((e <edge*>) (gv <graph-view>))
;(let ((etab (slot-ref gv 'edge-table)))
;	(hash-table-get etab e)))

(define-method edge-item ((e <edge*>))
	(let* ((gv (hash-table-get *link:graph-view-table* (owner e)))
	       (etab (slot-ref gv 'edge-table)))
		(hash-table-get etab e)))

(define-method edge-item ((v <vertex*>) (v2 <vertex*>))
	(let ((e (is-edge v v2 )))
		(if e (edge-item e) #f)))

(define-method edge-item ((v <vertex-item>) (v2 <vertex-item>))
	(let ((e (is-edge (vertex v) (vertex v2) )))
		(if e (edge-item e (graph-view v)) #f)))

(define-method edge-item ((v <vertex-item>) (v2 <vertex*>))
	(let ((e (is-edge (vertex v) v2 )))
		(if e (edge-item e (graph-view v)) #f)))

(define-method edge-item ((v <vertex*>) (v2 <vertex-item>))
	(let ((e (is-edge v (vertex v2) )))
		(if e (edge-item e (graph-view v)) #f)))

(define-generic edge-items)
(define-method edge-items ((edge-list <pair>) )
         (map (lambda (x) (edge-item x))
                                edge-list))
(define-method edge-items ((edge-list <mset<edge*>>) )
         (map (lambda (x) (edge-item x))
                                (mset-edge->list edge-list)))
(define-method edge-items ((edge-list <set<edge*>>) )
         (map (lambda (x) (edge-item x))
                                (set-edge->list edge-list)))

(define-generic vertex-items)
(define-method vertex-items ((vertex-list <pair>))
         (map (lambda (x) (vertex-item x))
                                vertex-list))

(define-method vertex-items ((vertex-list <mset<vertex*>>) )
         (map (lambda (x) (vertex-item x))
                                (mset-vertex->list vertex-list)))

(define-method vertex-items ((vertex-list <set<vertex*>>) )
         (map (lambda (x) (vertex-item x))
                                (set-vertex->list vertex-list)))

(define (width-edges el sz)
	(map (lambda (x) (slot-set! x 'width sz)) el) #f)

(define-method vertices ((eg <edge-item>))
	(map vertex-item (set-vertex->list (vertices (edge eg)))))

(define-method neighbors ((vg <vertex-item>))
    (let ((nl (set-vertex->list (neighbors (vertex vg)))))
      (if (not (null? nl))
        (vertex-items (set-vertex->list (neighbors (vertex vg)))) 
	'())))

(define-method in-neighbors ((vg <vertex-item>))
    (let ((nl (set-vertex->list (in-neighbors (vertex vg)))))
      (if (not (null? nl))
        (vertex-items (set-vertex->list (in-neighbors (vertex vg)))) 
	'())))

(define-method out-neighbors ((vg <vertex-item>))
    (let ((nl (set-vertex->list (out-neighbors (vertex vg)))))
      (if (not (null? nl))
        (vertex-items (set-vertex->list (out-neighbors (vertex vg)))) 
	'())))

(define-method degree ((vg <vertex-item>))
	(degree (vertex vg)))

(define-method in-degree ((vg <vertex-item>))
	(in-degree (vertex vg)))

(define-method out-degree ((vg <vertex-item>))
	(out-degree (vertex vg)))



(define-method adjacent? ((vg <vertex-item>) (vg2 <vertex-item>))
	(adjacent-vertices? (vertex vg) (vertex vg2)))

(provide "graphics")
