#!/bin/sh
# The next line restarts using wish \
	exec wish $0 ${1+"$@"}


proc biffUpdateBLP {} {
global no_mail_im opt

    killAfters checkMail
	.l conf -image $no_mail_im
	after $opt(biff_interval) checkMail
}

proc biffErr {} {
	global dead_mail_im opt

	.l conf -image $dead_mail_im 
	after [expr {5*$opt(biff_interval)}] checkMail
	return
}

proc killAfters {cmd} {
	foreach afters [after info] {
		foreach a $afters {
			if { [lindex [after info $a] 0] == $cmd } { after cancel $a }
		}
	}
}

proc checkMail {} {
	global no_mail_im new_mail_im opt beeped_at old_interval

	killAfters checkMail
	if { [catch {exec $opt(biff_ping) $opt(biff_mailhost) $opt(biff_pingopts)} err] } { biffErr ; return }
	# if msgchk returns 1, then no mail is unread
	if { [catch {exec $opt(biff_msgchk)} ret] } {  
		.l conf -image $no_mail_im 
		set opt(biff_interval) $old_interval
		set sz 0
		set beeped_at 0
	} else {
		scan $ret "You have %d messages" sz
		if { $opt(beep_always) } {
			if { $sz > $beeped_at } {
				bell 
				after 200 bell
				set beeped_at $sz
			}
		}
		if { [.l cget -image ] != "$new_mail_im" } {
			bell 
			after 200 bell
			.l conf -image $new_mail_im 
		}
	}
	after $opt(biff_interval) checkMail
}

proc startExmh cmd {
global Biff opt CMD

	set CMD $cmd
	set Exmh_exists 0
	foreach app_name [winfo interps] { if {$app_name == "exmh"} { set Exmh_exists 1 } }
	if { $Exmh_exists == 0  } { 
		.l conf -cursor watch
		update
		if { [ catch { eval exec $opt(biff_exmh) & } errtxt ] } { 
			BlpError $errtxt ;  return 
		}
		after 1000 {
			global CMD
			set Exmh_isup 0
			while { ! $Exmh_isup } { 
				foreach app_name [winfo interps] { if {$app_name == "exmh-bg"} { set Exmh_isup 1 } }
				after 1000
			} 
			.l conf -cursor ""
			eval $CMD
		}
		return
	}
	eval $cmd
}

proc blpUsage {op} {
	puts "invalid option: $op"
	puts "Usage: blp \[+biff\] \[+load\] \[+printQ\] \[+sensor\]"
	# Every 120 seconds (2 minutes)
	puts "	-biff_i/-biff_interval <interval between checks>  \[120000\]"
	puts "	-biff_bg/-biff_background <bg color>  \[mediumblue\]"
	puts "	-biff_ping <ping command>  \[/usr/sbin/ping\]"
	puts "	-biff_pingopts <options to ping>  \[5\]"
	puts "	-biff_exmh <exmh command>  \[/home/ddp/bin/exmh\]"
	puts "	-biff_msgchk <msgchk command>  \[/opt/local/mh/msgchk\]"
	puts "	-biff_mailhost <pop mail host>  \[mail-g.deakin.edu.au\]"
	puts "	-whoami <whoami command>  \[/opt/gnu/bin/whoami\]"
	puts "	-beep_always <boolean>  \[0\]"
	# Every 20 seconds
	puts "	-load_i/-load_interval <interval between checks>  \[20000\]"
	puts "	-load_bg/-load_background <bg color>  \[white\]"
	puts "	-load_w/-load_width <width of load window>  \[56\]"
	puts "	-load_uptime <uptime command>  \[/opt/gnu/bin/uptime\]"
	puts "	-load_xterm <xterm command>  \[/opt/X11/bin/xterm\]"
	puts "	-load_line <color of load lines>  \[black\]"
	puts "	-load_sl/load_scale_lines <color of scale lines>  \[red\]"
	puts "	-load_text_bg/-load_text_background <bg color behind text>  \[white\]"
	puts "	-load_text_col <color of text>  \[black\>"
	puts "	-print_fg/-print_foreground <bg color>  \[white\>"
	puts "	-print_bg/-print_background <bg color>  \[mediumblue\>"
	puts "	-print_play <play command>  \[/home/ddp/bin/play\]"
	puts "	-print_lpq <lpq command>  \[/usr/ucb/lpq\]"
	puts "	-print_printersfile <printersfile>  \[/etc/printers.conf\]"
	puts "	-sensor_bg/-sensor_background <bg color>  \[white\]"
	puts "	-sensor_text_bg/-sensor_text_background <bg color behind text>  \[white\]"
	puts "	-sensor_text_col <color of text>  \[black\]"
	puts "	-sensor_cpu_temp_num <temp file number>  \[1\]"
	puts "	-sensor_mb_temp_num <temp file number>  \[2\]"
	puts "	-sensor_line <color of temp lines>  \[black\]"
	puts "	-sensor_sl/sensor_scale_lines <color of scale lines>  \[red\]"
	# Every 20 seconds
	puts "	-sensor_i/-sensor_interval <interval between checks>  \[20000\]"
	puts "	-sensor_w/-sensor_width <width of sensor window>  \[56\]"
	exit 1
}

proc blpInit {} {
	global no_mail_im new_mail_im opt beeped_at old_interval auto_path
	global argc argv opt env W
	global sensor

	wm withdraw .
	wm geometry . 48x48
	set W 56
	set sensor(W) $W
	set opt(biff_interval) 120000
	set opt(biff_bg) mediumblue
	set opt(biff_ping) /usr/sbin/ping
	set opt(biff_exmh) /home/ddp/bin/exmh
	set opt(biff_mailhost) mail-g.deakin.edu.au
	set opt(biff_pingopts) 5
	set opt(biff_msgchk) /opt/local/mh/msgchk
	set opt(biff_uptime) /opt/gnu/bin/uptime
	set opt(whoami) /opt/gnu/bin/whoami
	set opt(load_interval) 20000
	set opt(load_bg) white
	set opt(load_line) black
	set opt(load_scale_line) red
	set opt(load_text_bg) white
	set opt(load_text_col) black
	set opt(load_uptime) /opt/gnu/bin/uptime
	set opt(load_xterm) /opt/X11/bin/xterm
	set opt(print_fg) white
	set opt(print_bg) mediumblue
	set opt(print_play) /home/ddp/bin/play
	set opt(print_lpq) /usr/ucb/lpq
	set opt(print_printersfile) /etc/printers.conf
	set opt(use_biff) 0
	set opt(use_load) 0
	set opt(use_printQ) 0
	set opt(use_sensor) 0
	set opt(beep_always) 0
	set opt(sensor_bg) white
	set opt(sensor_text_bg) white
	set opt(sensor_text_col) black
	set opt(sensor_cpu_temp_num) 1
	set opt(sensor_mb_temp_num) 2
	set opt(sensor_line) black
	set opt(sensor_scale_line) red
	set opt(sensor_interval) 20000

	set beeped_at 0

	for { set arg_cnt 0 } { $arg_cnt < $argc } { incr arg_cnt 1 } {
		switch -- "[lindex $argv $arg_cnt]" {
			"+biff"		{set opt(use_biff) 1 }
			"+load"		{set opt(use_load) 1}
			"+rload"	{incr arg_cnt ; set rload([lindex $argv $arg_cnt]) "" }
			"+printQ"	{set opt(use_printQ) 1}
			"+sensor"	{set opt(use_sensor) 1}
			"-biff_interval" -
			"-biff_i"	{ incr arg_cnt ; set opt(biff_interval) [lindex $argv $arg_cnt] }
			"-biff_bg" -
			"-biff_background" { incr arg_cnt ; set opt(biff_bg) [lindex $argv $arg_cnt] }
			"-biff_ping" { incr arg_cnt ; set opt(biff_ping) [lindex $argv $arg_cnt] }
			"-biff_pingopts" { incr arg_cnt ; set opt(biff_pingopts) [lindex $argv $arg_cnt] }
			"-biff_exmh" { incr arg_cnt ; set opt(biff_exmh) [lindex $argv $arg_cnt] }
			"-biff_mailhost" { incr arg_cnt ; set opt(biff_mailhost) [lindex $argv $arg_cnt] }
			"-biff_msgchk" { incr arg_cnt ; set opt(biff_msgchk) [lindex $argv $arg_cnt] }
			"-whoami" { incr arg_cnt ; set opt(whoami) [lindex $argv $arg_cnt] }
			"-beep_always"	{ incr arg_cnt ; set opt(beep_always) [lindex $argv $arg_cnt] }
			"-load_interval" -
			"-load_i"	{ incr arg_cnt ; set opt(load_interval) [lindex $argv $arg_cnt] }
			"-load_width" -
			"-load_w"	{ incr arg_cnt ; set W [lindex $argv $arg_cnt] }
			"-load_bg" -
			"-load_background" { incr arg_cnt ; set opt(load_bg) [lindex $argv $arg_cnt] }
			"-load_line"		{ incr arg_cnt ; set opt(load_line) [lindex $argv $arg_cnt] }
			"-load_sl" -
			"-load_scale_line" { incr arg_cnt ; set opt(load_scale_line) [lindex $argv $arg_cnt] }
			"-load_text_bg" -
			"-load_text_background" { incr arg_cnt ; set opt(load_text_bg) [lindex $argv $arg_cnt] }
			"-load_text_col" { incr arg_cnt ; set opt(load_text_col) [lindex $argv $arg_cnt] }
			"-load_uptime" { incr arg_cnt ; set opt(load_uptime) [lindex $argv $arg_cnt] }
			"-load_xterm" { incr arg_cnt ; set opt(load_xterm) [lindex $argv $arg_cnt] }
			"-print_fg" -
			"-print_foreground" { incr arg_cnt ; set opt(print_fg) [lindex $argv $arg_cnt] }
			"-print_bg" -
			"-print_background" { incr arg_cnt ; set opt(print_bg) [lindex $argv $arg_cnt] }
			"-print_play" { incr arg_cnt ; set opt(print_play) [lindex $argv $arg_cnt] }
			"-print_lpq" { incr arg_cnt ; set opt(print_lpq) [lindex $argv $arg_cnt] }
			"-print_printersfile" { incr arg_cnt ; set opt(print_printersfile) [lindex $argv $arg_cnt] }
			"-sensor_bg" -
			"-sensor_background" { incr arg_cnt ; set opt(sensor_bg) [lindex $argv $arg_cnt] }
			"-sensor_text_bg" -
			"-sensor_text_background" { incr arg_cnt; set opt(sensor_text_bg) [lindex $argv $arg_cnt] }
			"-sensor_text_col" { incr arg_cnt; set opt(sensor_text_col) [lindex $argv $arg_cnt] }
			"-sensor_cpu_temp_num" { incr arg_cnt; set opt(sensor_cpu_temp_num) [lindex $argv $arg_cnt] }
			"-sensor_mb_temp_num" { incr arg_cnt; set opt(sensor_mb_temp_num) [lindex $argv $arg_cnt] }
			"-sensor_line" { incr arg_cnt ; set opt(sensor_line) [lindex $argv $arg_cnt] }
			"-sensor_scale_line" { incr arg_cnt ; set opt(sensor_scale_line) [lindex $argv $arg_cnt] }
			"-sensor_interval" -
			"-sensor_i"	{ incr arg_cnt ; set opt(sensor_interval) [lindex $argv $arg_cnt] }
			"-sensor_width" -
			"-sensor_w"	{ incr arg_cnt ; set sensor(W) [lindex $argv $arg_cnt] }
			default { blpUsage [lindex $argv $arg_cnt] }
		}
	}
	foreach a [array names rload] {
		puts "rload - $a"
	}

	if { [expr {$opt(use_biff) + $opt(use_load) + $opt(use_printQ) + $opt(use_sensor)}] == 0} {
		blpUsage "No component loaded - must +biff/+load/+printQ/+sensor"
	}
	if { $opt(use_biff) || $opt(use_printQ) } {
		package require Img
	}
	# Setting up vars to validate (NB: Usually external commands to exec)
	set vars "whoami"
	if { $opt(use_biff) } {
		 append vars " biff_ping biff_exmh biff_msgchk"
	}
	if { $opt(use_load) } {
		append vars " load_uptime load_xterm"
	}
	if { $opt(use_printQ) } {
		append vars " print_play print_lpq"
	}
	foreach var $vars {
		if { ! [file exists $opt($var)] } {
			puts stderr "FATAL: the option -$var points to an invalid executable file: '$opt($var)'"
			exit -1
		}
	}
	if { [catch { exec $opt(whoami) } opt(user) ] } {
		puts stderr "FATAL: Failed to find out who you are: $opt(user)"
		exit -1
	}
	if { $opt(use_printQ) } { wm title . printQ }
	if { $opt(use_load) } { wm title . load }
	if { $opt(use_sensor) } { wm title . sensor }
	if { $opt(use_biff) } { wm title . biff }
}

proc biffInit {} {
	global no_mail_im new_mail_im opt dead_mail_im beeped_at old_interval auto_path
	global argc argv opt env

	if { [wm title .] != "biff" } {
		set print_win_ ".biff."
		set print_win ".biff"
		toplevel $biff_win
		wm withdraw $biff_win
	} else {
		set biff_win "."
		set biff_win_ "."
	}
	set job_on ""

	set old_interval $opt(biff_interval)

	set no_mail_im [image create pixmap -file /home/chrismc/lib/blp/biffno.xpm]
	set new_mail_im [image create pixmap -file /home/chrismc/lib/blp/biffnew.xpm]
	set dead_mail_im [image create pixmap -file /home/chrismc/lib/blp/biffdead.xpm]

	. conf -bg $opt(biff_bg)
	label .l -image $no_mail_im -bd 0 -bg $opt(biff_bg)
	grid .l -sticky nsew
	bind . <1> { startExmh checkMail }
	bind . <2> { startExmh "send exmh Msg_Compose" }
	bind . <3> { startExmh {send exmh Inc_Show ; send exmh "wm deiconify ." ; set old_interval $opt(biff_interval) ; set opt(biff_interval) 30000 ; after 20000 checkMail} }

	checkMail

	wm deiconify $biff_win
}

proc recalc_max_load {} {
	global max_load load_val W

	set max_load $load_val(0)
	for {set i 1} {$i <= $W} {incr i} {
		if { ! [info exists load_val($i) ] } {
			return
		}
		if { $max_load < $load_val($i) } {
			set max_load $load_val($i)
		}
		set load_val([expr {$i-1}]) $load_val($i)
	}
}

proc newLimit {dir} {
	global top H W opt max_load load_win_

	${load_win_}c delete load_limits

	if { $dir == 2 } {
		${load_win_}c scale load_line 0 $H 1 0.5 
	} else {
		${load_win_}c scale load_line 0 $H 1 2 
	}
		
	set top [expr {$top*$dir}]
	for { set i 1 } {$i < $top } {incr i } {
		${load_win_}c create line 0 [expr {$H/$top*$i}] $W [expr {$H/$top*$i}] \
			-tag load_limits -fill $opt(load_scale_line)
	}
	recalc_max_load
}

proc drawLoad {} {
	global x top H W opt max_load load_val load_win_ crud

	if { [catch {exec $opt(load_uptime)} s] } { return }
	set load [string trim [lindex $s [expr {[llength $s] - 3}]] ,]

#	incr crud
#	if { $x < $W-2 } {
#		set load 0.3
#	} else {
#		if { $crud < 80 } {
#			set load 1.5
#		} else {
#			set load 0.5
#		}
#	}

	set load_val($x) $load
	${load_win_}l conf -text $load

	while { $load > $top } { newLimit 2 }
	while { $top > 1 && $max_load < [expr {$top/2}] } {newLimit 0.5}
	if { $x == $W } {
		${load_win_}c move load_line -1 0
		set old_line [${load_win_}c find closest -1 $H 0 load_line]
		${load_win_}c delete $old_line
		incr x -1
		recalc_max_load
	}

	${load_win_}c create line $x $H $x [expr {$H - ($load/$top*$H)}] -tags load_line -fill $opt(load_line) -fill $opt(load_line)
	${load_win_}c raise load_limits
	incr x
	update
	after $opt(load_interval) drawLoad
#	puts "crud=$crud, x=$x, load=$load, top=$top"
#	gets stdin
#	drawLoad
}

proc loadInit {} {
	global W H top x opt argc argv max_load load_win_ crud

	set crud 0
	if { [wm title .] != "load" } {
		set load_win_ ".load."
		set load_win ".load"
		toplevel $load_win
		wm withdraw $load_win
	} else {
		set load_win_ "."
		set load_win "."
	}
	set H 40
	wm geometry $load_win [expr {$W+2}]x[expr {$H+20}]

	set top 1.0
	set x 0

	$load_win conf -bd 0 -highlightthickness 0 -bg $opt(load_bg)
	canvas ${load_win_}c -bg $opt(load_bg) -bd 0 -width $W -height $H -highlightthickness 0
	label ${load_win_}l -bd 1 -font fixed -highlightthickness 1 -relief sunken \
		-bg $opt(load_text_bg) -highlightbackground $opt(load_text_bg) -fg $opt(load_text_col)
	grid ${load_win_}c
	grid ${load_win_}l

	set max_load 0
	bind $load_win <1> { 
		if { [catch {eval exec $opt(load_xterm) -T top -n top -e top & } err] } {
			puts stderr "Failed to start an xterm: $err"
		}
	}
	drawLoad

	wm deiconify $load_win
}

proc sensorInit {} {
global opt sensor W

	# Only create a toplevel window if there isn't one already with the correct title
	if { [wm title .] != "sensor" } {
		set sensor(win_) ".sensor."
		set sensor(win) ".sensor"
		toplevel $sensor(win)
		wm withdraw $sensor(win)
	} else {
		set sensor(win_) "."
		set sensor(win) "."
	}
	set sensor(H) 40
	wm geometry $sensor(win) [expr {$sensor(W)+2}]x[expr {$sensor(H)+20}]

	set sensor(cpu_x) 0
	set sensor(cpu_top) 50.0
	set sensor(mb_x) 0
	set sensor(mb_top) 50.0

	$sensor(win) conf -bd 0 -highlightthickness 0 -bg $opt(sensor_bg)
	canvas ${sensor(win_)}c -bg $opt(sensor_bg) -bd 0 -width $sensor(W) -height $sensor(H) -highlightthickness 0
	label ${sensor(win_)}l -bd 1 -highlightthickness 1 -relief sunken \
		-bg $opt(sensor_text_bg) -highlightbackground $opt(sensor_text_bg) \
		-fg $opt(sensor_text_col) -font {-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso8859-1} 
	grid ${sensor(win_)}c -sticky ew
	grid ${sensor(win_)}l -sticky ew

	set sensor(max_cpu_temp) 0
	set sensor(max_mb_temp) 0
	bind $sensor(win) <1> {
		tk_dialog .dialog {Meaning of lines} {The left hand number is the CPU temperature and the right hand number is the MB temperature.  Generally the top line will be the CPU temperature and the bottom the MB temperature, but wierder things have been known to happen!} info 0 OK
	}

	# Now find the sensor chip!
	set sensor(sensor_dir) [file join /proc sys dev sensors]
	if { [file exists $sensor(sensor_dir)] } {
		set sensor(sensor_cpu_temp_file) [glob -join /proc sys dev sensors * temp$opt(sensor_cpu_temp_num)]
		set sensor(sensor_mb_temp_file) [glob -join /proc sys dev sensors * temp$opt(sensor_mb_temp_num)]
	} else {
		BlpError "Can't find sensors directory in /proc file system"
		destroy $sensor(win)
		return
	}

	# Draw the 15, 20, 25, 30, 35 and 40 degree lines
	# NB: Lines are in reverse. 0,0 is the top left, so the lines are going down!
	set dash_pat .
	set y [expr {$sensor(H) - (15/$sensor(cpu_top)*$sensor(H))}]
	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
#	set y [expr {$sensor(H) - (20/$sensor(cpu_top)*$sensor(H))}]
#	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
	set y [expr {$sensor(H) - (25/$sensor(cpu_top)*$sensor(H))}]
	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
#	set y [expr {$sensor(H) - (30/$sensor(cpu_top)*$sensor(H))}]
#	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
	set y [expr {$sensor(H) - (35/$sensor(cpu_top)*$sensor(H))}]
	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
#	set y [expr {$sensor(H) - (40/$sensor(cpu_top)*$sensor(H))}]
#	${sensor(win_)}c create line 0 $y $sensor(W) $y -tag sensor_limits -fill $opt(sensor_scale_line) -dash $dash_pat
	set opt(sensor_line,41) red
	set opt(sensor_line,40) orange
	set opt(sensor_line,39) yellow
	set opt(sensor_line,35) green
	set opt(sensor_line,30) blue
	drawTemp

	wm deiconify $sensor(win)
}

proc sensor_read { sensor_file } {
	if { [catch {open $sensor_file r} f] } {
		BlpError $f
		return
	}
	set val [read $f]
	close $f
	return $val
}

proc drawTemp {} {
global opt sensor

	set cpu_temp [sensor_read $sensor(sensor_cpu_temp_file)]
	set mb_temp [sensor_read $sensor(sensor_mb_temp_file)]

	if { ![regexp {[0-9]+\.[0-9]\s([0-9]+\.[0-9])\s([0-9]+\.[0-9])} $cpu_temp m sensor(cpu_top) sensor(curr_cpu_temp)] } {
		BlpError "regexp for temperature didn't work :("
		return
	}
	if { ![regexp {[0-9]+\.[0-9]\s([0-9]+\.[0-9])\s([0-9]+\.[0-9])} $mb_temp m sensor(mb_top) sensor(curr_mb_temp)] } {
		BlpError "regexp for temperature didn't work :("
		return
	}

	set sensor(cpu_val,$sensor(cpu_x)) $sensor(curr_cpu_temp)
	set sensor(mb_val,$sensor(mb_x)) $sensor(curr_mb_temp)
	${sensor(win_)}l conf -text "$sensor(curr_cpu_temp)°   $sensor(curr_mb_temp)°"

	set sensor(curr_cpu_temp) [format %.1f [expr ($sensor(curr_cpu_temp)-30)*3 ]]
	set sensor(curr_mb_temp) [format %.1f [expr ($sensor(curr_mb_temp)-30)*3 ]]

#	while { $sensor(curr_cpu_temp) > $sensor(cpu_top) } { newSensorLimit 2 cpu }
#	while { $sensor(cpu_top) > 1 && $sensor(max_temp) < [expr {$sensor(cpu_top)/2}] } {newSensorLimit 0.5 cpu }
	# If we have reached the RHS then move the lines to the left by 1 pixel.
	if { $sensor(cpu_x) == $sensor(W) } {
		move_line cpu
	}
	if { $sensor(mb_x) == $sensor(W) } {
		move_line mb
	}

	draw_line cpu
	draw_line mb

	${sensor(win_)}c raise sensor_limits
	incr sensor(cpu_x)
	incr sensor(mb_x)
	update
	after $opt(sensor_interval) drawTemp
}

proc move_line { what } {
global sensor

		${sensor(win_)}c move sensor_${what}_line -1 0
		# Didn't seem to find the correct "line" to select
#		set old_line [${sensor(win_)}c find closest -1 $sensor(H) 0 sensor_${what}_line]
		set old_line [${sensor(win_)}c find overlapping -1 $sensor(H) -1 [expr {$sensor(H) - ($sensor(curr_${what}_temp)/$sensor(${what}_top)*$sensor(H))}]]
		${sensor(win_)}c delete $old_line
		incr sensor(${what}_x) -1
		recalc_max_temp ${what}
}

proc draw_line { what } {
global opt sensor

	# Changed to draw a horizontal line
	set x $sensor(${what}_x)
	set y [expr {$sensor(H) - ($sensor(curr_${what}_temp)/$sensor(${what}_top)*$sensor(H))}]
	if { $x > 0 } {
		if { $sensor(${what}_val,$sensor(${what}_x)) > 40 } {
			set col $opt(sensor_line,40)
		} elseif { $sensor(${what}_val,$sensor(${what}_x)) > 35 } {
			set col $opt(sensor_line,35)
		} elseif { $sensor(${what}_val,$sensor(${what}_x)) > 30 } {
			set col $opt(sensor_line,30)
		} elseif { $sensor(${what}_val,$sensor(${what}_x)) > 25 } {
			set col $opt(sensor_line,25)
		} elseif { $sensor(${what}_val,$sensor(${what}_x)) > 20 } {
			set col $opt(sensor_line,20)
		} else {
			set col $opt(sensor_line)
		}
		${sensor(win_)}c create line [expr $x - 1] $sensor(y_${what}_prev) $x $y -tags sensor_${what}_line -fill $opt(sensor_line) -fill $col
	}
	set sensor(y_${what}_prev) [expr {$sensor(H) - ($sensor(curr_${what}_temp)/$sensor(${what}_top)*$sensor(H))}]
}

proc newSensorLimit {dir what} {
global opt sensor

	${sensor(win_)}c delete sensor_limits

	if { $dir == 2 } {
		${sensor(win_)}c scale sensor_${what}_line 0 $sensor(H) 1 0.5 
	} else {
		${sensor(win_)}c scale sensor_${what}_line 0 $sensor(H) 1 2 
	}
		
	set sensor(${what}_top) [expr {$sensor(${what}_top)*$dir}]
	# Scale lines
	for { set i 1 } { $i < $sensor(${what}_top) } { incr i } {
		${sensor(win_)}c create line 0 [expr {$sensor(H)/$sensor(${what}_top)*$i}] $sensor(W) [expr {$sensor(H)/$sensor(${what}_top)*$i}] \
			-tag sensor_limits -fill $opt(sensor_scale_line)
	}
	recalc_max_temp $what
}

proc recalc_max_temp { what } {
global sensor

	set sensor(max_${what}_temp) $sensor(${what}_val,0)
	for {set i 1} {$i <= $sensor(W)} {incr i} {
		if { ! [info exists sensor(${what}_val,$i) ] } {
			return
		}
		if { $sensor(max_${what}_temp) < $sensor(${what}_val,$i) } {
			set sensor(max_${what}_temp) $sensor(${what}_val,$i)
		}
		set sensor(${what}_val,[expr {$i-1}]) $sensor(${what}_val,$i)
	}
}

proc printSuccess {} {
	global opt printer job_on tries checks
	global emp_im print_win_ OLD

	set OLD 0
	${print_win_}toplab conf -text "Job Done!"
	if { [catch {eval exec $opt(print_play) /home/chrismc/lib/cricket/woohoo.au &} err] } {
		puts stderr "Failed to start an xterm: $err"
		return;
	}
	killAfters checkQ
	${print_win_}pic conf -image $emp_im
}

proc checkQ {} {
	global opt printer job_on tries checks OLD
	global dead_print_im emp_im full_im print_win_ first_job

	incr tries
	if { $tries == 5 } {
		${print_win_}toplab conf -text "Timed Out"
		return
	}
	killAfters checkQ

	if { [catch { exec $opt(print_lpq) -P$printer } result] } {
		${print_win_}pic conf -image $dead_print_im
		after 3000 checkQ
		return
	}
	set valid_line 0
	catch {
		unset first_job
		unset NEW
	}
	foreach line [split [string trim $result "\n"] "\n"] {
		if { [regexp -- "^-+" $line m] } {
			set valid_line 1
			continue
		} elseif { $valid_line } {
			scan [string range $line 0 12] "%s" owner
			scan [string range $line 12 28] "%s" status
			scan [string range $line 45 55] "%d" job
			if { $opt(user) == $owner } {
				set NEW($job) $valid_line
				set job_on $printer
				if { ![info exists first_job] } { 
					set first_job $valid_line 
					if { $valid_line == "1" } {
						if { $status == "Printing" } { set first_job "active" }
					}
				}
				set last_job $valid_line
			}
			incr valid_line
		}
	}

	${print_win_}toplab conf -text ""
	if { [array exists NEW] } {
		${print_win_}pic conf -image $full_im
		if { [array size NEW] == 1 } {
			${print_win_}toplab conf -text "job $first_job"
		} else {
			${print_win_}toplab conf -text "1st: $first_job\nLast: $last_job"
		}
		set tries 0
	} else {
		if { $OLD && $job_on == $printer } {
			printSuccess
			return
		}
		${print_win_}toplab conf -text "Check $checks"
		${print_win_}pic conf -image $emp_im
	}

	after 3000 checkQ

	if { [array exists NEW] } { set OLD 1 }
	incr checks
	update
}

proc createMenu {} {
	global printer print_win_ dead_print_im opt

	menu ${print_win_}m -tearoff 0
	${print_win_}m add command -label "Hide Menu" -command { ${print_win_}m unpost }
	${print_win_}m add separator
	if { [catch { open $opt(print_printersfile) r } f ] } {
		puts stderr "failed to get list of printers: $f"
		${print_win_}pic conf -image $dead_print_im
		return
	}
	set data [read $f]
	close $f
	foreach pr [ split $data "\n" ] {
		if { [ regexp {(^[^:\t ]+):} $pr m pn ] == 1 } {
			${print_win_}m add radiobutton -label $pn -variable printer
		}
	}
}

proc printerChanged {name element type} {
	global print_win_

	upvar $name x
	set tmp [string range $x 3 end]
	if { [string length $tmp] > 7 } {
		set tmp [string range $tmp 0 7]
		${print_win_}l conf -text "$tmp"
	} else {
		${print_win_}l conf -text "$tmp"
	}
}

proc Menu {} {
	global print_win_ print_win

	if { [winfo ismapped ${print_win_}m] } {
		${print_win_}m unpost
	} else {
		${print_win_}m post [expr {[winfo rootx $print_win]+20}] [winfo rooty $print_win]
	}
}

proc printQInit {} {
	global env auto_path printer job_on opt OLD
	global dead_print_im emp_im full_im print_win_ print_win

	if { [wm title .] != "sensor" } {
		set print_win_ ".printQ."
		set print_win ".printQ"
		toplevel $print_win
		wm withdraw $print_win
	} else {
		set print_win "."
		set print_win_ "."
	}
	set job_on ""
	set printer "cm_lw"
	set OLD 0
	trace variable printer w printerChanged
	set emp_im [image create pixmap -file /home/chrismc/lib/blp/print_emp.xpm]
	set full_im [image create pixmap -file /home/chrismc/lib/blp/print_full.xpm]
	set dead_print_im [image create pixmap -file /home/chrismc/lib/blp/print_dead.xpm]
	label ${print_win_}toplab -text "" -font "*-r-*--10-*" -highlightthickness 0 -bd 0 \
		-fg $opt(print_fg) -bg $opt(print_bg)
	label ${print_win_}pic -image $emp_im -highlightthickness 0 -bd 0 -bg $opt(print_bg)
	label ${print_win_}l -text "lw" -font "*-r-*--10-*" -highlightthickness 0 -bd 0 \
		-fg $opt(print_fg) -bg $opt(print_bg)
	grid ${print_win_}toplab -sticky nsew
	grid ${print_win_}pic -sticky nsew
	grid ${print_win_}l -sticky nsew
	grid columnconfigure $print_win 0 -weight 1
	grid rowconfigure $print_win 0 -weight 1
	grid rowconfigure $print_win 1 -weight 1
	grid rowconfigure $print_win 2 -weight 1

	createMenu
	bind $print_win <1> { 
		${print_win_}toplab conf -text ""
		set checks 0 
		set tries 0
		checkQ 
	}
	bind $print_win <3> Menu
	bind $print_win <2> { 
		killAfters checkQ
		${print_win_}toplab conf -text ""
		${print_win_}pic conf -image $emp_im
	}
	wm deiconify $print_win
}

proc BlpError {str} { tk_dialog .d {Blp Error} "$str" error 0 "OK" }

blpInit
if { $opt(use_biff) } { biffInit }
if { $opt(use_load) } { loadInit }
if { $opt(use_printQ) } { printQInit }
if { $opt(use_sensor) } { sensorInit }