Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -864,12 +864,10 @@
 	    (hash-table-set! tests-draw-state 'first-time #f)
 	    (hash-table-set! tests-draw-state 'scalef 1)
 	    (hash-table-set! tests-draw-state 'tests-info (make-hash-table))
 	    (hash-table-set! tests-draw-state 'selected-tests (make-hash-table))
 	    ;; set these 
-	    (hash-table-set! tests-draw-state 'test-browse-xoffset 20) ;; (- 0 (* (/ sizex 2) (* 8 xadj))))
-	    (hash-table-set! tests-draw-state 'test-browse-yoffset 20) ;; (- 0 (* (/ sizey 2) (* 8 (- 1 yadj)))))))
 	    (dcommon:initial-draw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records))
 	  (dcommon:redraw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records))
       ))
 
 ;;======================================================================
@@ -1068,51 +1066,51 @@
 			    #:expand "YES"
 			    #:scrollbar "YES"
 			    #:posx "0.5"
 			    #:posy "0.5"
 			    #:button-cb (lambda (obj btn pressed x y status)
-					  (print "obj: " obj ", pressed " pressed ", status " status)
-					  (print "canvas-origin: " (canvas-origin the-cnv))
-					  (let-values (((xx yy)(canvas-origin the-cnv)))
-					    (canvas-transform-set! the-cnv #f)
-					    (print "canvas-origin: " xx " " yy " click at " x " " y))
-					  (let* ((tests-info     (hash-table-ref tests-draw-state  'tests-info))
-						 (selected-tests (hash-table-ref tests-draw-state  'selected-tests))
+					  ;; (print "obj: " obj ", pressed " pressed ", status " status)
+					  ; (print "canvas-origin: " (canvas-origin the-cnv))
+					  ;; (let-values (((xx yy)(canvas-origin the-cnv)))
+					    ;; (canvas-transform-set! the-cnv #f)
+					    ;; (print "canvas-origin: " xx " " yy " click at " x " " y))
+					  (let* ((tests-info     (hash-table-ref tests-draw-state 'tests-info))
+						 (selected-tests (hash-table-ref tests-draw-state 'selected-tests))
 						 (scalef         (hash-table-ref tests-draw-state 'scalef))
-						 (x-scaled       (/ x scalef))
-						 (y-scaled       (/ y scalef)))
+						 (sizey          (hash-table-ref tests-draw-state 'sizey))
+						 (xoffset        (dcommon:get-xoffset tests-draw-state #f #f))
+						 (yoffset        (dcommon:get-yoffset tests-draw-state #f #f))
+						 (new-y          (- sizey y)))
+					    ;; (print "xoffset=" xoffset ", yoffset=" yoffset)
 					    ;; (print "\tx\ty\tllx\tlly\turx\tury")
 					    (for-each (lambda (test-name)
 							(let* ((rec-coords (hash-table-ref tests-info test-name))
-							       (llx        (list-ref rec-coords 0))
-							       (urx        (list-ref rec-coords 1))
-							       (lly        (list-ref rec-coords 2))
-							       (ury        (list-ref rec-coords 3)))
-							  (if (eq? pressed 1)
-							      (print "\tx=" x "\ty=" y "\t" llx "\t" lly "\t" urx "\t" ury "\t" test-name " "))
+							       (llx        (dcommon:x->canvas (list-ref rec-coords 0) scalef xoffset))
+							       (lly        (dcommon:y->canvas (list-ref rec-coords 1) scalef yoffset))
+							       (urx        (dcommon:x->canvas (list-ref rec-coords 2) scalef xoffset))
+							       (ury        (dcommon:y->canvas (list-ref rec-coords 3) scalef yoffset)))
+							  ;; (if (eq? pressed 1)
+							  ;;    (print "\tx=" x "\ty=" y "\tnew-y=" new-y "\tllx=" llx "\tlly=" lly "\turx=" urx "\tury=" ury "\t" test-name " "))
 							  (if (and (eq? pressed 1)
-								   (>= x-scaled llx)
-								   (>= y-scaled lly)
-								   (<= x-scaled urx)
-								   (<= y-scaled ury))
+								   (>= x llx)
+								   (>= new-y lly)
+								   (<= x urx)
+								   (<= new-y ury))
 							      (let ((patterns (string-split (iup:attribute test-patterns-textbox "VALUE"))))
 								(let* ((selected     (not (member test-name patterns)))
 								       (newpatt-list (if selected
 											 (cons test-name patterns)
 											 (delete test-name patterns)))
 								       (newpatt      (string-intersperse newpatt-list "\n")))
-								  ;; (if cnv-obj
-								  ;;    (dashboard:draw-tests cnv-obj 0 0 tests-draw-state sorted-testnames))
 								  (iup:attribute-set! obj "REDRAW" "ALL")
 								  (hash-table-set! selected-tests test-name selected)
 								  (iup:attribute-set! test-patterns-textbox "VALUE" newpatt)
 								  (dboard:data-set-test-patts! *data* (dboard:lines->test-patt newpatt))
 								  (dashboard:update-run-command)
 								  (if updater (updater last-xadj last-yadj)))))))
 						      (hash-table-keys tests-info)))))))
 	  canvas-obj)))
-      ;; (print "obj: " obj " btn: " btn " pressed: " pressed " x: " x " y: " y " status: " status))
        
       (iup:frame
        #:title "Logs" ;; To be replaced with tabs
        (let ((logs-tb (iup:textbox #:expand "YES"
 				   #:multiline "YES")))

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -590,16 +590,16 @@
 
 ;;======================================================================
 ;; CANVAS STUFF FOR TESTS
 ;;======================================================================
 
-(define (dcommon:draw-test cnv scalef x y w h name selected)
-  (let* ((llx (* scalef x))
-	 (lly (* scalef y))
-	 (urx (* scalef (+ x w)))
-	 (ury (* scalef (+ y h))))
-    (canvas-text! cnv (+ llx 5)(+ lly 5) name) ;; (conc testname " (" xtorig "," ytorig ")"))
+(define (dcommon:draw-test cnv xoffset yoffset scalef x y w h name selected)
+  (let* ((llx (dcommon:x->canvas x scalef xoffset))
+	 (lly (dcommon:y->canvas y scalef yoffset))
+	 (urx (dcommon:x->canvas (+ x w) scalef xoffset))
+	 (ury (dcommon:y->canvas (+ y h) scalef yoffset)))
+    (canvas-text! cnv (+ llx 5)(+ lly 5) name)
     (canvas-rectangle! cnv llx urx lly ury)
     (if selected (canvas-box! cnv llx (+ llx 5) lly (+ lly 5)))))
 
 (define (dcommon:draw-arrow cnv test-box-center waiton-center)
   (let* ((test-box-center-x (vector-ref test-box-center 0))
@@ -641,33 +641,41 @@
 		)
   (canvas-mark! cnv new-waiton-x new-waiton-y)))
 
 (define (dcommon:get-box-center box)
   (let* ((llx  (list-ref box 0))
-	 (lly  (list-ref box 4))
-	 (boxw (list-ref box 5))
-	 (boxh (list-ref box 6)))
+	 (lly  (list-ref box 1))
+	 (boxw (list-ref box 4))
+	 (boxh (list-ref box 5)))
     (vector (+ llx (/ boxw 2))
 	    (+ lly (/ boxh 2)))))
 
 (define-inline (num->int num)
   (inexact->exact (round num)))
 
-(define (dcommon:draw-edges cnv scalef edges)
+(define (dcommon:draw-edges cnv xoffset yoffset scalef edges)
   (for-each
    (lambda (e)
      (let loop ((x1 (car e))
 		(y1 (cadr e))
 		(x2 #f)
 		(y2 #f)
 		(tal (cddr e)))
        (if (and x1 y1 x2 y2)
-	   (canvas-line! cnv x1 y1 x2 y2)) ;; (num->int x1)(num->int y1)(num->int x2)(num->int y2)))
+	   (canvas-line! 
+	    cnv 
+	    (num->int (dcommon:x->canvas x1 scalef xoffset))
+	    (num->int (dcommon:y->canvas y1 scalef yoffset))
+	    (num->int (dcommon:x->canvas x2 scalef xoffset))
+	    (num->int (dcommon:y->canvas y2 scalef yoffset)))) ;; (num->int x1)(num->int y1)(num->int x2)(num->int y2)))
        (if (< (length tal) 2)
-	   (canvas-mark! cnv x1 y1) ;; (num->int x1)(num->int y1))
+	   (canvas-mark! cnv
+			 (num->int (dcommon:x->canvas x1 scalef xoffset))
+			 (num->int (dcommon:y->canvas y1 scalef yoffset))) ;; (num->int x1)(num->int y1))
 	   (loop (car tal)(cadr tal) x1 y1 (cddr tal)))))
-   (map (lambda (e)(map (lambda (x)(num->int (* x scalef))) e)) edges)))
+   ;; (map (lambda (e)(map (lambda (x)(num->int (* x scalef))) e)) edges)))
+   edges))
 
 
 (define (dcommon:draw-arrows cnv testname tests-hash test-records)
   (let* ((test-box-info   (hash-table-ref tests-hash testname))
 	 (test-box-center (dcommon:get-box-center test-box-info))
@@ -697,32 +705,47 @@
      nodes)
     (let ((scalex (/ sizex maxx))
 	  (scaley (/ sizey maxy)))
       (print "maxx: " maxx " maxy: " maxy " scalex: " scalex " scaley: " scaley)
       (min scalex scaley))))
+
+(define (dcommon:get-xoffset tests-draw-state sizex-in xadj-in)
+  (let ((xadj  (or xadj-in  (hash-table-ref/default tests-draw-state 'xadj 0)))
+	(sizex (or sizex-in (hash-table-ref/default tests-draw-state 'sizex 500))))
+    (hash-table-set! tests-draw-state 'xadj xadj) ;; for use in de-scaling when handling mouse clicks
+    (hash-table-set! tests-draw-state 'sizex sizex)
+    (* (/ sizex 2) (- 0.5 xadj))))
+
+(define (dcommon:get-yoffset tests-draw-state sizey-in yadj-in)
+  (let ((yadj  (or yadj-in  (hash-table-ref/default tests-draw-state 'yadj 0)))
+	(sizey (or sizey-in (hash-table-ref/default tests-draw-state 'sizey 500))))
+    (hash-table-set! tests-draw-state 'yadj yadj) ;; for use in de-scaling when handling mouse clicks
+    (hash-table-set! tests-draw-state 'sizey sizey)
+    (* (/ sizey 2) (- yadj 0.5))))
+
+(define (dcommon:x->canvas x scalef xoffset)
+  (+ xoffset (* x scalef)))
+
+(define (dcommon:y->canvas y scalef yoffset)
+  (+ yoffset (* y scalef)))
 
 ;; sizex, sizey     - canvas size
 ;; originx, originy - canvas origin
 ;;
 (define (dcommon:initial-draw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records)
   (let* ((dot-data ;; (map cdr (filter
 		   ;; 	  (lambda (x)(equal? "node" (car x)))
 	  (map string-split (tests:lazy-dot test-records "plain" sizex sizey))) ;; (tests:easy-dot test-records "plain")))
-	 (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
-	 (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
-	 (xtorig (+ test-browse-xoffset (* (/ sizex 2) 1 (- 0.5 xadj)))) ;;  (- xadj 1))))
-	 (ytorig (+ test-browse-yoffset (* (/ sizey 2) 1 (- yadj 0.5))))
-	 (boxw   10)
-	 (tests-hash     (hash-table-ref tests-draw-state 'tests-info))
+	 (xoffset	 (dcommon:get-xoffset tests-draw-state sizex xadj))
+	 (yoffset        (dcommon:get-yoffset tests-draw-state sizey yadj))
+	 (boxw           10)
+	 (tests-info     (hash-table-ref tests-draw-state 'tests-info))
 	 (selected-tests (hash-table-ref tests-draw-state 'selected-tests ))
 	 (scalef         (dcommon:estimate-scale sizex sizey originx originy dot-data)))
 
     (hash-table-set! tests-draw-state 'scalef scalef)
     
-    ;; (print "dot-data=" dot-data)
-    (hash-table-set! tests-draw-state 'xtorig xtorig)
-    (hash-table-set! tests-draw-state 'ytorig ytorig)
     (let ((longest-str   (if (null? sorted-testnames) "         " (car (sort sorted-testnames (lambda (a b)(>= (string-length a)(string-length b))))))))
       (let-values (((x-max y-max) (canvas-text-size cnv longest-str)))
 	(if (> x-max boxw)(set! boxw (+ 10 x-max)))))
     ;; (print "sizex: " sizex " sizey: " sizey " font: " (canvas-font cnv) " originx: " originx " originy: " originy " xtorig: " xtorig " ytorig: " ytorig " xadj: " xadj " yadj: " yadj)
     (if (not (null? sorted-testnames))
@@ -760,24 +783,19 @@
 		 (boxw (string->number (list-ref nodedat 4)))
 		 (boxh (string->number (list-ref nodedat 5)))
 		 (urx  (+ llx boxw))
 		 (ury  (+ lly boxh)))
 					; (print "hed " hed " llx " llx " lly " lly " urx " urx " ury " ury)
-	    (dcommon:draw-test cnv scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
-	    ;; (dcommon:draw-arrows cnv testname tests-hash test-records))
-	    (dcommon:draw-edges cnv scalef edgedat)
+	    (dcommon:draw-test cnv xoffset yoffset scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	    ;; (dcommon:draw-arrows cnv testname tests-info test-records))
+	    (dcommon:draw-edges cnv xoffset yoffset scalef edgedat)
 	    
 	    ;; data used by mouse click calc. keep the wacky order for now.
-	    (hash-table-set! tests-hash hed  (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh edgedat)) 
-	    ;; (list llx lly boxw boxh)) ;; NB// Swap ury and lly
+	    (hash-table-set! tests-info hed  (list llx lly urx ury boxw boxh edgedat)) 
 	    (if (not (null? tal))
 		(loop (car tal)
 		      (cdr tal))))))
-    ;; (for-each
-    ;;  (lambda (testname)
-    ;;    (dcommon:draw-arrows cnv testname tests-hash test-records))
-    ;;  sorted-testnames))
     ))
 
 ;; per-point-proc required, remainder optional
 ;;
 (define (dcommon:process-polyline line per-point-proc per-segment-proc last-segment-proc)
@@ -797,48 +815,36 @@
 	      (append res (per-point-proc x1 y1)))
 	    (loop (car tal)(cadr tal) x1 y1 (cddr tal) (append res (per-point-proc x1 y1)))))))
 
 (define (dcommon:redraw-tests cnv xadj yadj sizex sizey sizexmm sizeymm originx originy tests-draw-state sorted-testnames test-records)
   (let* ((scalef              (hash-table-ref tests-draw-state 'scalef))
-	 (test-browse-xoffset (hash-table-ref tests-draw-state 'test-browse-xoffset))
-	 (test-browse-yoffset (hash-table-ref tests-draw-state 'test-browse-yoffset))
-	 (xtorig              (+ test-browse-xoffset (* (/ sizex 2) (- xadj 0.5)))) ;;  (- xadj 1))))
-	 (ytorig              (+ test-browse-yoffset (* (/ sizey 2) (- 0.5 yadj))))
-	 (xdelta              (- (hash-table-ref tests-draw-state 'xtorig) xtorig))
-	 (ydelta              (- (hash-table-ref tests-draw-state 'ytorig) ytorig))
-	 (tests-hash          (hash-table-ref tests-draw-state 'tests-info))
+	 (xoffset             (dcommon:get-xoffset tests-draw-state sizex xadj))
+	 (yoffset             (dcommon:get-yoffset tests-draw-state sizey yadj))
+	 (tests-info          (hash-table-ref tests-draw-state 'tests-info))
 	 (selected-tests      (hash-table-ref tests-draw-state 'selected-tests )))
-    (hash-table-set! tests-draw-state 'xtorig xtorig)
-    (hash-table-set! tests-draw-state 'ytorig ytorig)
     (if (not (null? sorted-testnames))
 	(let loop ((hed (car (reverse sorted-testnames)))
 		   (tal (cdr (reverse sorted-testnames))))
-	  (let* ((tvals (hash-table-ref tests-hash hed))
-		 (llx   (+ xdelta (list-ref tvals 0)))
-		 (lly   (+ ydelta (list-ref tvals 4)))
-		 (boxw  (list-ref tvals 5))
-		 (boxh  (list-ref tvals 6))
+	  (let* ((tvals (hash-table-ref tests-info hed))
+		 (llx   (list-ref tvals 0))
+		 (lly   (list-ref tvals 1))
+		 (boxw  (list-ref tvals 4))
+		 (boxh  (list-ref tvals 5))
 		 (edges (map (lambda (pline)
 			       (dcommon:process-polyline pline
 							 (lambda (x1 y1)
-							   (list (+ x1 xdelta)
-								 (+ y1 ydelta)))
+							   (list x1 y1))
 							 #f #f))
-			     (list-ref tvals 7)))
+			     (list-ref tvals 6)))
 		 (urx   (+ llx boxw))
 		 (ury   (+ lly boxh)))
-	    (dcommon:draw-test cnv scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
-	    (dcommon:draw-edges cnv scalef edges)
-	    (hash-table-set! tests-hash hed (list llx urx (- sizey ury)(- sizey lly) lly boxw boxh edges))
+	    (dcommon:draw-test cnv xoffset yoffset scalef llx lly boxw boxh hed (hash-table-ref/default selected-tests hed #f))
+	    (dcommon:draw-edges cnv xoffset yoffset scalef edges)
 	    (if (not (null? tal))
 		;; leave a column of space to the right to list items
 		(loop (car tal)
 		      (cdr tal))))))))
-    ;; (for-each
-    ;;  (lambda (testname)
-    ;;    (dcommon:draw-edges cnv scalef edges)) ;; (dcommon:draw-arrows cnv testname tests-hash test-records))
-    ;;  sorted-testnames)))
 
 ;;======================================================================
 ;;  S T E P S
 ;;======================================================================