@@ -128,10 +128,11 @@
 (define *please-update-buttons* #t)
 (define *delayed-update* 0)
 (define *update-is-running* #f)
 (define *update-mutex* (make-mutex))
 
+(define *all-item-test-names* '())
 (define *num-tests*     15)
 (define *start-run-offset*  0)
 (define *start-test-offset* 0)
 (define *examine-test-dat* (make-hash-table))
 (define *exit-started* #f)
@@ -138,11 +139,28 @@
 (define *status-ignore-hash* (make-hash-table))
 (define *state-ignore-hash*  (make-hash-table))
 
 (define *db-file-path* (conc *toppath* "/megatest.db"))
 
-(define *tests-sort-reverse* #f)
+(define *tests-sort-options* (vector (vector "Sort +a" 'testname   "ASC")
+				     (vector "Sort -a" 'testname   "DESC")
+				     (vector "Sort +t" 'event_time "ASC")
+				     (vector "Sort -t" 'event_time "DESC")
+				     (vector "Sort +s" 'statestatus "ASC")
+				     (vector "Sort -s" 'statestatus "DESC")))
+
+;; Don't forget to adjust the >= below if you add to the sort-options above
+(define (next-sort-option)
+  (if (>= *tests-sort-reverse* 5)
+      (set! *tests-sort-reverse* 0)
+      (set! *tests-sort-reverse* (+ *tests-sort-reverse* 1)))
+  *tests-sort-reverse*)
+
+(define (get-curr-sort)
+  (vector-ref *tests-sort-options* *tests-sort-reverse*))
+
+(define *tests-sort-reverse* 3)
 (define *hide-empty-runs* #f)
 
 (define *current-tab-number* 0)
 (define *updaters* (make-hash-table))
 
@@ -152,11 +170,10 @@
 
 (define-inline (dboard:uidat-get-keycol  vec)(vector-ref vec 0))
 (define-inline (dboard:uidat-get-lftcol  vec)(vector-ref vec 1))
 (define-inline (dboard:uidat-get-header  vec)(vector-ref vec 2))
 (define-inline (dboard:uidat-get-runsvec vec)(vector-ref vec 3))
-
 
 (define (message-window msg)
   (iup:show
    (iup:dialog
     (iup:vbox 
@@ -175,12 +192,12 @@
     i))
 
 (define (pad-list l n)(append l (make-list (- n (length l)))))
 
 (define (colors-similar? color1 color2)
-  (let* ((c1 (map string->number (string-split color1)))
-	 (c2 (map string->number (string-split color2)))
+  (let* ((c1    (map string->number (string-split color1)))
+	 (c2    (map string->number (string-split color2)))
 	 (delta (map (lambda (a b)(abs (- a b))) c1 c2)))
     (null? (filter (lambda (x)(> x 3)) delta))))
 
 ;; keypatts: ( (KEY1 "abc%def")(KEY2 "%") )
 (define (update-rundat runnamepatt numruns testnamepatt keypatts)
@@ -190,19 +207,26 @@
 	 (header      (db:get-header allruns))
 	 (runs        (db:get-rows   allruns))
 	 (result      '())
 	 (maxtests    0)
 	 (states      (hash-table-keys *state-ignore-hash*))
-	 (statuses    (hash-table-keys *status-ignore-hash*)))
+	 (statuses    (hash-table-keys *status-ignore-hash*))
+	 (sort-info   (get-curr-sort))
+	 (sort-by     (vector-ref sort-info 1))
+	 (sort-order  (vector-ref sort-info 2))
+	 (bubble-type (if (member sort-order '(testname))
+			  'testname
+			  'itempath)))
     ;; 
     ;; trim runs to only those that are changing often here
     ;; 
     (for-each (lambda (run)
-		(let* ((run-id   (db:get-value-by-header run header "id"))
-		       (tests    (let ((tsts (mt:get-tests-for-run run-id testnamepatt states statuses)))
-				   (if *tests-sort-reverse* (reverse tsts) tsts)))
-		       (key-vals (cdb:remote-run db:get-key-vals #f run-id)))
+		(let* ((run-id      (db:get-value-by-header run header "id"))
+		       (tests    (mt:get-tests-for-run run-id testnamepatt states statuses sort-by: sort-by sort-order: sort-order))
+		       ;; NOTE: bubble-up also sets the global *all-item-test-names*
+		       ;; (tests       (bubble-up tmptests priority: bubble-type))
+		       (key-vals    (cdb:remote-run db:get-key-vals #f run-id)))
 		  ;; Not sure this is needed?
 		  (set! referenced-run-ids (cons run-id referenced-run-ids))
 		  (if (> (length tests) maxtests)
 		      (set! maxtests (length tests)))
 		  (if (or (not *hide-empty-runs*) ;; this reduces the data burden when set
@@ -249,36 +273,35 @@
 	       (vector-set! res 1 (car (string-split (cadr splst) ")"))))
 	   res))
        lst))
 
 (define (collapse-rows inlst)
-  (let* ((newlst (filter (lambda (x)
-			  (let* ((tparts    (string-split x "("))
-				 (basetname (if (null? tparts) x (car tparts))))
+  (let* ((sort-info   (get-curr-sort))
+	 (sort-by     (vector-ref sort-info 1))
+	 (sort-order  (vector-ref sort-info 2))
+	 (bubble-type (if (member sort-order '(testname))
+			  'testname
+			  'itempath))
+	 (newlst      (filter (lambda (x)
+				(let* ((tparts    (string-split x "("))
+				       (basetname (if (null? tparts) x (car tparts))))
 					;(print "x " x " tparts: " tparts " basetname: " basetname)
-			    (cond
-			     ((string-match blank-line-rx x) #f)
-			     ((equal? x basetname) #t)
-			     ((hash-table-ref/default *collapsed* basetname #f) 
+				  (cond
+				   ((string-match blank-line-rx x) #f)
+				   ((equal? x basetname) #t)
+				   ((hash-table-ref/default *collapsed* basetname #f) 
 					;(print "Removing " basetname " from items")
-			      #f)
-			     (else #t))))
-			inlst))
-	 (vlst  (run-item-name->vectors newlst))
-	 ;; sort by second field
-	 (vlst-s1 (sort vlst (lambda (a b)
-			       (let ((astr (vector-ref a 1))
-				     (bstr (vector-ref b 1)))
-				 (if (string=? astr "") #f #t)))))
-			;; (>= (string-length (vector-ref a 1))(string-length (vector-ref b 1))))))
-	 (vlst-s2 (sort vlst-s1 (lambda (a b)
-			   	  (string>= (vector-ref a 0)(vector-ref b 0))))))
+				    #f)
+				   (else #t))))
+			      inlst))
+	 (vlst         (run-item-name->vectors newlst))
+	 (vlst2        (bubble-up vlst priority: bubble-type)))
     (map (lambda (x)
 	   (if (equal? (vector-ref x 1) "")
 	       (vector-ref x 0)
 	       (conc (vector-ref x 0) "(" (vector-ref x 1) ")")))
-	 vlst-s2)))
+	 vlst2)))
     
 (define (update-labels uidat)
   (let* ((rown    0)
 	 (keycol  (dboard:uidat-get-keycol uidat))
 	 (lftcol  (dboard:uidat-get-lftcol uidat))
@@ -302,10 +325,66 @@
 	      (iup:attribute-set! lbl "TITLE" munged-val)))
 	(iup:attribute-set! lbl "FGCOLOR" (if (hash-table-ref/default *collapsed* newval #f) "0 112 112" "0 0 0"))
 	(if (< i maxn)
 	    (loop (+ i 1)))))))
 
+;; 
+(define (get-itemized-tests test-dats)
+  (let ((tnames '()))
+    (for-each (lambda (tdat)
+		(let ((tname (vector-ref tdat 0))  ;; (db:test-get-testname tdat))
+		      (ipath (vector-ref tdat 1))) ;; (db:test-get-item-path tdat)))
+		  (if (not (equal? ipath ""))
+		      (if (not (member tname tnames))
+			  (set! tnames (append tnames (list tname)))))))
+	      test-dats)))
+
+;; Bubble up the top tests to above the items, collect the items underneath
+;; all while preserving the sort order from the SQL query as best as possible.
+;;
+(define (bubble-up test-dats #!key (priority 'itempath))
+  (if (null? test-dats)
+      test-dats
+      (begin
+	(let* ((tnames   '())                ;; list of names used to reserve order
+	       (tests    (make-hash-table))  ;; hash of lists, used to build as we go
+	       (itemized (get-itemized-tests test-dats)))
+	  (for-each 
+	   (lambda (testdat)
+	     (let* ((tname (vector-ref testdat 0))  ;; db:test-get-testname testdat))
+		    (ipath (vector-ref testdat 1))) ;; db:test-get-item-path testdat)))
+	       ;;   (seen  (hash-table-ref/default tests tname #f)))
+	       (if (not (member tname tnames))
+		   (if (or (and (eq? priority 'itempath)
+				(not (equal? ipath "")))
+			   (and (eq? priority 'testname)
+				(equal? ipath ""))
+			   (not (member tname itemized)))
+		       (set! tnames (append tnames (list tname)))))
+	       (if (equal? ipath "")
+		   ;; This a top level, prepend it
+		   (hash-table-set! tests tname (cons testdat (hash-table-ref/default tests tname '())))
+		   ;; This is item, append it
+		   (hash-table-set! tests tname (append (hash-table-ref/default tests tname '())(list testdat))))))
+	   test-dats)
+	  ;; Set all tests with items 
+	  (set! *all-item-test-names* (append (if (null? tnames)
+						  '()
+						  (filter (lambda (tname)
+							    (let ((tlst (hash-table-ref tests tname)))
+							      (and (list tlst)
+								   (> (length tlst) 1))))
+							  tnames))
+					      *all-item-test-names*))
+	  (let loop ((hed (car tnames))
+		     (tal (cdr tnames))
+		     (res '()))
+	    (let ((newres (append res (hash-table-ref tests hed))))
+	      (if (null? tal)
+		  newres
+		  (loop (car tal)(cdr tal) newres))))))))
+      
 (define (update-buttons uidat numruns numtests)
   (let* ((runs        (if (> (length *allruns*) numruns)
 			  (take-right *allruns* numruns)
 			  (pad-list *allruns* numruns)))
 	 (lftcol      (dboard:uidat-get-lftcol uidat))
@@ -1091,28 +1170,36 @@
 	      ;;  		      (mark-for-update)
 	      ;;  		      (update-search "item-name" val))
 	      ))
 	    (iup:vbox
 	     (iup:hbox
-	      (iup:button "Sort" #:action (lambda (obj)
-					    (set! *tests-sort-reverse* (not *tests-sort-reverse*))
-					    (iup:attribute-set! obj "TITLE" (if *tests-sort-reverse* "+Sort" "-Sort"))
-					    (mark-for-update)))
+	      (iup:button "Sort -t"   #:action (lambda (obj)
+						 (next-sort-option)
+						 (iup:attribute-set! obj "TITLE" (vector-ref (vector-ref *tests-sort-options* *tests-sort-reverse*) 0))
+						 (mark-for-update)))
 	      (iup:button "HideEmpty" #:action (lambda (obj)
 						 (set! *hide-empty-runs* (not *hide-empty-runs*))
 						 (iup:attribute-set! obj "TITLE" (if *hide-empty-runs* "+Hide" "-Hide"))
-						 (mark-for-update)))
-	      (iup:button "Refresh"   #:action (lambda (obj)
 						 (mark-for-update))))
 	     (iup:hbox
-	      (iup:button "Quit" #:action (lambda (obj)(if *db* (sqlite3:finalize! *db*))(exit)))
-	      (iup:button "Monitor" #:action (lambda (obj)(system (conc (car (argv))" -guimonitor &")))))
-	     ))
-	   ;; (iup:button "<-  Left" #:action (lambda (obj)(set! *start-run-offset*  (+ *start-run-offset* 1))))
-	   ;; (iup:button "Up     ^" #:action (lambda (obj)(set! *start-test-offset* (if (> *start-test-offset* 0)(- *start-test-offset* 1) 0))))
-	   ;; (iup:button "Down   v" #:action (lambda (obj)(set! *start-test-offset* (if (>= *start-test-offset* (length *alltestnamelst*))(length *alltestnamelst*)(+ *start-test-offset* 1)))))
-	   ;; (iup:button "Right ->" #:action (lambda (obj)(set! *start-run-offset*  (if (> *start-run-offset* 0)(- *start-run-offset* 1) 0))))
+	      (iup:button "Quit"      #:action (lambda (obj)(if *db* (sqlite3:finalize! *db*))(exit)))
+	      (iup:button "Refresh"   #:action (lambda (obj)
+						 (mark-for-update)))
+	      (iup:button "Collapse"  #:action (lambda (obj)
+						 (let ((myname (iup:attribute obj "TITLE")))
+						   (if (equal? myname "Collapse")
+						       (begin
+							 (for-each (lambda (tname)
+								     (hash-table-set! *collapsed* tname #t))
+								   *all-item-test-names*)
+							 (iup:attribute-set! obj "TITLE" "Expand"))
+						       (begin
+							 (for-each (lambda (tname)
+								     (hash-table-delete! *collapsed* tname))
+								   (hash-table-keys *collapsed*))
+							 (iup:attribute-set! obj "TITLE" "Collapse"))))
+						 (mark-for-update))))))
 	   (iup:frame 
 	    #:title "hide"
 	    (iup:vbox
 	     (apply 
 	      iup:hbox