vars.tcl

# de1 internal state live variables
package provide de1_vars 1.2

package require lambda

package require de1_device_scale 1.0
package require de1_event 1.0
package require de1_logging 1.0
package require de1_profile 2.0
package require de1_shot 2.0


#############################
# raw data from the DE1

proc clear_espresso_chart {} {
	espresso_elapsed length 0
	espresso_pressure length 0
	espresso_weight length 0
	espresso_weight_chartable length 0
	espresso_flow length 0
	espresso_flow_weight length 0
	espresso_flow_weight_raw length 0
	espresso_flow_weight_2x length 0
	espresso_water_dispensed length 0
	espresso_flow_2x length 0
	espresso_resistance length 0
	espresso_resistance_weight length 0
	espresso_pressure_delta length 0
	espresso_flow_delta length 0
	espresso_flow_delta_negative length 0
	espresso_flow_delta_negative_2x length 0
	espresso_temperature_mix length 0
	espresso_temperature_basket length 0
	espresso_state_change length 0
	espresso_pressure_goal length 0
	espresso_flow_goal length 0
	espresso_flow_goal_2x length 0
	espresso_temperature_goal length 0

	espresso_de1_explanation_chart_elapsed length 0
	espresso_de1_explanation_chart_elapsed_1 length 0
	espresso_de1_explanation_chart_elapsed_2 length 0
	espresso_de1_explanation_chart_elapsed_3 length 0

	espresso_de1_explanation_chart_elapsed_flow length 0
	espresso_de1_explanation_chart_elapsed_flow_1 length 0
	espresso_de1_explanation_chart_elapsed_flow_2 length 0
	espresso_de1_explanation_chart_elapsed_flow_3 length 0	

	espresso_elapsed append 0
	espresso_pressure append 0
	#god_espresso_pressure append 0
	espresso_weight append 0
	espresso_weight_chartable append 0
	espresso_flow append 0
	espresso_flow_weight append 0
	espresso_flow_weight_2x append 0
	espresso_flow_weight_raw append 0
	espresso_water_dispensed append 0
	espresso_flow_2x append 0
	espresso_resistance append 0
	espresso_resistance_weight append 0
	espresso_pressure_delta append 0
	espresso_flow_delta append 0
	espresso_flow_delta_negative append 0
	espresso_flow_delta_negative_2x append 0
	espresso_temperature_mix append [return_temperature_number $::settings(espresso_temperature)]
	espresso_temperature_basket append [return_temperature_number $::settings(espresso_temperature)]
	espresso_state_change append 0
	espresso_pressure_goal append -1
	espresso_flow_goal append -1
	espresso_flow_goal_2x append -1
	espresso_temperature_goal append [return_temperature_number $::settings(espresso_temperature)]

	god_shot_reference_reset
	
	catch {
		# update the Y axis on the temperature chart, each time that we make an espresso, in case the goal temperature changed
		#update_temperature_charts_y_axis
	}

}	

proc espresso_chart_structures {} {
	return [list espresso_elapsed espresso_pressure espresso_weight espresso_weight_chartable espresso_flow espresso_flow_weight espresso_flow_weight_raw espresso_water_dispensed espresso_flow_weight_2x espresso_flow_2x espresso_resistance espresso_resistance_weight espresso_pressure_delta espresso_flow_delta espresso_flow_delta_negative espresso_flow_delta_negative_2x espresso_temperature_mix espresso_temperature_basket espresso_state_change espresso_pressure_goal espresso_flow_goal espresso_flow_goal_2x espresso_temperature_goal espresso_de1_explanation_chart_flow espresso_de1_explanation_chart_elapsed_flow espresso_de1_explanation_chart_flow_2x espresso_de1_explanation_chart_flow_1_2x espresso_de1_explanation_chart_flow_2_2x espresso_de1_explanation_chart_flow_3_2x espresso_de1_explanation_chart_pressure espresso_de1_explanation_chart_temperature espresso_de1_explanation_chart_temperature_10 espresso_de1_explanation_chart_pressure_1 espresso_de1_explanation_chart_pressure_2 espresso_de1_explanation_chart_pressure_3 espresso_de1_explanation_chart_elapsed_flow espresso_de1_explanation_chart_elapsed_flow_1 espresso_de1_explanation_chart_elapsed_flow_2 espresso_de1_explanation_chart_elapsed_flow_3 espresso_de1_explanation_chart_elapsed espresso_de1_explanation_chart_elapsed_1 espresso_de1_explanation_chart_elapsed_2 espresso_de1_explanation_chart_elapsed_3]
}

proc backup_espresso_chart {} {
	unset -nocomplain ::chartbk
	foreach s [espresso_chart_structures] {
		if {[$s length] > 0} {
			set ::chartbk($s) [$s range 0 end]
		} else {
			set ::chartbk($s) {}
		}
	}

}

proc restore_espresso_chart {} {
	foreach s [espresso_chart_structures] {
		$s length 0
		if {[info exists ::chartbk($s)] == 1} {
			$s append $::chartbk($s)
		}
	}
}


proc god_shot_reference_reset {} {
	############################################################################################################
	# god shot reference
	god_espresso_pressure length 0
	god_espresso_temperature_basket length 0
	god_espresso_flow length 0
	god_espresso_flow_weight length 0
	god_espresso_flow_2x length 0
	god_espresso_flow_weight_2x length 0

	if {[info exists ::settings(god_espresso_elapsed)] == 1} {
		espresso_elapsed length 0
		espresso_elapsed append $::settings(god_espresso_elapsed)
	}

	god_espresso_pressure append $::settings(god_espresso_pressure)
	god_espresso_temperature_basket append  $::settings(god_espresso_temperature_basket)

	if {$::settings(god_espresso_flow) != {} } {
		god_espresso_flow append $::settings(god_espresso_flow)

		# in zoomed flow/pressure mode we chart flow/weight at 2x the normal Y axis, so we need to populate those vectors by hand
		foreach flow $::settings(god_espresso_flow) {
			god_espresso_flow_2x append [expr {2.0 * $flow}]
		}
	}

	if {$::settings(god_espresso_flow_weight) != {} } {
		god_espresso_flow_weight append $::settings(god_espresso_flow_weight)

		foreach flow_weight $::settings(god_espresso_flow_weight) {
			god_espresso_flow_weight_2x append [expr {2.0 * $flow_weight}]
		}
	}
	############################################################################################################

}


proc espresso_frame_title {num} {
	if {$num == 1} {
		return "1) Ramp up pressure to 8.4 bar over 12 seconds"
	} elseif {$num == 2} {
		return "2) Hold pressure at 8.4 bars for 10 seconds"
	} elseif {$num == 3} {
		return "3) Maintain 1.2 mL/s flow rate for 30 seconds"
	} elseif {$num == 4} {
		return ""
	} elseif {$num == 5} {
		return ""
	} elseif {$num == 6} {
			return ""
	}
}

proc espresso_frame_description {num} {
	if {$num == 1} {
		return "Gently go to 8.4 bar of pressure with a water mix temperature of 92\u00B0C. Go to the next step after 10 seconds. temperature of 92\u00B0C. Gently go to 8.4 bar of pressure with a water mix temperature of 92\u00B0C."
	} elseif {$num == 2} {
		return "Quickly go to 8.4 bar of pressure with a basket temperature of 90\u00B0C. Go to the next step after 10 seconds."
	} elseif {$num == 3} {
		return "Automatically manage pressure to attain a flow rate of 1.2 mL/s at a water temperature of 88\u00B0C.  End this step after 30 seconds."
	} elseif {$num == 4} {
		return ""
	} elseif {$num == 5} {
		return ""
	} elseif {$num == 6} {
		return ""
	}

}

proc set_alarms_for_de1_wake_sleep {} {
	# first clear existing timers
	if {[info exists ::alarms_for_de1_wake] == 1} {
		after cancel $::alarms_for_de1_wake
		unset ::alarms_for_de1_wake
	}
	if {[info exists ::alarms_for_de1_sleep] == 1} {
		after cancel $::alarms_for_de1_sleep
		unset ::alarms_for_de1_sleep
	}

	# if the timers are active, then find the next alarm time and set an alarm to wake in that many milliseconds from now
	if {$::settings(scheduler_enable) == 1} {
		set wake_seconds [expr {[next_alarm_time $::settings(scheduler_wake)] - [clock seconds]}]
		set ::alarms_for_de1_wake [after [expr {1000 * $wake_seconds}] scheduler_wake]

		# scheduled sleep is now an enforced awake time and this function should not be called
		# set sleep_seconds [expr {[next_alarm_time $::settings(scheduler_sleep)] - [clock seconds]}]
		# set ::alarms_for_de1_sleep [after [expr {1000 * $sleep_seconds}] scheduler_sleep]

	}
}

proc scheduler_wake {} {
	msg -NOTICE "Scheduled wake occured at [clock format [clock seconds]]"
	start_schedIdle

	# after alarm has occured go ahead and set the alarm for tommorrow
	after 2000 set_alarms_for_de1_wake_sleep
}

proc scheduler_sleep {} {

	msg -ERROR "OBSOLETE: scheduled sleep is now an enforced awake time and this function should not be called"

	msg -NOTICE "Scheduled sleep occured at [clock format [clock seconds]]"
	start_sleep

	# after alarm has occured go ahead and set the alarm for tommorrow
	after 2000 set_alarms_for_de1_wake_sleep
}

proc current_alarm_time { in } {
	set alarm [expr {[round_date_to_nearest_day [clock seconds]] + round($in)}]
	return $alarm
}



proc next_alarm_time { in } {
	set alarm [expr {[round_date_to_nearest_day [clock seconds]] + round($in)}]
	if {$alarm < [clock seconds] } {
		# if the alarm time has passed, set it for tomorrow
		#set alarm [expr {$alarm + 86400} ]
		set alarm [clock add $alarm 1 day]
	}
	return $alarm
}

proc time_format {seconds {crlf 0} {include_day 0} } {
	if {$seconds == ""} {
		# no time passed
		return ""
	}

	set crlftxt " "
	if {$crlf == 1} {
		set crlftxt \n
	}

	if {$include_day == 0} {
		# john decided to no longer include the day on the alarm, as it's more info that is needed for an alarm clock
		if {$::settings(enable_ampm) == 1} {
			return [subst {[string trim [clock format $seconds -format {%l:%M %p}]]}]
		} else {
			return [subst {[string trim [clock format $seconds -format {%H:%M}]]}]
		}
	} else {
		if {$::settings(enable_ampm) == 1} {
			return [subst {[translate [clock format $seconds -format {%A}]]$crlftxt[string trim [clock format $seconds -format {%l:%M %p}]]}]
		} else {
			return [subst {[translate [clock format $seconds -format {%A}]]$crlftxt[string trim [clock format $seconds -format {%H:%M}]]}]
		}
	}
}

proc stripzeros {value} {
    set retval [string trimleft $value 0]
    if { ![string length $retval] } {
		return 0
    }
    return $retval
}

proc format_alarm_time { in } {
	return [time_format [next_alarm_time $in]]
}

proc start_timer_espresso_preinfusion {} {
	set ::timers(espresso_preinfusion_start) [clock milliseconds]
}

proc stop_timer_espresso_preinfusion {} {
	set ::timers(espresso_preinfusion_stop) [clock milliseconds]

}

proc start_timer_espresso_pour {} {
	set ::timers(espresso_pour_start) [clock milliseconds]
}

proc start_timer_water_pour {} {

	set ::timers(water_pour_stop) 0
	set ::timers(water_pour_start) [clock milliseconds]
}

proc start_timer_steam_pour {} {

	set ::timers(steam_pour_stop) 0
	set ::timers(steam_pour_start) [clock milliseconds]
}
proc start_timer_flush_pour {} {

	set ::timers(flush_pour_stop) 0
	set ::timers(flush_pour_start) [clock milliseconds]
}

proc stop_timer_espresso_pour {} {
	set ::timers(espresso_pour_stop) [clock milliseconds]

}

proc stop_timer_water_pour {} {
	msg -DEBUG "stop_timer_water_pour"
	set ::timers(water_pour_stop) [clock milliseconds]
}

proc stop_timer_steam_pour {} {
	msg -DEBUG "stop_timer_steam_pour"
	set ::timers(steam_pour_stop) [clock milliseconds]
}

proc stop_timer_flush_pour {} {
	msg -DEBUG "stop_timer_flush_pour"
	set ::timers(flush_pour_stop) [clock milliseconds]
}

proc stop_espresso_timers {} {
	if {$::timer_running != 1} {
		return
	}
	set ::timer_running 0
	set ::timers(espresso_stop) [clock milliseconds]
}

proc start_espresso_timers {} {
	clear_espresso_timers
	set ::timer_running 1
	set ::timers(espresso_start) [clock milliseconds]
}

proc clear_espresso_timers {} {

	unset -nocomplain ::timers
	set ::timers(espresso_start) 0
	set ::timers(espresso_stop) 0

	unset -nocomplain ::substate_timers
	set ::substate_timers(espresso_start) 0
	set ::substate_timers(espresso_stop) 0

	set ::timers(espresso_preinfusion_start) 0
	set ::timers(espresso_preinfusion_stop) 0

	set ::timers(espresso_pour_start) 0
	set ::timers(espresso_pour_stop) 0

	set ::timer_running 0
}

clear_espresso_timers
#stop_timers


# amount of time that we've been on this page
#set ::timer [clock seconds]
proc espresso_timer {} {
	#global start_timer
	#if {$::timer_running == 1} {
	#	set ::timer [clock seconds]
	#}	
	#return $timer
	return [expr {([clock milliseconds] - $::timers(espresso_start) )/1000}]
}

proc espresso_millitimer {{time_reference 0}} {

	# Accept seconds or ms, always returns ms; 10000000000 is Sat Nov 20 09:46:40 PST 2286

	if { $time_reference == 0 } {
		set time_reference [clock milliseconds]
	} elseif { $time_reference < 10000000000 } {
		set time_reference [expr { $time_reference * 1000. }]
	}

	return [expr { $time_reference - $::timers(espresso_start) }]
}

proc espresso_elapsed_timer {} {
	if {$::timers(espresso_start) == 0} {
		return 0
	} elseif {$::timers(espresso_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(espresso_start))/1000}]
	} else {
		# stop occured, so show that.
		return [expr {($::timers(espresso_stop) - $::timers(espresso_start))/1000}]
	}
}

proc espresso_preinfusion_timer {} {
	if {$::timers(espresso_preinfusion_start) == 0} {
		return 0
	} elseif {$::timers(espresso_preinfusion_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(espresso_preinfusion_start))/1000}]
	} else {
		# stop occured, so show that.
		return [expr {($::timers(espresso_preinfusion_stop) - $::timers(espresso_preinfusion_start))/1000}]
	}
}


proc espresso_pour_timer {} {
	if {[info exists ::timers(espresso_pour_start)] != 1} {
		return 0
	}

	if {$::timers(espresso_pour_start) == 0} {
		return 0
	} elseif {$::timers(espresso_pour_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(espresso_pour_start))/1000}]
	} else {
		# stop occured, so show that.
		return [expr {($::timers(espresso_pour_stop) - $::timers(espresso_pour_start))/1000}]
	}
}

proc water_pour_timer {} {
	if {[info exists ::timers(water_pour_start)] != 1} {
		return 0
	}

	if {$::timers(water_pour_start) == 0} {
		return 0
	} elseif {$::timers(water_pour_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(water_pour_start))/1000}]
	} else {
		# stop occured, so show that.
		return [expr {($::timers(water_pour_stop) - $::timers(water_pour_start))/1000}]
	}
}
proc steam_pour_timer {} {
	if {[info exists ::timers(steam_pour_start)] != 1} {
		return 0
	}

	if {$::timers(steam_pour_start) == 0} {
		return 0
	} elseif {$::timers(steam_pour_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(steam_pour_start))/1000}]
	} else {
		# stop occured, so show that.
		return [expr {($::timers(steam_pour_stop) - $::timers(steam_pour_start))/1000}]
	}
}

proc steam_pour_millitimer {{time_reference 0}} {

	# Accept seconds or ms, always returns ms; 10000000000 is Sat Nov 20 09:46:40 PST 2286

	if { $time_reference == 0 } {
		set time_reference [clock milliseconds]
	} elseif { $time_reference < 10000000000 } {
		set time_reference [expr { $time_reference * 1000. }]
	}


	if {[info exists ::timers(steam_pour_start)] != 1} {
		return 0
	}

	if {$::timers(steam_pour_start) == 0} {
		return 0
	} elseif {$::timers(steam_pour_stop) == 0} {
		# no stop, so show current elapsed time
		return [expr {$time_reference - $::timers(steam_pour_start)}]
	} else {
		# stop occured, so show that.
		return [expr {$::timers(steam_pour_stop) - $::timers(steam_pour_start)}]
	}
}

proc flush_pour_timer {} {
	set t ""
	set c 0
	if {[info exists ::timers(flush_pour_start)] != 1} {
		set t "-0"
		set c 1
	} elseif {$::timers(flush_pour_start) == 0} {
		set t "-1"
		set c 2
	} elseif {$::timers(flush_pour_stop) == 0} {
		# no stop, so show current elapsed time
		set t [expr {([clock milliseconds] - $::timers(flush_pour_start))/1000}]
		set c 3
	} else {
		# stop occured, so show that.
		set t [expr {($::timers(flush_pour_stop) - $::timers(flush_pour_start))/1000}]
		set c 4
	}
	return $t
}
proc done_timer {} {
	if {$::timers(stop) == 0} {
		return 0
	} else {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(stop))/1000}]
	}
}

proc espresso_done_timer {} {

	if {[info exists ::timers(espresso_stop)] != 1} {
		return 0
	}

	if {$::timers(espresso_stop) == 0} {
		return 0
	} else {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(espresso_stop))/1000}]
	}
}

proc water_done_timer {} {
	if {[info exists ::timers(water_pour_stop)] != 1} {
		return 0
	}

	if {$::timers(water_pour_stop) == 0} {
		return 0
	} else {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(water_pour_stop))/1000}]
	}
}
proc steam_done_timer {} {
	if {[info exists ::timers(steam_pour_stop)] != 1} {
		return 0
	}

	if {$::timers(steam_pour_stop) == 0} {
		return 0
	} else {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(steam_pour_stop))/1000}]
	}
}

proc flush_done_timer {} {
	if {[info exists ::timers(flush_pour_stop)] != 1} {
		return 0
	}

	if {$::timers(flush_pour_stop) == 0} {
		return 0
	} else {
		# no stop, so show current elapsed time
		return [expr {([clock milliseconds] - $::timers(flush_pour_stop))/1000}]
	}
}

proc waterflow {} {
	if {$::de1(substate) != $::de1_substate_types_reversed(pouring) && $::de1(substate) != $::de1_substate_types_reversed(preinfusion)} {	
		return 0
	}

	if {$::android == 0} {
		if {[ifexists ::de1(flow)] == ""} {
			set ::de1(flow) 3
		}
		if {$::de1(flow) > 5} {
			set ::de1(flow) 4.5
		}
		if {$::de1(flow) < 1} {
			set ::de1(flow) 1.5
		}


		set ::de1(flow) [expr {(.1 * (rand() - 0.5)) + $::de1(flow)}]		

		if {$::de1_num_state($::de1(state)) == "Espresso"} {
			if {[espresso_millitimer] < 5000} {	
				set ::de1(preinfusion_volume) [expr {$::de1(preinfusion_volume) + ($::de1(flow) * .1) }]
			} else {
				set ::de1(pour_volume) [expr {$::de1(pour_volume) + ($::de1(flow) * .1) }]
			}
		}
		#set ::de1(flow) [expr {rand() + $::de1(flow) - 0.5}]

	}

	return $::de1(flow)
	
}

set start_timer [clock seconds]
set start_millitimer [clock milliseconds]
proc watervolume {} {
	if {$::de1(substate) != $::de1_substate_types_reversed(pouring) && $::de1(substate) != $::de1_substate_types_reversed(preinfusion)} {	
		return 0
	}


	if {$::android == 1} {
		return $::de1(volume)
	}
	global start_timer
	return [expr {[clock seconds] - $start_timer}]
}

proc steamtemp {} {
	if {$::android == 0} {

		set ::de1(steam_heater_temperature) [expr {(160+(rand() * 5))}]
	}
	return $::de1(steam_heater_temperature)
}

proc watertemp {} {
	if {$::android == 0} {
		#set ::de1(head_temperature) [expr {$::settings(espresso_temperature) - 2.0 + (rand() * 4)}]
		set ::de1(goal_temperature) $::settings(espresso_temperature)

		if {[ifexists ::de1(head_temperature)] == ""} {
			set ::de1(head_temperature) $::de1(goal_temperature)
		}
		if {$::de1(head_temperature) < 80} {
			set ::de1(head_temperature) $::de1(goal_temperature)
		}
		if {$::de1(head_temperature) > 95} {
			set ::de1(head_temperature) $::de1(goal_temperature)
		}

		#set ::de1(head_temperature) [expr {rand() + $::de1(head_temperature) - 0.5}]
		set ::de1(head_temperature) [expr {(.2 * (rand() - 0.6)) + $::de1(head_temperature)}]		
		#set ::de1(head_temperature) 90

	}

	return $::de1(head_temperature)
}

proc pressure {} {
	if {$::de1(substate) != $::de1_substate_types_reversed(pouring) && $::de1(substate) != $::de1_substate_types_reversed(preinfusion)} {	
		return 0
	}

	if {$::android == 0} {
		if {$::de1(state) == 4} {
			#espresso
			if {[ifexists ::de1(pressure)] == ""} {
				set ::de1(pressure) 5
			}

			if {$::de1(pressure) > 10} {
				set ::de1(pressure) 9
			}
			if {$::de1(pressure) < 1} {
				set ::de1(pressure) 5
			}


			set ::de1(pressure) [expr {(.5 * (rand() - 0.5)) + $::de1(pressure)}]
		} elseif {$::de1(state) == 5} { 
			#steam
			if {[ifexists ::de1(pressure)] == ""} {
				set ::de1(pressure) 2
			}

			if {$::de1(pressure) > 3} {
				set ::de1(pressure) 2
			}
			if {$::de1(pressure) < .2} {
				set ::de1(pressure) 2
			}

			set ::de1(pressure) [expr {(.2 * (rand() - 0.5)) + $::de1(pressure)}]
		}
	}

	return $::de1(pressure)
	#if {$::android == 1} {
	#}
	#return [expr {(rand() * 3.5)}]
}

proc accelerometer_angle {} {
	if {$::android == 0} {
		set ::settings(accelerometer_angle) [expr {(rand() + $::settings(accelerometer_angle)) - 0.5}]
	}
	return [round_to_one_digits [expr {abs($::settings(accelerometer_angle))}]]

}

set since_last_acc [clock milliseconds]
set last_acc_count 0
proc accelerometer_angle_text {} {
	global accelerometer_read_count

	global since_last_acc
	global last_acc_count

	set rate 0
	set delta 0
	catch {
		set delta [expr {$accelerometer_read_count - $last_acc_count}]
		set rate [expr {1000* ([clock milliseconds] - $since_last_acc}]
	}
	set since_last_acc [clock milliseconds]
	set last_acc_count $accelerometer_read_count
	return "$::settings(accelerometer_angle)\u00B0 ($accelerometer_read_count) $rate events/second $delta events $rate"
}

proc group_head_heater_temperature {} {

	
	if {$::android == 0} {
		# slowly have the water level drift
		set ::de1(water_level) [expr {$::de1(water_level) + (.1*(rand() - 0.5))}]
	}

	return $::de1(head_temperature)
}

proc steam_heater_temperature {} {
	if {$::android == 0} {
		set ::de1(mix_temperature) [expr {140 + (rand() * 20.0)}]
	}

	return $::de1(steam_heater_temperature)

}
proc water_mix_temperature {} {
	if {$::android == 0} {
		if {$::de1(substate) == $::de1_substate_types_reversed(pouring) || $::de1(substate) == $::de1_substate_types_reversed(preinfusion)} {	
			if {$::de1(mix_temperature) == "" || $::de1(mix_temperature) < 85 || $::de1(mix_temperature) > 99} {
				set ::de1(mix_temperature) 94
			}
			set ::de1(mix_temperature) [expr {$::de1(head_temperature) + ((rand() - 0.5) * 2) }]
		}
			#return [return_flow_weight_measurement [expr {(rand() * 6)}]]
	}

	return $::de1(mix_temperature)
}





#################
# formatting DE1 numbers into pretty text



proc steam_heater_action_text {} {
	set delta [expr {int([steam_heater_temperature] - [setting_steam_temperature])}]
	if {$delta < -2} {
		return [translate "(Heating):"]
	} elseif {$delta > 2} {
		return [translate "(Cooling):"]
	} else {
		return [translate "Ready:"]
	}
}

proc group_head_heater_action_text {} {
	set delta [expr {int([group_head_heater_temperature] - [setting_espresso_temperature])}]
	if {$delta < -5} {
		return [translate "Heating:"]
	} elseif {$delta > 5} {
		return [translate "Cooling:"]
	} else {
		return [translate "Ready:"]
	}
}

proc group_head_heating_text {} {
	set delta [expr {int([group_head_heater_temperature] - [setting_espresso_temperature])}]
	if {$delta < -5} {
		return [translate "(heating)"]
	}
}

proc return_seconds_divided_by_ten {in} {
	if {$in == ""} {return ""}

	set t [expr {$in / 10.0}]
	return "[round_to_one_digits $t] [translate "seconds"]"

}
proc timer_text {} {
	return [subst {[timer] [translate "seconds"]}]
}

proc return_liquid_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "mL"] [round_to_integer $in] }]
    }

	if {$::settings(enable_fluid_ounces) != 1} {
		return [subst {[round_to_integer $in] [translate "mL"]}]
	} else {
		return [subst {[round_to_integer [ml_to_oz $in]] oz}]
	}
}

proc return_flow_calibration_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "mL/s"] [round_to_one_digits [expr {0.1 * $in}]]}]
    }
	return [subst {[round_to_one_digits [expr {0.1 * $in}]] [translate "mL/s"]}]

}

proc return_flow_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "mL/s"] [round_to_one_digits $in]}]
    }

	if {$::settings(enable_fluid_ounces) != 1} {
		return [subst {[round_to_one_digits $in] [translate "mL/s"]}]
	} else {
		return [subst {[round_to_one_digits [ml_to_oz $in]] oz/s}]
	}
}

proc return_pressure_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "bar"] [commify [round_to_one_digits $in]]}]
    }
	return [subst {[commify [round_to_one_digits $in]] [translate "bar"]}]
}

proc return_flow_weight_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "g/s"] [round_to_one_digits $in]}]
    }

	if {$::settings(enable_fluid_ounces) != 1} {
		return [subst {[round_to_one_digits $in] [translate "g/s"]}]
	} else {
		return [subst {[round_to_one_digits [ml_to_oz $in]] oz/s}]
	}
}

proc return_weight_measurement {in} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "g"][round_to_one_digits $in]}]
    }

	if {$::settings(enable_fluid_ounces) != 1} {
		return [subst {[round_to_one_digits $in][translate "g"]}]
	} else {
		return [subst {[round_to_one_digits [ml_to_oz $in]] oz}]
	}
}

proc return_percent {in} {
	return [subst {[round_to_one_digits $in]%}]
}

proc return_percent_off_if_zero {in} {
	if {$in == 0} {
		return [translate "off"]
	}
	return [subst {[round_to_one_digits $in]%}]
}

proc return_off_if_zero {in} {
	if {$in == 0} {
		return [translate "off"]
	}
	return $in

}

proc return_zero_if_blank {in} {
	if {$in == ""} {
		return 0
	}
	return $in
}

proc return_stop_at_volume_measurement {in} {
	if {$in == 0} {
		return [translate "off"]
	} else {
		return [return_liquid_measurement [round_to_integer $in]]
	}
}

proc return_off_or_temperature {in} {
	if {$in == 0} {
		return [translate "off"]
	} else {
		return [return_temperature_measurement [round_to_integer $in]]
	}
}

proc return_stop_at_weight_measurement {in} {

	if {$in == 0 || $in == ""} {
		return [translate "off"]
	} else {

	    if {$::de1(language_rtl) == 1} {
			return [subst {[translate "g"][round_to_one_digits $in]}]
		}

		if {$::settings(enable_fluid_ounces) != 1} {
			return [subst {[round_to_one_digits $in][translate "g"]}]
		} else {
			return [subst {[round_to_one_digits [ml_to_oz $in]] oz}]
		}
	}
}

proc return_stop_at_weight_measurement_precise {in} {
	if {$in == 0} {
		return [translate "off"]
	} else {
	    if {$::de1(language_rtl) == 1} {
			return [subst {[translate "g"][round_to_one_digits $in]}]
		}
		if {$::settings(enable_fluid_ounces) != 1} {
			return [subst {[round_to_one_digits $in][translate "g"]}]
		} else {
			return [subst {[round_to_half_integer [ml_to_oz $in]] oz}]
		}
	}
}

proc return_shot_weight_measurement {in} {
	if {$in == 0} {
		return [translate "off"]
	} else {
	    if {$::de1(language_rtl) == 1} {
			return [subst {[translate "g"][round_to_one_digits $in]}]
		}

		if {$::settings(enable_fluid_ounces) != 1} {
			return [subst {[round_to_one_digits $in][translate "g"]}]
		} else {
			return [subst {[round_to_one_digits [ml_to_oz $in]] oz}]
		}
	}
}

proc preinfusion_pour_timer_text {} {
    if {$::de1(language_rtl) == 1} {
		return [subst {[translate "s"][espresso_preinfusion_timer] [translate "preinfusion"] }]
	}

	return [subst {[espresso_preinfusion_timer][translate "s"] [translate "preinfusion"]}]
}

proc total_pour_timer_text {} {
    if {$::de1(language_rtl) == 1} {
		return "[translate {s}][espresso_elapsed_timer] [translate {total}] "
	}

	return "[espresso_elapsed_timer][translate {s}] [translate {total}]"
}

proc espresso_done_timer_text {} {
	if {[espresso_done_timer] < $::settings(seconds_to_display_done_espresso)} {
	    if {$::de1(language_rtl) == 1} {
			return "[translate s][espresso_done_timer] [translate done]"
	    }

		return "[espresso_done_timer][translate s] [translate done]"
	} else { 
		return ""
	}

}

proc pouring_timer_text {} {
    if {$::de1(language_rtl) == 1} {

		if {$::settings(final_desired_shot_volume_advanced) > 0 && $::settings(settings_profile_type) == "settings_2c"} {
			return "[return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume_advanced)]] < [translate {pouring}] [translate {s}][espresso_elapsed_timer]"
		}

		if {$::settings(scale_bluetooth_address) == "" && $::settings(final_desired_shot_volume) > 0 && ($::settings(settings_profile_type) == "settings_2a" || $::settings(settings_profile_type) == "settings_2b")} {
			return "[translate {s}][espresso_pour_timer] [translate {pouring}] < [return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume)]]"

		} else {
			return "[translate {s}][espresso_pour_timer] [translate {pouring}]"
		}
	}

	if {$::settings(final_desired_shot_volume_advanced) > 0 && $::settings(settings_profile_type) == "settings_2c"} {
		return "[espresso_elapsed_timer][translate {s}] [translate {pouring}] < [return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume_advanced)]]"
	}

	if {$::settings(scale_bluetooth_address) == "" && $::settings(final_desired_shot_volume) > 0 && ($::settings(settings_profile_type) == "settings_2a" || $::settings(settings_profile_type) == "settings_2b")} {
		return "[espresso_pour_timer][translate {s}] [translate {pouring}] < [return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume)]]"
	}
	return "[espresso_pour_timer][translate {s}] [translate {pouring}]"

}

proc pouring_timer_text_2 {} {
	OBSOLETE
	if {$::de1(language_rtl) == 1} {
		if {$::settings(scale_bluetooth_address) == "" && $::settings(final_desired_shot_volume) > 0 && ($::settings(settings_profile_type) == "settings_2a" || $::settings(settings_profile_type) == "settings_2b")} {

			return "[translate {s}][espresso_pour_timer] [translate {pouring}] < [return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume)]]"

		} else {
			return "[translate {pouring}] [translate {s}][espresso_pour_timer]"
		}
	}

	if {$::settings(scale_bluetooth_address) == "" && $::settings(final_desired_shot_volume) > 0 && ($::settings(settings_profile_type) == "settings_2a" || $::settings(settings_profile_type) == "settings_2b")} {
		return "[espresso_pour_timer][translate {s}] [translate {pouring}] < [return_liquid_measurement [round_to_integer $::settings(final_desired_shot_volume)]]"
	} else {
		return "[espresso_pour_timer][translate {s}] [translate {pouring}]"
	}
}


proc preinfusion_volume {} {
	return_liquid_measurement [round_to_integer $::de1(preinfusion_volume)]
}

proc pour_volume {} {
	return_liquid_measurement [round_to_integer $::de1(pour_volume)]
}

proc waterflow_text {} {
	return [return_flow_measurement [waterflow]] 
}

proc watervolume_text {} {
	if {$::android == 0} {
		if {$::de1(substate) == $::de1_substate_types_reversed(pouring) || $::de1(substate) == $::de1_substate_types_reversed(preinfusion)} {	
			if {$::de1(volume) == ""} {
				set ::de1(volume) 0
			}
			set ::de1(volume) [expr {$::de1(volume) + (rand() * .27) }]
		}
	}

	# we sum these two numbers so that we don't have a rounding error that a user might find offensive (ie, "preinfusion + pour = total" ALWAYS) 
	return [return_liquid_measurement [expr {[round_to_integer $::de1(preinfusion_volume)] + [round_to_integer $::de1(pour_volume)]}]] 
}

proc waterweightflow_text {} {
	if {$::android == 0} {
		if {$::de1(substate) == $::de1_substate_types_reversed(pouring) || $::de1(substate) == $::de1_substate_types_reversed(preinfusion)} {	
			if {[espresso_millitimer] > 5000} {	
				# no weight increase for 5s due to preinfusion
				if {$::de1(scale_weight_rate) == ""} {
					set ::de1(scale_weight_rate) 3
				}

				set ::de1(scale_weight_rate) [expr {$::de1(scale_weight_rate) + ((rand() - 0.5) * .3) }]
				if {$::de1(scale_weight_rate) < 0} {
					set ::de1(scale_weight_rate) 1
				}
				set ::de1(scale_weight_rate_raw) [expr {$::de1(scale_weight_rate) + ((rand() - 0.5) * 1) }]
			}

		}
			#return [return_flow_weight_measurement [expr {(rand() * 6)}]]
	}

	if {$::de1(scale_weight) == "" || [ifexists ::settings(scale_bluetooth_address)] == ""} {
		return ""
	}
	return [return_flow_weight_measurement $::de1(scale_weight_rate)]
}

proc finalwaterweight_text {} {
	if {$::de1(scale_weight) == "" || [ifexists ::settings(scale_bluetooth_address)] == ""} {
		return ""
	}

	if {[ifexists ::blink_water_weight] == 1} {
		return ""
	}

	return [return_weight_measurement $::de1(final_water_weight)]
}

# drink_weight is present for both espresso and hot water
proc drink_weight_text {} {
	if {$::de1(scale_weight) == "" || [ifexists ::settings(scale_bluetooth_address)] == ""} {
		return ""
	}

	if {[ifexists ::blink_water_weight] == 1} {
		return ""
	}

	return [return_weight_measurement $::settings(running_weight)]
}

proc dump_stack {args} {
	msg -INFO [stacktrace]
}

#trace add variable de1(final_water_weight) write dump_stack

proc waterweight_text {} {
	if {$::de1(scale_weight) == "" || [ifexists ::settings(scale_bluetooth_address)] == ""} {
		return ""
	}

	if {$::android == 0} {
		if {[espresso_millitimer] < 5000} {	
			# no weight increase for 5s due to preinfusion
			set ::de1(scale_weight) 0
		} else {

			if {$::de1(substate) == $::de1_substate_types_reversed(pouring) || $::de1(substate) == $::de1_substate_types_reversed(preinfusion)} {	
				if {$::de1(scale_weight) == ""} {
					set ::de1(scale_weight) 3
				}
				set ::de1(scale_weight) [expr {$::de1(scale_weight) + (rand() * .3) }]
				set ::de1(final_water_weight) $::de1(scale_weight)
			} else {
				set ::de1(scale_weight) 0
			}
		}

		#return [return_weight_measurement [expr {round((rand() * 20))}]]
	}

	if {$::de1(scale_device_handle) == "0"} {
		return [translate "Disconnected"]
	}

	return [return_weight_measurement $::de1(scale_sensor_weight)]

	#return [return_weight_measurement $::de1(scale_weight)]
}

proc waterweight_label_text {} {
	if {[ifexists ::settings(scale_bluetooth_address)] == ""} {
		return ""
	}

	if {$::de1(scale_device_handle) == "0"} {
		if {[ifexists ::blink_water_weight] != 1} {
			if {$::currently_connecting_scale_handle == 0} {
				set ::blink_water_weight 1
				return {}
			} else {
				return [translate "Wait"]
			}
		} else {
			set ::blink_water_weight 0
			return [translate "Weight"]
		}
	}

	return [translate "Weight"]
}


proc espresso_goal_temp_text {} {
	return [return_temperature_measurement $::de1(goal_temperature)]
}

proc espresso_goal_temp_text_rtl_aware {} {
	return [subst {[return_temperature_measurement $::de1(goal_temperature)] [translate "goal"]}]
}

set ::diff_brew_temp_from_goal 0
set ::positive_diff_brew_temp_from_goal 0
proc diff_brew_temp_from_goal {} {
	set ::diff_brew_temp_from_goal [expr {[water_mix_temperature] - $::de1(goal_temperature)}]
	set ::positive_diff_brew_temp_from_goal [expr {abs($::diff_brew_temp_from_goal)}]
	return $::diff_brew_temp_from_goal
}

proc diff_brew_temp_from_goal_text {} {
	set diff [expr {[water_mix_temperature] - $::de1(goal_temperature)}]
	return [return_delta_temperature_measurement $diff]
}

proc diff_espresso_temp_from_goal {} {
	set diff [expr {[watertemp] - $::de1(goal_temperature)}]
	return $diff
}
proc diff_espresso_temp_from_goal_text {} {
	set diff [expr {[watertemp] - $::de1(goal_temperature)}]
	return [return_delta_temperature_measurement $diff]
}

proc diff_group_temp_from_goal {} {
	set diff [expr {[group_head_heater_temperature] - $::de1(goal_temperature)}]
	return $diff
}

proc diff_group_temp_from_goal_text {} {
	set diff [expr {[group_head_heater_temperature] - $::de1(goal_temperature)}]
	return [return_delta_temperature_measurement $diff]
}

proc diff_pressure {} {
	if {$::android == 0} {
		return [expr {3 - (rand() * 6)}]
	}

	return $::gui::state::_delta_pressure
}

proc diff_flow_rate {} {
	if {$::android == 0} {
		return [expr {3 - (rand() * 6)}]
	}

	return $::gui::state::_delta_flow
}

proc diff_flow_rate_text {} {
	return [return_flow_measurement [round_to_one_digits [diff_flow_rate]]]
}



proc mixtemp_text {} {
	return [return_temperature_measurement [water_mix_temperature]]
}

proc watertemp_text {} {
	return [return_temperature_measurement [watertemp]]
}

proc steamtemp_text {} {
	return [return_temperature_measurement [steamtemp]]
}

proc pressure_text {} {
	if {$::de1(language_rtl) == 1} {
		return [subst {[translate "bar"] [commify [round_to_one_digits [pressure]]]}]
	}
	return [subst {[commify [round_to_one_digits [pressure]]] [translate "bar"]}]
}


proc commify {number}  {
	while {[regsub {^([-+]?\d+)(\d\d\d)} $number {\1,\2} number]} {}
	if {[ifexists ::settings(enable_commanumbers)] == 1} {
		set number [string map {. , , .} $number]
	}
	return $number
}

#######################
# settings
proc setting_steam_max_time {} {
	return [expr {round( $::settings(steam_max_time) )}]
}
proc setting_water_max_time {} {
	return [expr {round( $::settings(water_time_max) )}]
}
proc setting_espresso_max_time {} {
	return [expr {round( $::settings(espresso_max_time) )}]
}
proc setting_steam_max_time_text {} {
	return [subst {[setting_steam_max_time] [translate "seconds"]}]
}
proc setting_water_max_time_text {} {
	return [subst {[setting_water_max_time] [translate "seconds"]}]
}
proc setting_espresso_max_time_text {} {
	return [subst {[setting_espresso_max_time] [translate "seconds"]}]
}


proc setting_steam_temperature {} {
	return $::settings(steam_temperature)
}
proc setting_espresso_temperature {} {
	return $::settings(espresso_temperature)
}
proc setting_water_temperature {} {
	return $::settings(water_temperature)
}

proc return_html_temperature_units {} {
	if {$::settings(enable_fahrenheit) == 1} {
		return "[encoding convertfrom utf-8 °]F"
	} else {
		return "[encoding convertfrom utf-8 °]C"
	}
}

proc return_temp_offset {in} {
	if {$::settings(enable_fahrenheit) == 1} {
		return [expr {$in * 1.8}]
	} else {
		return $in
	}
}


proc return_temperature_number {in} {
	if {$::settings(enable_fahrenheit) == 1} {
		return [round_to_two_digits [celsius_to_fahrenheit $in]]
	} else {
		return [round_to_two_digits $in]
	}	
}

# john 25-1-2020 fix
# we were using the wrong unicode symbol for the degrees sign (should be \u00B0 not \u00BA).
# http://www.fileformat.info/info/unicode/char/b0/index.htm
# http://www.fileformat.info/info/unicode/char/ba/index.htm
proc return_temperature_measurement {in} {
	if {$::settings(enable_fahrenheit) == 1} {
		return [subst {[round_to_integer [celsius_to_fahrenheit $in]]\u00B0F}]
	} else {
		return [subst {[round_to_one_digits $in]\u00B0C}]
	}
}

proc round_and_return_temperature_setting {varname} {
	upvar $varname in
	set out [round_temperature_number $in]
	if {$in != $out} {
		set $varname $out
	}	
	return_temperature_setting $in
}

proc round_temperature_number {in} {
	return [round_to_half_integer $in]
}

proc return_temperature_setting_or_off {in} {
	if {$in == 0} {
		return [translate "off"]
	} else {
		return [return_temperature_setting $in]
	}
}

proc return_temperature_setting {in} {
	if {$::settings(enable_fahrenheit) == 1} {
		return [subst {[round_to_integer [celsius_to_fahrenheit $in]]\u00B0F}]
	} else {
		if {[round_to_half_integer $in] == [round_to_integer $in]} {
			# don't display a .0 on the number if it's not needed
			return [subst {[round_to_integer $in]\u00B0C}]
		} else {
			return [subst {[round_to_half_integer $in]\u00B0C}]
		}
	}
}

proc return_plus_or_minus_number {in} {
	if {$in > 0.0} {
		return "+$in"
	}
	return $in
}

proc return_delta_temperature_measurement {in} {

	if {$::settings(enable_fahrenheit) == 1} {
		set label "\u00B0F"
		#set num [celsius_to_fahrenheit $in]
#		set num $in
	} else {
		set label "\u00B0C"
#		set num $in
	}

	# handle ºC vs ºF deltas
	set in [return_temp_offset $in]
	set num [round_to_one_digits $in]
	set t {}
	if {$num > 0.0} {
		set t "+$t"
	}

	set s "$t$num$label"
	return $s
}

proc setting_steam_temperature_text {} {
	return [return_temperature_measurement [setting_steam_temperature]]
}
proc setting_water_temperature_text {} {
	return [return_temperature_measurement [setting_water_temperature]]
}



proc steam_heater_temperature_text {} {
	return [return_temperature_measurement [steam_heater_temperature]]
}

proc group_head_heater_temperature_text {} {
	return [return_temperature_measurement [group_head_heater_temperature]]
}

proc group_head_heater_temperature_text_rtl_aware {} {

	return [subst {[return_temperature_measurement [group_head_heater_temperature]] [translate "metal"]}]
}

proc coffee_temp_text_rtl_aware {} {
	return "[watertemp_text] [translate {coffee}]"

}

proc setting_espresso_temperature_text {} {
	return [return_temperature_measurement [setting_espresso_temperature]]
}

proc setting_espresso_pressure {} {
	return $::settings(espresso_pressure)
}
proc setting_espresso_pressure_text {} {
	return [subst {[commify [round_to_one_digits [setting_espresso_pressure]]] [translate "bar"]}]
}

proc setting_espresso_stop_pressure_text {} {
	if {$::settings(preinfusion_stop_pressure) == 0} {
		return ""
	}
	return [subst {[commify [round_to_one_digits $::settings(preinfusion_stop_pressure)]] [translate "bar"]}]
}

proc setting_espresso_stop_flow_text {} {
	if {$::settings(preinfusion_stop_flow_rate) == 0} {
		return ""
	}
	return [subst {[return_flow_measurement $::settings(preinfusion_stop_flow_rate)]}]
}


proc graph_seconds_axis_format {nm val} {
	if {$val == 0} {
		return [translate "start"]
	}
	return "$val [translate {seconds}]"
}




#######################
# conversion functions

proc round_to_tens {in} {
	set x 0
    catch {
    	set x [expr {round($in / 10.0)*10}]
    }
    return $x
}

proc round_to_two_digits {in} {
	set x 0
	catch {
		set x [format "%.2f" $in]
	}
	return $x

	# obsolete below
	set x 0
    catch {
    	set x [expr {round($in * 100.0)/100.0}]
    }
    return $x
}

proc round_to_one_digits {in} {
	set x 0
	catch {
    	set x [expr {round($in * 10.0)/10.0}]
    }
    return $x
}

proc round_to_integer {in} {
	set x 0
	catch {
    	set x [expr {round($in)}]
    }
    return $x
}

proc celsius_to_fahrenheit {in} {
	set x 0
	catch {
		set x [expr {32 + ($in * 1.8)}]
	}
	return $x
}

proc ml_to_oz {in} {
	set x 0
	catch {
		set x [expr {$in * 0.033814}]
	}
	return $x
}

proc backup_settings {} {
	unset -nocomplain ::settings_backup; 
	array set ::settings_backup [array get ::settings]
	backup_espresso_chart
	#update_de1_explanation_chart
}

proc refresh_skin_directories {} {
	unset -nocomplain ::skin_directories_cache
}

proc skin_directories {} {
	if {[info exists ::skin_directories_cache] == 1} {
		return $::skin_directories_cache
	}

	set dirs [lsort -dictionary [glob -nocomplain -tails -directory "[homedir]/skins/" *]]
	set dd {}

	# overriding settings to include Insight Dark now
	set ::settings(most_popular_skins) [list Insight "Insight Dark" MimojaCafe Metric DSx SWDark4 MiniMetric]

	foreach d $dirs {
		if {$d == "CVS" || $d == "example"} {
			continue
		}
	    
		if {[ifexists ::settings(show_only_most_popular_skins)] == 1 && [ifexists ::settings(most_popular_skins)] != ""} {
			#puts "'$d' '[ifexists ::settings(most_popular_skins)]'"
			if {[lsearch -exact [string toupper [ifexists ::settings(most_popular_skins)]] [string toupper $d] ] == -1} {
				continue
			}
		}

	    set fn "[homedir]/skins/$d/skin.tcl"
	    set skintcl [read_file $fn]
	    #set skintcl ""
	    if {[string first "package require de1plus" $skintcl] != -1} {

		    # keep track of which skins are DE1PLUS so we can display them differently in the listbox
		    set ::de1plus_skins($d) 1
		}

		lappend dd $d		
	}
	set ::skin_directories_cache [lsort -dictionary -increasing $dd]
	return $::skin_directories_cache
}


proc fill_history_listbox {} {
	set widget $::globals(history_listbox)

	$widget delete 0 99999

	set cnt 0
	set current_skin_number 0
	foreach d [history_directories] {
		$widget insert $cnt [clock format $d]
		incr cnt
	}

	#$widget selection set $current_skin_number

	bind $widget <<ListboxSelect>> [list ::preview_history %W] 	

	preview_history
}

proc fill_skin_listbox {} {
	set widget $::globals(tablet_styles_listbox)
	$widget delete 0 99999

	set cnt 0
	set ::current_skin_number 0
	foreach d [skin_directories] {
		if {$d == "CVS" || $d == "example"} {
			continue
		}

		$widget insert $cnt [translate $d]
		if {$::settings(skin) == $d} {
			set ::current_skin_number $cnt
		}

		if {[ifexists ::de1plus_skins($d)] == 1} {
			# mark skins that require the DE1PLUS model with a different color to highlight them
			$widget itemconfigure $cnt -background #F0F0FF
		}
		incr cnt
	}
	
	#$widget itemconfigure $current_skin_number -foreground blue

	$widget selection set $::current_skin_number

	make_current_listbox_item_blue $widget

	preview_tablet_skin
	$widget yview $::current_skin_number

}


proc make_current_listbox_item_blue { widget} {
	if {[$widget index end] == 0} {
		# empty listbox
		return
	}

	set found_one 0
	for {set x 0} {$x < [$widget index end]} {incr x} {
		if {$x == [$widget curselection]} {
			#if {$x < [$widget index end]} {
				$widget itemconfigure $x -foreground #000000 -selectforeground #000000  -background #c0c4e1
				set found_one 1
			#}

		} else {
			$widget itemconfigure $x -foreground #b2bad0 -background #fbfaff
		}
	}

	if {$found_one != 1} {
		# handle the case where nothing has been selected
		$widget selection set 0
		$widget itemconfigure 0 -foreground #000000 -selectforeground #000000  -background #c0c4e1
	}

}



proc history_directories {} {
	set dirs [lsort -dictionary [glob -nocomplain -tails -directory "[homedir]/history/" *.shot]]
	set dd {}
	foreach d $dirs {
		lappend dd [file rootname $d]
	}
	return [lsort -dictionary -increasing $dd]
}


proc profile_directories {} {

	set show_hidden 0
	if {[ifexists ::profiles_hide_mode] == 1} {
		set show_hidden 1
	}

	set dirs [lsort -dictionary [glob -nocomplain -tails -directory "[homedir]/profiles/" *.tcl]]
	set dd {}
	foreach d $dirs {
		#if {$d == "CVS" || $d == "example"} {
		#	continue
		#}

		set dflow_test [string tolower [string range $d 0 5]]
		if {$dflow_test == "d-flow"} {
			if {[plugin_enabled "D_Flow_Espresso_Profile"] != true} {
				continue
			}
		}

		set filecontents [encoding convertfrom utf-8 [read_binary_file "[homedir]/profiles/$d"]]
	    if {[string first "settings_profile_type settings_2b" $filecontents] != -1 || [string first "settings_profile_type settings_2c" $filecontents] != -1 || [string first "settings_profile_type settings_profile_flow" $filecontents] != -1 || [string first "settings_profile_type settings_profile_advanced" $filecontents] != -1} {

		    # keep track of which skins are DE1PLUS so we can display them differently in the listbox
		    set ::de1plus_profile([file rootname $d]) 1
		}

		unset -nocomplain profile
		catch {
			array set profile $filecontents
		}
		if {[info exists profile(profile_title)] != 1} {
			msg -WARNING "Corrupt profile file in profile_directories: '$d'"
			#continue
		}

		if {[ifexists profile(profile_hide)] == 1} {
			if {$show_hidden != 1} {
				continue
			}
		}

		set rootname [file rootname $d]

		if {$rootname == "CVS" || $rootname == "example"} {
			continue
		}		

		lappend dd $rootname
	}

	return [lsort -dictionary -increasing $dd]
}

proc delete_selected_profile {} {

	set w $::globals(profiles_listbox)
	if {[$w curselection] == ""} {
		msg -NOTICE "No profile has yet been tapped by the user to delete, so doing nothing"
		return
	}
	set profile $::profile_number_to_directory([$w curselection]) 

	set fn "[homedir]/profiles/${profile}.tcl"
	msg -NOTICE "About to delete profile: '$fn'"

	if {$profile == "default"} {
		msg -NOTICE "cannot delete default profile"
		return
	}
	#return

	file delete $fn
	set ::settings(profile) "default"
	fill_profiles_listbox 
	#preview_profile 

}


# the checkbox character is not available in all fonts, so we use an X instead then
proc checkboxchar {} {
	if {[language] == "ar" || [language] == "he"} {
		return "X"
	}

	return "\u2713"
}

proc bluetooth_character {} {
	if {[language] == "ar" || [language] == "he"} {
		return "BLE:"
	}

	return "\uE018"
}

proc thermometer_character {} {
	if {[language] == "ar" || [language] == "he"} {
		return "T:"
	}

	return "\uF2C9"
}

proc scale_character {} {
	if {[language] == "ar" || [language] == "he"} {
		return "SCALE:"
	}

	return "\uF515"
}

proc usb_character {} {
	if {[language] == "ar" || [language] == "he"} {
		return "USB:"
	}

	return "\uE01A"
}

proc wifi_character {} {
	if {[language] == "ar" || [language] == "he"} {
		return "WIFI:"
	}

	return "\uE019"
}

#set de1_device_list {}
proc fill_ble_listbox {} {

	set widget $::ble_listbox_widget
	$widget delete 0 99999
	set cnt 0
	set current_ble_number 0

	set one_selected 0
	foreach d [lsort -dictionary -increasing $::de1_device_list] {
		set addr_raw [dict get $d address]
		set name [dict get $d name]
		set type [dict get $d type]

		set display_addr $addr_raw
		if { $type == "ble" } { 
			set icon [bluetooth_character]
			set display_addr [string range $addr_raw 9 13]
		} elseif { $type == "usb" } {
			set icon [usb_character]
		} elseif { $type == "wifi" } {
			set icon [wifi_character]
		} else {
			set icon "?${type}?"
		}

		if {$addr_raw == [ifexists ::settings(bluetooth_address)]} {
			$widget insert $cnt " \[[checkboxchar]\] $icon $name ($display_addr)"
			set one_selected 1
		} else {
			$widget insert $cnt " \[   \] $icon $name ($display_addr)"
		}

		if {[ifexists ::settings(bluetooth_address)] == $addr_raw} {
			set current_ble_number $cnt
		}
		incr cnt
	}

	set ::de1_needs_to_be_selected 0
	if {[llength $::de1_device_list] > 0 && $one_selected == 0} {
		set ::de1_needs_to_be_selected 1
	}

	# john - probably makes sense for "pair" to occur on item tap
	make_current_listbox_item_blue $widget
}

proc remove_peripheral {address} {

	set newdict {}
	foreach d $::peripheral_device_list {
		if {[dict get $d address] != $address} {
			lappend newdict $d
		}
	}
	set ::peripheral_device_list $newdict
}

proc fill_peripheral_listbox {} {

	set widget $::ble_scale_listbox_widget

	$widget delete 0 99999
	set cnt 0
	set current_ble_number 0

	# count peripherals with the same name, so we can differentiate them in the listbox if needed
	foreach d $::peripheral_device_list {
		set name [dict get $d name]
		if {[info exists peripherals_seen($name)] == 1} {
			incr peripherals_seen($name)
		} else {
			set peripherals_seen($name) 1
		}
	}


	set one_selected 0
	foreach d $::peripheral_device_list {
		set addr [dict get $d address]
		set name [dict get $d name]
		set connectiontype [dict get $d connectiontype]
		set devicetype [dict get $d devicetype]
		set family [dict get $d devicefamily]
		set icon "UNKN:"

		if {$devicetype eq "thermometer"} {
			set icon [thermometer_character]
		} elseif {$devicetype eq "scale"} {
			set icon [scale_character]
		} elseif {$connectiontype eq "ble"} {
			set icon [bluetooth_character]
		}

		if { $name eq "" } { set name $family }

		if {$peripherals_seen($name) > 1} {
			# this peripheral appears twice in a ble scan, so give the last two digits of the ble address to differentiate it
			set name "[string range $addr end-1 end]-$name"
		}

		if {$addr == [ifexists ::settings(scale_bluetooth_address)]} {
			$widget insert $cnt " \[[checkboxchar]\] $icon $name"
			set one_selected 1
		} else {
			$widget insert $cnt " \[   \] $icon $name"
		}

		if {[ifexists ::settings(scale_bluetooth_address)] == $addr} {
			set current_ble_number $cnt
		}

		incr cnt
	}

	$widget selection set $current_ble_number;
	
	set ::peripheral_needs_to_be_selected 0
	if {[llength $::de1_device_list] > 0 && $one_selected == 0} {
		set ::peripheral_needs_to_be_selected 1
	}

	make_current_listbox_item_blue $widget
}

proc profile_type_text {} {
	set in $::settings(settings_profile_type)
	if {$in == "settings_2a"} {
		return [translate "Pressure profile"]
	} elseif {$in == "settings_2b"} {
		return [translate "Flow profile"]
	} elseif {$in == "settings_2c"} {
		return [translate "Advanced profile"]
	} else {
		return [translate "Profile"]
	}
}

proc array_keys_sorted_by_val {arrname {sort_order -increasing}} {
	upvar $arrname arr
	foreach k [array names arr] {
		set k2 "$arr($k) $k"
		#set k2 "[format {"%0.12i"} $arr($k)] $k"
		set t($k2) $k
	}
	
	set toreturn {}

	set keys [lsort $sort_order -dictionary [array names t]]
	foreach k $keys {
		set v $t($k)
		lappend toreturn $v
	}
	return $toreturn
}

proc fill_specific_profiles_listbox { widget selected_profile_name hide_mode} {
	$widget delete 0 99999

	set selected_profile_number 0
	set cnt 0
	set grouping ""

	unset -nocomplain ::profile_number_to_directory

	foreach d [profile_directories] {

		unset -nocomplain profile
		catch {
			set fn "[homedir]/profiles/$d.tcl"

			array set profile [encoding convertfrom utf-8 [read_binary_file $fn]]
		}

		set profile_to_title($d) [translate [ifexists profile(profile_title)]]
	}

	set profiles [array_keys_sorted_by_val profile_to_title]

	foreach d $profiles {

		set fn "[homedir]/profiles/${d}.tcl"
		unset -nocomplain profile
		catch {
			array set profile [encoding convertfrom utf-8 [read_binary_file $fn]]
		}

		if {[info exists profile(profile_title)] != 1} {
			msg -WARNING "Corrupt profile file in choices: '$d'"
			#continue
			set profile(profile_title) "$d \u2639 \u2639 \u2639"
		}


		# experimental feature to also load god shots with profiles
		# if {$profile(profile_title) == "Default" || $profile(profile_title) == "Gentle and sweet"} {
		# 	set profile(profile_title) "$d \u2665"
		# }


		set ptitle $profile(profile_title)

		set pcnt [ifexists ::profile_shot_count($d)]

		if {[language] != "en" && [ifexists profile(profile_language)] == "en" && [ifexists profile(author)] == "Decent"} {
			set p [translate $ptitle]
		} else {
			set p $ptitle
		}

		if {$hide_mode != 1} {
			if {[ifexists profile(profile_hide)] == 1} {
				# hide this profile if it's marked to be hidden, unless we're un the profile_hide edit mode, in which case we show all profiles
				continue
			}
			if {$pcnt != ""} {
				# mark the most frequently used profiles with a special symbol, to attract the eye to them
				set p "$p \u25C0"
			}

			set parts [split $p /]
			if {[llength $parts] > 1} {
				set this_group [lindex $parts 0]
				if {$this_group != $grouping} {
					set grouping $this_group
					$widget insert $cnt $this_group
					set ::profile_number_to_directory($cnt) $d
					incr cnt
				}
				set p " - [lindex $parts 1]"
	
			} else {
			}
	
		} else {
			# if editing what profiles to show, then use a check or empty box, to indicate which profiles will be shown

			if {[ifexists profile(profile_hide)] == 1} {
				if {[language] == "he"} {
					set p "\[   \] $p"
				} else {
					set p "\u2610 $p"
				}
			} else {
				if {[language] == "he"} {
					set p "\[X\] $p"
				} else {
					set p "\u2612 $p"
				}
			}

		}

		$widget insert $cnt $p
		set ::profile_number_to_directory($cnt) $d
	

		if {[string tolower $selected_profile_name] == [string tolower [ifexists profile(profile_title)]]} {
			set selected_profile_number $cnt
		} elseif {[language] != "en"} {
			if {[string tolower $selected_profile_name] == [string tolower [translate [ifexists profile(profile_title)]]]} {
				set selected_profile_number $cnt
			}
		}

		incr cnt
	}

	return $selected_profile_number
}


proc fill_profiles_listbox {} {

	# use this variable to prevent triggering preview_profile for each profile as it gets added to the listbox.  Tk would otherwise do this for each profile as its added to the listbox
	set ::filling_profiles 1

	set widget $::globals(profiles_listbox)
	set ::settings(profile_to_save) $::settings(profile)

	set ::current_profile_number [fill_specific_profiles_listbox $widget $::settings(profile) [ifexists ::profiles_hide_mode]]

	$widget selection set $::current_profile_number;
	#set ::globals(profiles_listbox) $widget
	make_current_listbox_item_blue $widget 
	preview_profile 
	$widget yview $::current_profile_number
	unset -nocomplain ::filling_profiles 
}

proc fill_languages_listbox {} {

	set widget $::languages_widget

	$widget delete 0 99999
	set cnt 0
	set current_profile_number 0

	# on android we can automatically detect the language from the OS setting, and this is the preferred way to go
	$widget insert $cnt [translate Automatic]
	incr cnt

	set current 0

	foreach {code desc} [translation_langs_array] {

		if {$::settings(language) == $code} {
			set current $cnt
		}
		$widget insert $cnt "$desc"
		incr cnt
	}

	$widget selection set $current;
	make_current_listbox_item_blue $::languages_widget

	$::languages_widget yview $current
}

proc highlight_extension {} {
	set stepnum [$::extensions_widget curselection]	
	if {$stepnum == ""} {
		set ::extension_highlighted -1
		return
	}
	if { [info exists ::extension_highlighted] } {
		if { $::extension_highlighted == $stepnum } {
			set plugin [lindex [available_plugins] $stepnum]
			plugins toggle $plugin
			
			fill_extensions_listbox
			$::extensions_widget selection set $stepnum
			make_current_listbox_item_blue $::extensions_widget
		} else {
			set ::extension_highlighted $stepnum
		}
	} else {
		set ::extension_highlighted $stepnum
	}

	set plugin [lindex [available_plugins] $stepnum ]

	if {[info exists ::plugins::${plugin}::ui_entry] && [set ::plugins::${plugin}::ui_entry] != ""} {
		canvas_show "$::extensions_settings $::extensions_settings_button"
	} else {
		canvas_hide "$::extensions_settings $::extensions_settings_button"
		msg -WARNING "Plugin" $plugin "Does not have a uientry"
	}

	set description ""


	foreach {name value} { "Version:" version "Author:" author "Contact:" contact "\n" description} {
		set conf [set ::plugins::${plugin}::${value}]
		if { $conf != {} } {
			append description "[translate $name] $conf\n"
		}
	}
	.can itemconfigure $::extensions_metadata -text $description

	fill_extensions_listbox
	$::extensions_widget selection set $stepnum;
	make_current_listbox_item_blue $::extensions_widget
}

proc fill_plugin_settings {} {
	set stepnum [$::extensions_widget curselection]
	if {$stepnum == ""} {
		borg toast [translate "No extension selected"]
		return
	}

	set plugin [lindex [available_plugins] $stepnum]

	if {[info exists ::plugins::${plugin}::ui_entry] && [set ::plugins::${plugin}::ui_entry] != ""} {
		set next_page [set ::plugins::${plugin}::ui_entry]
		page_to_show_when_off $next_page
	}
}

proc fill_extensions_listbox {} {

	set widget $::extensions_widget

	set stepnum [$::extensions_widget curselection]

	$widget delete 0 99999
	set cnt 0
	set current 0

	foreach {plugin} [available_plugins] {
		if {[plugin_enabled $plugin]} {
			if {[language] == "he"} {
				set p "\[X\] "
			} else {
				set p "\u2612 "
			}
		} else {
			if {[language] == "he"} {
				set p "\[   \] "
			} else {
				set p "\u2610 "
			}
		}
		
		if { [info exists ::plugins::${plugin}::name ] && [subst \$::plugins::${plugin}::name] ne "" } {
			set plugin_name [subst \$::plugins::${plugin}::name]
		} else {
			set plugin_name $plugin
		}

		$widget insert $cnt "$p $plugin_name"
		incr cnt
	}

	$::extensions_widget yview $current

	if {$stepnum == ""} {
		canvas_hide "$::extensions_settings $::extensions_settings_button"
	} else {
		$::extensions_widget selection set $stepnum;
		make_current_listbox_item_blue $::extensions_widget
	}
}

proc fill_advanced_profile_steps_listbox {} {

	set widget $::advanced_shot_steps_widget
	set cs [ifexists ::current_step_number]
	$widget delete 0 99999
	set cnt 0
	set current_profile_number 0

	foreach step $::settings(advanced_shot) {
		unset -nocomplain props
		array set props $step

		set name $props(name)
		$widget insert $cnt "[expr {1 + $cnt}]. $name"
		incr cnt
	}
	
	if {$cs == "" || $cs > [$::advanced_shot_steps_widget index end]} {
		$::advanced_shot_steps_widget selection set 0;
		set ::current_step_number 0
	} else {
		$::advanced_shot_steps_widget selection set $cs;
	}

	load_advanced_profile_step 1
	make_current_listbox_item_blue $::advanced_shot_steps_widget
	update idletasks
}

proc load_language {} {
	set stepnum [$::languages_widget curselection]
	if {$stepnum == ""} {
		return
	}

	if {$stepnum == 0} {
		set ::settings(language) ""
	} else {
		set ::settings(language) [lindex [translation_langs_array] [expr {($stepnum * 2) - 2}] ]
	}

	make_current_listbox_item_blue $::languages_widget

}

proc load_advanced_profile_step {{force 0}} {

	if {$::de1(current_context) != "settings_2c" && $force == 0} {
		msg -DEBUG "returning load_advanced_profile_step"
		return 
	}

	set stepnum [$::advanced_shot_steps_widget curselection]
	if {$stepnum == ""} {
		#set stepnum
		return
	}

	set ::current_step_number $stepnum
	#set stepnum [current_adv_step]

	unset -nocomplain ::current_adv_step
	# max flow / max pressure are not always set, so we set it now
	array set ::current_adv_step {max_flow_or_pressure 0 max_flow_or_pressure_range 0.6}

	# Max weight is not always set, so we set it here
	array set ::current_adv_step {weight 0.0}

	array set ::current_adv_step [lindex $::settings(advanced_shot) $stepnum]

	make_current_listbox_item_blue $::advanced_shot_steps_widget

	set ::profile_step_name_to_add $::current_adv_step(name)
	set ::current_step_number $stepnum
}

proc current_adv_step {} {
	return $::current_step_number

	set stepnum [$::advanced_shot_steps_widget curselection]
	if {$stepnum == ""} {
		msg -DEBUG "current_adv_step: blank seleted"
		set stepnum 0
	}
	msg -DEBUG "current_adv_step: stepnum: $stepnum"
	return $stepnum
}

proc change_current_adv_shot_step_name {} {
	set ::current_adv_step(name) "$::profile_step_name_to_add"
	save_current_adv_shot_step
	fill_advanced_profile_steps_listbox
}

proc save_current_adv_shot_step {} {
	set ::settings(advanced_shot) [lreplace $::settings(advanced_shot) [current_adv_step] [current_adv_step]  [array get ::current_adv_step]]

	profile_has_changed_set
	# for display purposes, make the espresso temperature be equal to the temperature of the first step in the advanced shot
	array set first_step [lindex $::settings(advanced_shot) 0]
	set ::settings(espresso_temperature) [ifexists first_step(temperature)]
}

proc delete_current_adv_step {} {

	if {[$::advanced_shot_steps_widget index end] == 1} {
		# we don't allow deleting the only step, because that leads to weird UI issues.
		msg -NOTICE "not deleting step because there is only one advanced step at the moment"
		return
	}

	set ::settings(advanced_shot) [lreplace $::settings(advanced_shot)  [current_adv_step] [current_adv_step]]

	msg -DEBUG "delete_current_adv_step: deleting"
	set ::current_step_number 0
	$::advanced_shot_steps_widget selection set $::current_step_number;
	$::advanced_shot_steps_widget activate $::current_step_number;
	fill_advanced_profile_steps_listbox
	#make_current_listbox_item_blue $::advanced_shot_steps_widget
}

# inserts a new step immediately after the currently seleted one, with all the same settings except for a different name
proc add_to_current_adv_step {} {

	# don't add more than the maximum number of steps that the espresso machine can handle
	if {[llength $::settings(advanced_shot)] >= 20} {
		return
	}

	set newlist {} 
	set cnt 0
	set stepnum [current_adv_step]
	set name $::profile_step_name_to_add
	if {$name == ""} {
		set name [translate "step"]
	}
	foreach s $::settings(advanced_shot) {
		lappend newlist $s
		if {$cnt == $stepnum} {
			array set x $s
			set x(name) $name
			lappend newlist [array get x]
		}
		incr cnt
	}

	if {$newlist == {}} {
		set newlist [list [list name $name]]
	}

	set ::settings(advanced_shot) $newlist
	fill_advanced_profile_steps_listbox

	#$::advanced_shot_steps_widget selection set $stepnum;
	$::advanced_shot_steps_widget selection clear $::current_step_number;
	incr ::current_step_number
	$::advanced_shot_steps_widget selection set $::current_step_number;
	$::advanced_shot_steps_widget activate $::current_step_number;
#	$::advanced_shot_steps_widget activate $stepnum;
	make_current_listbox_item_blue $::advanced_shot_steps_widget

}


proc save_new_tablet_skin_setting {} {
	set ::settings(skin) [$::globals(tablet_styles_listbox) get [$::globals(tablet_styles_listbox) curselection]]
}


proc preview_tablet_skin {} {
	
	if {$::de1(current_context) != "tabletstyles"} {
		return 
	}


	msg -DEBUG "preview_tablet_skin (entry)"
	set w $::globals(tablet_styles_listbox)
	if {[$w curselection] == ""} {
		msg -DEBUG "preview_tablet_skin: no current skin selection"
		#set w 
		#set skindir [$w get $::current_skin_number]
		#return
		msg -DEBUG "preview_tablet_skin ::current_skin_number: $::current_skin_number"
		$w selection set $::current_skin_number
	}


	set skindir [lindex [skin_directories] [$w curselection]]
	set ::settings(skin) $skindir

	set fn "[homedir]/skins/$skindir/${::screen_size_width}x${::screen_size_height}/icon.jpg"
	if {[file exists $fn] != 1} {
    	catch {
    		file mkdir "[homedir]/skins/$skindir/${::screen_size_width}x${::screen_size_height}/"
    	}

		msg -DEBUG "preview_tablet_skin: creating $fn"
        set rescale_images_x_ratio [expr {$::screen_size_height / 1600.0}]
        set rescale_images_y_ratio [expr {$::screen_size_width / 2560.0}]

		set src "[homedir]/skins/$skindir/2560x1600/icon.jpg"
		catch {
			$::table_style_preview_image read $src
			photoscale $::table_style_preview_image $rescale_images_y_ratio $rescale_images_x_ratio
			$::table_style_preview_image write $fn  -format {jpeg -quality 90}
		}

	} else {
		set fn "[homedir]/skins/$skindir/${::screen_size_width}x${::screen_size_height}/icon.jpg"
		$::table_style_preview_image read $fn
	}

	make_current_listbox_item_blue $::globals(tablet_styles_listbox)
}

proc preview_history {w args} {
	catch {
		set profile [lindex [history_directories] [$w curselection] [$w curselection]]
		msg -DEBUG "preview_history: history item: $profile [$w curselection]"

		set fn "[homedir]/history/${profile}.tcl"

		# need to code this
		array set props [encoding convertfrom utf-8 [read_binary_file $fn]]

		array set ::settings $props(settings)

		espresso_elapsed length 0; espresso_elapsed append $props(espresso_elapsed)
		espresso_pressure length 0; espresso_pressure append $props(espresso_pressure)
		espresso_flow length 0; espresso_flow append $props(espresso_flow)
		espresso_flow_weight length 0; espresso_flow_weight append $props(espresso_flow_weight)
		espresso_temperature_basket length 0; espresso_temperature_basket append $props(espresso_temperature_basket)
		espresso_temperature_mix length 0; espresso_temperature_mix append $props(espresso_temperature_mix)

		make_current_listbox_item_blue $::globals(history_listbox)
		
	}
}

proc save_settings_and_ask_to_restart_app {} {
	save_settings; 
	message_page [translate "Please quit and restart this app to apply your changes."] [translate "Quit"];
}

proc message_page {msg buttonmsg {longertxt {}} } {

	if {[catch {

		if {$longertxt == ""} {
			.can coords $::message_label [list [rescale_x_skin 1280] [rescale_y_skin 800]]
		} else {
			# if there is a longer message, then move the larger font label up, to make room for it
			.can coords $::message_label [list [rescale_x_skin 1280] [rescale_y_skin 550]]
		}

		.can itemconfigure $::message_label -text $msg
		.can itemconfigure $::message_button_label -text $buttonmsg
		.can itemconfigure $::message_longertxt -text $longertxt
		set_next_page off message; 
		page_show message
	} err] != 0} {
		msg -ERROR "message_page failed because: '$err'"
	}

}


#set ::infopage_label [add_de1_text "infopage" 1280 750 -text "" -font Helv_15_bold -fill "#2d3046" -justify "center" -anchor "center" -width 900]
#set ::infopage_button_label [add_de1_text "infopage" 1280 1090 -text [translate "Ok"] -font Helv_10_bold -fill "#fAfBff" -anchor "center"]
#set ::infopage_button [add_de1_button "infopage" {say [translate {Ok}] $::settings(sound_button_in); set_next_page off off} 980 990 1580 1190 ""]


proc info_page {msg buttonmsg {nextpage {}}} {
	if {[catch {
		.can itemconfigure $::infopage_label -text $msg
		.can itemconfigure $::infopage_button_label -text $buttonmsg
		set_next_page off infopage
		page_show off

		if {$nextpage != ""} {
			msg -INFO "Setting next page after info to: '$nextpage'"
			set_next_page off $nextpage
		} else {
			set_next_page off off
		}
	} err] != 0} {
		msg -ERROR "info_page failed because: '$err'"
	}
}

proc version_page {msg buttonmsg} {
	if {[catch {
		.can itemconfigure $::versionpage_label -text $msg
		.can itemconfigure $::versionpage_button_label -text $buttonmsg
		set_next_page off versionpage; 
		page_show off
	} err] != 0} {
		msg -ERROR "info_page failed because: '$err'"
	}
}

proc change_bluetooth_device {} {


	################################################################################################################

	set w $::ble_listbox_widget
	#set ::settings(profile) [$::globals(profiles_listbox) get [$::globals(profiles_listbox) curselection]]
	if {[$w curselection] == ""} {
		# no current selection
		msg -DEBUG "change_bluetooth_device: no BLE selection"
		return ""
	}

	set selection_index [$w curselection]
	set dic [lindex $::de1_device_list $selection_index]
	set addr [dict get $dic address]

	if {$addr == $::settings(bluetooth_address)} {
		# if no change in setting, then disconnect/reconnect.
		#return

		################################################################################################################
		# prevent rapid changing of DE1 bluetooth setting, because that can cause multiple connections to be made to the same DE1
		if {[ifexists ::globals(changing_bluetooth_device)] == 1} {
			msg -DEBUG "change_bluetooth_device: already changing_bluetooth_device"
			return
		}

		msg -NOTICE "change_bluetooth_device: reconnecting to DE1"

	}

	set ::globals(changing_bluetooth_device) 1
	after 5000 {set ::globals(changing_bluetooth_device) 0}

	if {$addr != $::settings(bluetooth_address)} {
		# if no change in setting, then disconnect/reconnect.
		set ::settings(bluetooth_address) $addr
		save_settings
	}

	# disconnect (if necessary) and reconnect to the DE1 now
	ble_connect_to_de1

	fill_ble_listbox
}

proc change_scale_bluetooth_device {} {
	set w $::ble_scale_listbox_widget

	if {$w == ""} {
		return
	}

	set selection_index [$w curselection]
	if {$selection_index == ""} {
		return
	}

	puts "selection_index: $selection_index"

	msg "selected item" 	
	set dic [lindex $::peripheral_device_list $selection_index]
	set addr [dict get $dic address]
	set name [dict get $dic name]
	set connectiontyte [dict get $dic connectiontype]
	set devicetype [dict get $dic devicetype]
	set devicefamily [dict get $dic devicefamily]

	if { $name == "" } {
		set name $devicefamily
	}

	if {$connectiontyte ne "ble"} {
		msg -WARNING "Non BLE peripheral requested for connect. Damn!"
		return
	}

	msg -INFO  "selected $devicetype $name @ $addr"

	if {$devicetype eq "scale"} {
		set ::settings(scale_bluetooth_address) $addr
		set ::settings(scale_bluetooth_name) $name
		set ::settings(scale_type) $devicefamily
		msg "set scale type to: '$::settings(scale_type)' $addr"

		set handle $::de1(scale_device_handle)
		if {$handle != "" && $handle != 0} {
			set ::de1(scale_device_handle) 0
			#set ::de1(cmdstack) {};
			#set ::currently_connecting_scale_handle 0
			ble close $handle
			ble_connect_to_scale
		}  else {
			ble_connect_to_scale
		}

		#after 500 

	} else {
		msg -WARNING "Non scale peripheral requested for connect. Damn!"
	}

	save_settings
	fill_peripheral_listbox

}


proc select_profile { profile } {
	set fn "[homedir]/profiles/${profile}.tcl"
	set ::settings(profile) $profile
	set ::settings(profile_notes) ""
	
	# for importing De1 profiles that don't have this feature.
	set ::settings(preinfusion_flow_rate) 4

	# Disable limits by default
	set ::settings(maximum_pressure) 0
	set ::settings(maximum_flow) 0

	# 
	unset -nocomplain ::settings(profile_video_help)

	load_settings_vars $fn

	set ::settings(profile_filename) $profile

	if {[language] != "en" && $::settings(profile_language) == "en" && [ifexists ::settings(author)] == "Decent"} {
		# the first time this profile is loaded into another language, we should try to translate the
		# title and notes to the local language
		set ::settings(profile_notes) [translate $::settings(profile_notes)]
		set ::settings(profile_title) [translate $::settings(profile_title)]
		set ::settings(profile_language) [language]
	}
	set ::settings(original_profile_title) $::settings(profile_title)

	set ::settings(settings_profile_type) [::profile::fix_profile_type $::settings(settings_profile_type)]
	set ::settings(profile) $::settings(profile_title)

	::profile::sync_from_legacy

	update_onscreen_variables
	profile_has_not_changed_set

	# as of v1.3 people can start an espresso from the group head, which means their currently selected 
	# profile needs to sent right away to the DE1, in case the person taps the GH button to start espresso w/o leaving settings
	send_de1_settings_soon
}


set preview_profile_counter 0
proc preview_profile {} {
	if {$::de1(current_context) != "settings_1"} {
		return 
	}

	if {[ifexists ::filling_profiles] == 1} {
		# use this variable to prevent triggering preview_profile for each profile as it gets added to the listbox.  Tk would otherwise do this for each profile as its added to the listbox
		return
	}


	incr ::preview_profile_counter
	set w $::globals(profiles_listbox)

    #$w selection set active

	#set ::settings(profile) [$::globals(profiles_listbox) get [$::globals(profiles_listbox) curselection]]
	if {[$w curselection] == ""} {
		$w selection set $::current_profile_number
		msg -DEBUG "preview_profile: setting profile to $::current_profile_number"
		#set profile $::current_profile_number
	}

	#set profile [$w get [$w curselection]]

	#set profile [lindex [profile_directories] [$w curselection]]
	set profile $::profile_number_to_directory([$w curselection]) 

	
	set fn "[homedir]/profiles/${profile}.tcl"

	if {[ifexists ::profiles_hide_mode] == 1} {

		catch {
			array set thisprofile [encoding convertfrom utf-8 [read_binary_file $fn]]
		}

		if {[info exists thisprofile(profile_title)] != 1} {
			msg -WARNING "Corrupt profile file to preview: '$d'"
			return
		}


		if {[ifexists thisprofile(profile_hide)] == 1} {
			set thisprofile(profile_hide) 0
		} else {
			set thisprofile(profile_hide) 1
		}
		save_array_to_file thisprofile $fn 
		set ::filling_profiles 1

		# need to save and restore the scrollbar value, because we're refilling the listbox to show hide/show state change
		set oldscrollbarbalue [$::profiles_scrollbar get]
		fill_profiles_listbox
		unset -nocomplain ::filling_profiles 

		$::profiles_scrollbar set $oldscrollbarbalue
		listbox_moveto $::globals(profiles_listbox) $::profiles_slider $oldscrollbarbalue
		return

	}

	select_profile $profile

	make_current_listbox_item_blue $::globals(profiles_listbox)
	
	#set ::settings(profile_notes) [clock seconds]
}


proc send_de1_settings_soon  {} {

	# if they have a GHC then they can press it while in the settings page, and expect the profile they just select to be in place.  Thus we bluetooth send 
	# profiles as they tap on them, but only if they have a GHC. No point in sending bluetooth commands that are not needed on non-GHC machines.
	if {[ghc_required] == 1} {

		if {[info exists ::save_settings_to_de1_id] == 1} {
			after cancel $::save_settings_to_de1_id; 
			unset -nocomplain ::save_settings_to_de1_id
			msg -NOTICE "send_de1_settings_soon: cancelled extra de1_send"
		}

		set ::save_settings_to_de1_id [after 500 save_settings_to_de1]
	}
}



proc profile_has_changed_set_colors {} {

	if {$::settings(profile_has_changed) == 1} {
		update_de1_explanation_chart
		if {[info exists ::globals(widget_profile_name_to_save)] == 1} {		
			catch {
				$::globals(widget_profile_name_to_save) configure -bg #ffe3e3
			}
		}

		catch {
			.can itemconfigure $::globals(widget_current_profile_name) -fill $::de1(widget_current_profile_name_color_normal)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name1) -fill $::de1(widget_current_profile_name_color_normal)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name2) -fill $::de1(widget_current_profile_name_color_normal)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso) -fill $::de1(widget_current_profile_name_color_normal)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso1) -fill $::de1(widget_current_profile_name_color_normal)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso2) -fill $::de1(widget_current_profile_name_color_normal)
		}
	} else {
		if {[info exists ::globals(widget_profile_name_to_save)] == 1} {		
			# this indicates to the user that the profile has changed or not
			catch {
				$::globals(widget_profile_name_to_save) configure -bg #fbfaff
			}
		}

		# this is displayed on the main Insight skin page
		catch {
			.can itemconfigure $::globals(widget_current_profile_name) -fill $::de1(widget_current_profile_name_color_changed)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name1) -fill $::de1(widget_current_profile_name_color_changed)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name2) -fill $::de1(widget_current_profile_name_color_changed)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso) -fill $::de1(widget_current_profile_name_color_changed)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso1) -fill $::de1(widget_current_profile_name_color_changed)
		}
		catch {
			.can itemconfigure $::globals(widget_current_profile_name_espresso2) -fill $::de1(widget_current_profile_name_color_changed)
		}
	}
}

proc profile_has_changed_set args {

	# if one the scroll bars has been touched by a human (not by the page display code) then mark the profile as having been changed
	if {[lsearch -exact [stackprocs] "page_show"] == -1 && [lsearch -exact [stackprocs] "update_onscreen_variables"] == -1} {
		set ::settings(profile_has_changed) 1
	} else {
		# pass 
	}

	#profile_has_changed_set_colors
}


proc profile_has_not_changed_set args {
	set ::settings(profile_has_changed) 0
}

proc load_settings_vars {fn} {


	msg -NOTICE "load_settings_vars $fn"

	# default to no temp steps, so as to migrate older profiles that did not have this setting, and not accidentally enble this feature on them
	unset -nocomplain ::settings(espresso_temperature_steps_enabled) 

	# default value 
	set ::settings(final_desired_shot_volume_advanced_count_start) 0

	#error "load_settings_vars"
	# set the default profile type to use, this can be over-ridden by the saved profile
	set ::settings(settings_profile_type) "settings_2a"


	catch {
		foreach {k v} [encoding convertfrom utf-8 [read_binary_file $fn]] {
			#set ::settings($k) $v
			set temp_settings($k) $v
		}
	}


	if {[ifexists temp_settings(settings_profile_type)] == "settings_2c" && [ifexists temp_settings(final_desired_shot_weight)] != "" && [ifexists temp_settings(final_desired_shot_weight_advanced)] == "" } {
		msg -NOTICE "load_settings_vars: Using a default" \
			"for final_desired_shot_weight_advanced" \
			"from final_desired_shot_weight of" \
			[ifexists temp_settings(final_desired_shot_weight)]
		set temp_settings(final_desired_shot_weight_advanced) [ifexists temp_settings(final_desired_shot_weight)]
	}

	# pre-set the shot volume, to the shot weight, if importing an old shot definition that doesn't have a an end volume 
	if {[ifexists temp_settings(final_desired_shot_volume)] == ""} {
		msg -NOTICE "load_settings_vars: pre-set the shot volume,"\
			"to the shot weight, if importing an old shot definition" \
			"that doesn't have a an end volume"
		set temp_settings(final_desired_shot_volume) [ifexists temp_settings(final_desired_shot_weight)]
	}

	# properly reset beverage_type if not provided in the profile, o/w the beverage_type of the last profile with it
	#	defined will be persisted throughout all subsequent shots.
	if { ![info exists temp_settings(beverage_type)] } {
		set temp_settings(beverage_type) {}
	}
		
	if {[ifexists temp_settings(black_screen_saver)] == 1} {
		# we've moved the "black screen saver" feature from its own dedicated variable to now be a setting of "0 minutes" on the screen saver change timer
		# this line is simply for backward compatiblity, moving the old setting to a new one
		set temp_settings(final_desired_shot_volume) 0
		set temp_settings(saver_brightness) 0		
	}


	# we accidentally saved water temp in profiles for about a year and then decided we didn't want that, so remove it from profiles if it's there
	unset -nocomplain temp_settings(water_temperature) 

	catch {
		array set ::settings [array get temp_settings]
	}

	# john disabling LONG PRESS support as it appears to be buggy on tablets https://3.basecamp.com/3671212/buckets/7351439/messages/2566269076#__recording_2595312790
	set ::setting(disable_long_press) 1

	update_de1_explanation_chart


}

proc save_settings_vars {fn varlist} {

	set txt ""
	foreach k $varlist {
		if {[info exists ::settings($k)] == 1} {
			set v $::settings($k)
			append txt "[list $k] [list $v]\n"
		}
	}

	set success 0
	catch {
	    write_file $fn $txt
	    set success 1
	}
	return $success
}

proc profile_vars {} {
 	return { advanced_shot espresso_temperature_steps_enabled author espresso_hold_time preinfusion_time espresso_pressure espresso_decline_time pressure_end espresso_temperature espresso_temperature_0 espresso_temperature_1 espresso_temperature_2 espresso_temperature_3 settings_profile_type flow_profile_preinfusion flow_profile_preinfusion_time flow_profile_hold flow_profile_hold_time flow_profile_decline flow_profile_decline_time flow_profile_minimum_pressure preinfusion_flow_rate profile_notes final_desired_shot_volume final_desired_shot_weight final_desired_shot_weight_advanced tank_desired_water_temperature final_desired_shot_volume_advanced profile_title profile_language preinfusion_stop_pressure profile_hide final_desired_shot_volume_advanced_count_start beverage_type maximum_pressure maximum_pressure_range_advanced maximum_flow_range_advanced maximum_flow maximum_pressure_range_default maximum_flow_range_default}
}


proc set_profile_title_untitled {} {
	# if no name then give it a name which is just a number
	if {$::settings(profile_title) == ""} {
		incr ::settings(preset_counter)  
		save_settings

		set ::settings(profile_title) [subst {[translate "Untitled"] $::settings(preset_counter)}]
	}
}

proc save_profile {} {
	if {$::settings(profile_title) == [translate "Saved"]} {
		return
	}

	# if no name then give it a name which is just a number
	set_profile_title_untitled

	#set profile_vars { advanced_shot author espresso_hold_time preinfusion_time espresso_pressure espresso_decline_time pressure_end espresso_temperature settings_profile_type flow_profile_preinfusion flow_profile_preinfusion_time flow_profile_hold flow_profile_hold_time flow_profile_decline flow_profile_decline_time flow_profile_minimum_pressure preinfusion_flow_rate profile_notes water_temperature final_desired_shot_volume final_desired_shot_weight final_desired_shot_weight_advanced tank_desired_water_temperature final_desired_shot_volume_advanced profile_title profile_language preinfusion_stop_pressure}
	#set profile_name_to_save $::settings(profile_to_save) 

	if {$::settings(settings_profile_type) == "settings_2c2"} {
		# if on the LIMITS tab, indicate that this is settings_2c (aka "advanced") shot as part of the OK button process
		set ::settings(settings_profile_type) "settings_2c"
		
	}


	if {[ifexists ::settings(original_profile_title)] == $::settings(profile_title)} {
		set profile_filename $::settings(profile_filename) 
	} else {
		# if they change the description of the profile, then save it to a new name
		# replace prior usage of unformatted seconds with sanitized profile name and append with formatted time if file exists
		set profile_filename [::profile::filename_from_title $::settings(profile_title)]
		set profile_timestamp [clock format [clock seconds] -format %Y%m%d_%H%M%S] 
		if {[file exists "[homedir]/profiles/${profile_filename}.tcl"] == 1} {
			append profile_filename "_" $profile_timestamp
		}
	}
	
	set fn "[homedir]/profiles/${profile_filename}.tcl"
	
	if {[write_file $fn ""] == 0} {
		set fn "[homedir]/profiles/${profile_timestamp}.tcl"
	}

	# set the title back to its title, after we display SAVED for a second
	# moves the cursor to the end of the seletion after showing the "saved" message.
	after 1000 "set ::settings(profile_title) \{$::settings(profile_title)\}; $::globals(widget_profile_name_to_save) icursor 999"

	# Save V2 of profiles in parallel
	::profile::save "[homedir]/profiles_v2/${profile_filename}.json"

	if {[save_settings_vars $fn [profile_vars]] == 1} {
		set ::settings(profile) $::settings(profile_title)

		fill_profiles_listbox 
		update_de1_explanation_chart
		set ::settings(profile_title) [translate "Saved"]
		profile_has_not_changed_set

	} else {
		set ::settings(profile_title) [translate "Invalid name"]
	}

	profile_has_changed_set_colors
}

proc save_espresso_rating_to_history {} {
	#unset -nocomplain ::settings(history_saved)
	set ::settings(history_saved) 0
	save_this_espresso_to_history {} {}
}

::de1::event::listener::after_flow_complete_add \
	[lambda {event_dict} {
		save_this_espresso_to_history \
			[dict get $event_dict previous_state] \
			[dict get $event_dict this_state] \
		} ]



proc save_this_espresso_to_history {unused_old_state unused_new_state} {
	msg -DEBUG "save_this_espresso_to_history (entry)"
	# only save shots that have at least 5 data points
	if {!$::settings(history_saved) && [espresso_elapsed length] > 5 && [espresso_pressure length] > 5 && $::settings(should_save_history) == 1} {

		#TODO disable once v2 shotfiles are stable
		#if {$::settings(create_legacy_shotfiles) == 1} {
			set espresso_data [::shot::create_legacy]
			set fn "[homedir]/history/[clock format $::settings(espresso_clock) -format "%Y%m%dT%H%M%S"].shot"
			write_file $fn $espresso_data
		#}

		set espresso_data [::shot::create]
		set fn "[homedir]/history_v2/[clock format $::settings(espresso_clock) -format "%Y%m%dT%H%M%S"].json"
		write_file $fn $espresso_data
		msg -NOTICE "Saved this espresso to history"

		set ::settings(history_saved) 1
	} else {
		msg -NOTICE "Not saved to history:" \
			"history_saved: $::settings(history_saved)" \
			"Time samples: [espresso_elapsed length]" \
			"Pres samples: [espresso_pressure length]" \
			"should_save_history: $::settings(should_save_history)"
	}
}

proc ghc_required {} {
	if {$::settings(ghc_is_installed) != 0 && $::settings(ghc_is_installed) != 1 && $::settings(ghc_is_installed) != 2 && $::settings(ghc_is_installed) != 4} {
		return 1
	}
	if {$::undroid == 1 && $::android == 0} {
		return 0
	}
	return 0
}

proc start_text_if_espresso_ready {} {
	set num $::de1(substate)
	set substate_txt $::de1_substate_types($num)
	if {$substate_txt == "ready" && $::de1(device_handle) != 0} {
		
		if {[ghc_required]} {
			# display READY instead of START, because they have to tap the group head to start, they cannot tap the tablet, due to UL compliance limits
			return [translate "READY"]
		}
		return [translate "START"]
	}
	return [translate "WAIT"]
}

proc restart_text_if_espresso_ready {} {
	set num $::de1(substate)
	set substate_txt $::de1_substate_types($num)
	if {$substate_txt == "ready" && $::de1(device_handle) != 0} {
		if {[ghc_required]} {
			# display READY instead of START, because they have to tap the group head to start, they cannot tap the tablet, due to UL compliance limits
			return [translate "READY"]
		}
		return [translate "RESTART"]
	}
	return [translate "WAIT"]

}

proc stop_text_if_espresso_stoppable {} {
	set num $::de1(substate)
	set substate_txt $::de1_substate_types($num)
	if {$substate_txt != "ending"} {
		return [translate "STOP"]
	}
	return [translate "WAIT"]

}


# TODO: this should probably be renamed.
proc espresso_history_save_from_gui {} {
	set num $::de1(substate)
	set substate_txt $::de1_substate_types($num)
	if {$substate_txt != "ready"} {
		set state [translate "WAIT"]
	} else {
#		if {$::settings(history_saved) != 1} { 
	#		set state [translate "SAVING"] 
		#} else {
		#}; 
		if {[ghc_required]} {
			# display READY instead of START, because they have to tap the group head to start, they cannot tap the tablet, due to UL compliance limits
			set state [translate "READY"]
		} else {
			set state [translate "RESTART"]
		}

	}
	#set state [translate "WAIT"]
	#save_this_espresso_to_history; 
	return $state
}

proc bar_or_off_text {num} {
	if {$num == 0} {
		return [translate "off"]
	} else {
		return [subst {$num [translate "bar"]}]
	}
}



proc preinfusion_seconds_text {num} {
	if {$num == 0} {
		return [translate "off"]
	} elseif {$num == 1} {
		return [subst {< $num [translate "second"]}]
	} else {
		return [subst {< $num [translate "seconds"]}]
	}
}

proc seconds_text {num} {
	if {$num == 0} {
		return [translate "off"]
	} elseif {$num == 1} {
		return [subst {$num [translate "second"]}]
	} elseif {$num == 60} {
		return [translate "1 minute"]
	} else {
		return [subst {$num [translate "seconds"]}]
	}
}


proc seconds_text_abbreviated {num} {
	if {$num == 0} {
		return [translate "off"]
	} elseif {$num == 1} {
		return [subst {$num [translate "sec"]}]
	} elseif {$num == 60} {
		return [translate "1 min"]
	} else {
		return [subst {$num [translate "sec"]}]
	}
}

proc screen_saver_change_minutes {num} {
	if {$num == 0} {
		set ::settings(saver_brightness) 0
		return [translate "Always black"]
	} else {
		return "[translate {Change image every:}] [minutes_text $num]"
	}
}

proc minutes_text {num} {
	if {$num == 0} {
		return [translate "off"]
	} elseif {$num == 60} {
		return [translate "1 hour"]
	} elseif {$num == 120} {
		return [translate "2 hours"]
	} elseif {$num == 1} {
		return [subst {$num [translate "minute"]}]
	} else {
		return [subst {$num [translate "minutes"]}]
	}
}

proc days_text {num} {
	if {$num == 0} {
		return [translate "immediately"]
	} elseif {$num == 30} {
		return [translate "One month"]
	} else {
		return [subst {$num [translate "days"]}]
	}
}

proc scentone_choice {english_aroma} {
	if {[lsearch -exact $::settings(scentone) $english_aroma] == -1} {
		return [translate $english_aroma]
	} else {
		return [subst {\[ \[ \[ [translate $english_aroma] \] \] \]}]
	}
}

proc scentone_toggle {english_aroma} {
	if {[lsearch -exact $::settings(scentone) $english_aroma] == -1} {
		lappend ::settings(scentone) $english_aroma
		set ::settings(scentone) [lsort $::settings(scentone)]
	} else {
		set ::settings(scentone) [lsort -unique [list_remove_element $::settings(scentone) $english_aroma]]
	}
	update_onscreen_variables
}

proc scentone_category {english_category} {

	set english_aroma_list $::scentone($english_category)

	foreach english_aroma $english_aroma_list {
		if {[lsearch -exact $::settings(scentone) $english_aroma] != -1} {
			return [subst {\[ \[ \[ [translate $english_category] \] \] \]}]
		}
	}
	return [translate $english_category]
}

proc scentone_selected { {category {}} } {

	set returnlist {}
	foreach selected $::settings(scentone) {
		if {$category == ""} {
			# if this is a complete list of all selected aromas
			lappend returnlist [translate $selected]
		} else {
			# if this is only the selected aromas for a subcategory
			if {[lsearch -exact $::scentone($category) $selected] != -1} {
				lappend returnlist [translate $selected]
			}
		}

	}

	if {$returnlist == "" } {
		if {$category == ""} {
			return [translate "Categories"]
		} else {
			return [subst {[translate $category]}]
		}
	}
	if {$category != ""} {
		return [subst {[translate $category] : [join [lsort $returnlist] ", "].}]
	} else {
		return [subst {[translate "Selected:"] [join [lsort $returnlist] ", "].}]
	}

}


proc scentone_translated_selection { } {

	set returnlist {}
	foreach selected $::settings(scentone) {
		lappend returnlist [translate $selected]
	}

	if {$returnlist == ""} {
		return ""
	}

	return [join [lsort $returnlist] ", "].
}

proc round_to_half_integer {in} {
	set r 0
	catch {
		set r [expr {int($in * 2) / 2.0}]
	}
	return $r
}



proc check_firmware_update_is_available {} {

	#if {$::settings(ghc_is_installed) != 0} {
		# ok to do v1.3 fw update
		#if {$::settings(force_fw_update) != 1} {
			#set ::de1(firmware_update_button_label) "Up to date"
			#return ""
		#}
	#} else {
		#if {$::settings(force_fw_update) != 1} {
		#	set ::de1(firmware_update_button_label) "Up to date"
		#	return ""
		#}
	#}

	if {[ifexists ::de1(firmware_crc)] == ""} {
		set ::de1(firmware_crc) [crc::crc32 -filename [fwfile]]
	}

	# obsolete method, comparing settings-saved CRC of last fw upload, to what DE1 reports as CRC
	if {($::de1(firmware_crc) != [ifexists ::settings(firmware_crc)]) && $::de1(currently_updating_firmware) == ""} {
		##obsolete - set ::de1(firmware_update_button_label) "Firmware update available"
	} else {
		# pass
	}

	set ::de1(firmware_update_button_label) "Up to date"

	# new method, directly comparing the incremented version number
	if {[ifexists ::de1(Firmware_file_Version)] != "" && [ifexists ::settings(firmware_version_number)] != ""} {
		if {[ifexists ::de1(Firmware_file_Version)] > [ifexists ::settings(firmware_version_number)]} {
			set ::de1(firmware_update_button_label) "Firmware update available"
		} elseif {[ifexists ::de1(Firmware_file_Version)] < [ifexists ::settings(firmware_version_number)]} {
			set ::de1(firmware_update_button_label) "Firmware downgrade available"
		}

	}



	return ""
}

proc firmware_update_eta_label {} {

	if {[info exists ::de1(firmware_update_start_time)] != 1} {
		return
	}

	set elapsed [expr {[clock milliseconds] - $::de1(firmware_update_start_time)}]
	set ::de1(firmware_update_eta) 0

	set percentage [expr {1.0 * ($::de1(firmware_bytes_uploaded)) / $::de1(firmware_update_size)}]

	if {$percentage >= 1 && $::de1(currently_updating_firmware) == 0} {
		#return "[translate {Turn your machine off and on again}]"
		return ""
	} elseif {$percentage < 0.003 } {
		# not enough data to give a good estimate yet
		return ""
	} else {
		set etamin [expr {round((($elapsed / $percentage) - $elapsed) / 60000)}]
		set etasec [expr {1 + round((($elapsed / $percentage) - $elapsed) / 1000)}]
		if {$etasec >=120} {
			return "$etamin [translate minutes]"
		} else {
			return "$etasec [translate seconds]"
		}
	}	
}


proc firmware_uploaded_label {} {


	if {($::de1(firmware_bytes_uploaded) == 0 || $::de1(firmware_update_size) == 0) && $::de1(currently_updating_firmware) != "1" && $::de1(currently_erasing_firmware) != "1"} {
		if {$::de1(firmware_crc) == [ifexists ::settings(firmware_crc)]} {
			return [translate "No update necessary"]
		}

		return ""
	} 

	if {$::de1(firmware_update_size) == 0 || $::de1(firmware_bytes_uploaded) == 0} {
		return "0.0%"
	}

	set percentage [expr {(100.0 * $::de1(firmware_bytes_uploaded)) / $::de1(firmware_update_size)}]
	if {$percentage >= 100 && $::de1(currently_updating_firmware) == 0} {
		#return "[translate {Turn your machine off and on again}]"
		return [translate "Done"]
	} else {
		return "[round_to_one_digits $percentage]%"
	}
}

proc de1_version_bleapi {} {
	array set ver $::de1(version)
	set c [ifexists ver(BLE_APIVersion)]
	if {$c == ""} {
		set c 0
	}
	return $c
}


proc de1_version_string {} {
	array set v $::de1(version)

	#set v(BLE_Sha) [clock seconds]

	#, APP=[package version de1app]	
	set version "BLE v[ifexists v(BLE_Release)].[ifexists v(BLE_Changes)].[ifexists v(BLE_Commits)], API v[ifexists v(BLE_APIVersion)], SHA=[ifexists v(BLE_Sha)]"
	if {[ifexists v(FW_Sha)] != [ifexists v(BLE_Sha)] && [ifexists v(FW_Sha)] != 0} {
		append version "\nFW v[ifexists v(FW_Release)].[ifexists v(FW_Changes)].[ifexists v(FW_Commits)], API v[ifexists v(FW_APIVersion)], SHA=[ifexists v(FW_Sha)]"
	}


	if {$::settings(firmware_sha) != "" && [ifexists v(BLE_Sha)] != "" && $::settings(firmware_sha) != [ifexists v(BLE_Sha)] } {
		after 5000 [list info_page "[translate {Your DE1 firmware has been upgraded}]\n\n$version" [translate "Ok"]]
	}
	
	array set modelarr [list 0 [translate "unknown"] 1 DE1 2 DE1+ 3 DE1PRO 4 DE1XL 5 DE1CAFE 6 DE1XXL 7 DE1XXXL]

	set brev ""
	if {[ifexists ::settings(cpu_board_model)] != ""} {
		set brev [expr {$::settings(cpu_board_model) / 1000.0}]
	}
	
	if {$brev != ""} {
		append version ", [translate pcb]=$brev"
	}
	if {[ifexists ::settings(machine_model)] != "" && [ifexists ::settings(machine_model)] != "0"} {
		append version ", [translate model]=[ifexists modelarr([ifexists ::settings(machine_model)])]"
	}

	if {[ifexists ::settings(firmware_version_number)] != ""} {
		append version ", [translate current]=[ifexists ::settings(firmware_version_number)]"
	}
	
	if {[ifexists ::de1(Firmware_file_Version)] != "" && [ifexists ::settings(firmware_version_number)] != "" && [ifexists ::de1(Firmware_file_Version)] != [ifexists ::settings(firmware_version_number)] } {
		append version ", [translate available]=[ifexists ::de1(Firmware_file_Version)]"
	}

	if { [package version de1app] ne ""  } {
		append version ", [translate app]=v[package version de1app] [app_updates_policy_as_text]"
	}

	#if { [app_updates_policy_as_text] ne ""  } {
	#	append version ", [translate {branch}]=[app_updates_policy_as_text]"
	#}
	
	if {[ifexists v(BLE_Sha)] != "" && $::settings(firmware_sha) != [ifexists v(BLE_Sha)] } {
		set ::settings(firmware_sha) $v(BLE_Sha)
		save_settings
	}

	return $version

	#return "HW=[ifexists v(BLEFWMajor)].[ifexists v(BLEFWMinor)].[ifexists v(P0BLECommits)].[ifexists v(Dirty)] API=[ifexists v(APIVersion)] SHA=[ifexists v(BLESha)]"
}

# spreadsheet to calculate this calculated from CAD, from Mark Kelly, and is in /d/admin/src/
proc water_tank_level_to_milliliters {mm} {

	set mm_to_ml [list \
		0 \
		16	\
		43	\
		70	\
		97	\
		124	\
		151	\
		179	\
		206	\
		233	\
		261	\
		288	\
		316	\
		343	\
		371	\
		398	\
		426	\
		453	\
		481	\
		509	\
		537	\
		564	\
		592	\
		620	\
		648	\
		676	\
		704	\
		732	\
		760	\
		788	\
		816	\
		844	\
		872	\
		900	\
		929	\
		957	\
		985	\
		1013	\
		1042	\
		1070	\
		1104	\
		1138	\
		1172	\
		1207	\
		1242	\
		1277	\
		1312	\
		1347	\
		1382	\
		1417	\
		1453	\
		1488	\
		1523	\
		1559	\
		1594	\
		1630	\
		1665	\
		1701	\
		1736	\
		1772	\
		1808	\
		1843	\
		1879	\
		1915	\
		1951	\
		1986	\
		2022	\
		2058	\
	]

	set index [expr {int($mm)}]
	set mm 2058
	catch {
		set mm [lindex $mm_to_ml $index ]
	}
	if {$mm == ""} {
		set mm 2058
	}
	return $mm

}

proc refill_kit_retry_button {} {

	if {$::de1(substate) != 0} {
		return [translate "Touch screen to retry"]
	} else {
		return ""
	}
}

proc return_fan_threshold_calibration {temperature} {

	if {$temperature == 0} {
		return [translate "always on"]		
	}
	return [return_temperature_setting $temperature]
}


proc return_steam_flow_calibration {steam_flow} {
	set in [expr {$steam_flow / 100.0}]

	if {$::settings(enable_fluid_ounces) != 1} {
		return [subst {[round_to_one_digits $in] [translate "mL/s"]}]
	} else {
		return [subst {[round_to_two_digits [ml_to_oz $in]] oz/s}]
	}

}


proc return_steam_heater_calibration {steam_temperature} {

	if {$steam_temperature < 130} {
		return [translate "off"]		
	}
	return [return_temperature_setting $steam_temperature]
}


# obsolete - does not work reliably
proc Restart_app {} {
   #foreach w [winfo children .] {
    ##   destroy $w
   #}
   #source [info script]

	setup_images_for_first_page
	setup_images_for_other_pages
	.can itemconfigure splash -state hidden

	#after $::settings(timer_interval) 
	update_onscreen_variables
	delay_screen_saver
	change_screen_saver_img


#de1_ui_startup

}

foreach p [info procs] { set kpv(p,$p) 1 }
 foreach p [info vars]  { set kpv(v,$p) 1 }
 set kpv(p,bgerror) 1

 #######################################################################
 #
 # Restart
 #
 # Deletes all non-root widgets and all bindings This allows us to
 # reload the source file without getting any errors.
 #
 proc Restart_app {{f ""}} {



#    global kpv tk_version
 
    ;#catch {auto_reset}                        ;# Undo all autoload stuff
    if [info exists tk_version] {               ;# In wish not tclsh
        . config -cursor {}
        eval destroy [winfo children .]         ;# Kill all children windows
  
        foreach v [bind .] {                    ;# Remove all bindings also
            bind . $v {}
        }
        if {$tk_version >= 4.0} {               ;# Kill after events
            catch {foreach v [after info] {after cancel $v}}
        }
        if {$tk_version >= 8} {                 ;# Font stuff
            catch { eval font delete [font names] }
            eval image delete [image names]     ;# Image stuff
        }
        wm geom . {}                            ;# Reset main window geometry
        . config -width 200 -height 200
        raise .
    }
    foreach v [info procs] {                    ;# Remove unwanted procs
        if {[info exists kpv(p,$v)] == 0} {
            catch {rename $v {}}
        }
    }
 #     foreach v [namespace children] {
 #       if {[info exists kpv(n,$v)] == 0} {
 #           catch {namespace delete $v}
 #       }
 #     }
    
    uplevel {                                   ;# Get at global variables 
        foreach _v [info vars] {                ;# Remove unwanted variables
            if {[info exists kpv(v,$_v)] == 0} {;# Part of the core?
                catch {unset $_v}
            }
        }
        catch { unset _v }
    }
    if [file exists $f] {
       # uplevel source $f
    }

    source "de1plus.tcl"
 }



 proc toggle_espresso_steps_option {} {

 	if {[ifexists ::settings(espresso_temperature_steps_enabled)] != 1} {
 		set ::settings(espresso_temperature_steps_enabled) 1 
 	} else {
 		set ::settings(espresso_temperature_steps_enabled) 0 

 	} 		

	msg -DEBUG "Clearing default step temps"
	set ::settings(espresso_temperature_0) $::settings(espresso_temperature)
	set ::settings(espresso_temperature_1) $::settings(espresso_temperature)
	set ::settings(espresso_temperature_2) $::settings(espresso_temperature)
	set ::settings(espresso_temperature_3) $::settings(espresso_temperature)
 	

 	msg -DEBUG "toggle_espresso_steps_option $::settings(espresso_temperature_steps_enabled)"

}

proc round_and_return_step_temperature_setting {varname} {

	if {[ifexists ::settings(espresso_temperature_steps_enabled)] != 1} {
		return ""
	}

	set v [ifexists $varname]
	if {$v == ""} {
		msg -ERROR "can't find variable $varname in round_and_return_step_temperature_setting"
		return ""
	}

	return [round_and_return_temperature_setting $varname]
}

proc range_check_variable {varname low high} {

	upvar $varname var
	if {$var < $low} {
		msg -DEBUG "range_check_variable: variable $varname was under $low"
		set var $low
	}
	if {$var > $high} {
		msg -DEBUG "range_check_variable: variable $varname was over $high"
		set var $high
	}
}

proc range_check_shot_variables {} {

	range_check_variable ::settings(espresso_temperature) 0 105
	range_check_variable ::settings(espresso_temperature_0) 0 105
	range_check_variable ::settings(espresso_temperature_1) 0 105
	range_check_variable ::settings(espresso_temperature_2) 0 105
	range_check_variable ::settings(espresso_temperature_3) 0 105
	
	range_check_variable ::settings(preinfusion_time) 0 60
	range_check_variable ::settings(espresso_hold_time) 0 60
	range_check_variable ::settings(preinfusion_flow_rate) 0 $::de1(max_flowrate_v11)
	range_check_variable ::settings(flow_profile_hold) 0 $::de1(max_flowrate_v11)
	range_check_variable ::settings(flow_profile_decline) 0 $::de1(max_flowrate_v11)

	range_check_variable ::settings(preinfusion_stop_pressure) 0 $::de1(maxpressure)

	range_check_variable ::settings(espresso_pressure) 0 $::de1(maxpressure)

	range_check_variable ::settings(espresso_decline_time) 0 60
	range_check_variable ::settings(pressure_end) 0 $::de1(maxpressure)
	range_check_variable ::settings(final_desired_shot_volume) 0 100

	range_check_variable ::settings(final_desired_shot_weight) 0 100
	range_check_variable ::settings(final_desired_shot_weight_advanced) 0 2000
	range_check_variable ::settings(final_desired_shot_volume) 0 2000
	range_check_variable ::settings(final_desired_shot_volume_advanced) 0 2000
	range_check_variable ::settings(final_desired_shot_volume_advanced_count_start) 0 20
	range_check_variable ::settings(tank_desired_water_temperature) 0 45

}

proc change_espresso_temperature {amount} {

	if {$::settings(settings_profile_type) == "settings_2a" || $::settings(settings_profile_type) == "settings_2b"} {
		# pressure or flow profile

		if {[ifexists ::settings(espresso_temperature_steps_enabled)] == 1} {

			# if step temps are enabled then set the preinfusion start temp to the global temp 
			# and then apply the relative change desired to each subsequent step
			set ::settings(espresso_temperature) [expr {$::settings(espresso_temperature) + $amount}]
			set ::settings(espresso_temperature_0) $::settings(espresso_temperature)			
			set ::settings(espresso_temperature_1) [expr {$::settings(espresso_temperature_1) + $amount}]
			set ::settings(espresso_temperature_2) [expr {$::settings(espresso_temperature_2) + $amount}]
			set ::settings(espresso_temperature_3) [expr {$::settings(espresso_temperature_3) + $amount}]

		} else {
			set ::settings(espresso_temperature) [expr {$::settings(espresso_temperature) + $amount}]
		}
	} else {
		# advanced shots need every step changed

		set newshot {}
		set cnt 0
		foreach step $::settings(advanced_shot) {
			incr cnt
			array unset -nocomplain props
			array set props $step
			set temp [ifexists props(temperature)]
			set newtemp [expr {$temp + $amount}]
			if {$cnt == 1} {
				set ::settings(espresso_temperature) $newtemp
			}

			set props(temperature) $newtemp
			lappend newshot [array get props]
		}
		set ::settings(advanced_shot) $newshot
	}

	range_check_shot_variables
}

proc when_to_start_pour_tracking_advanced {} {
	if {$::settings(final_desired_shot_volume_advanced_count_start) > 0} {
		set stepdesc ""
		catch {
			# this should all work, but in case there's something wrong with this logic or the advanced shot, wrap it all in a catch{} so as to not cause an error for such a minor feature
			if {$::settings(final_desired_shot_volume_advanced_count_start) > [llength [ifexists ::settings(advanced_shot)]] } {
				set ::settings(final_desired_shot_volume_advanced_count_start) [llength [ifexists ::settings(advanced_shot)]]
			}

			array set steparr [lindex [ifexists ::settings(advanced_shot)] [expr {-1 + $::settings(final_desired_shot_volume_advanced_count_start)}]]
			set stepdesc [ifexists steparr(name)]
		}
		return [subst {[translate "After step"] $::settings(final_desired_shot_volume_advanced_count_start) - $stepdesc}]
	} else {
		return [translate "Immediately"]
	}
}

proc app_updates_policy_as_text {} {
	set progname "stable"
    if {[ifexists ::settings(app_updates_beta_enabled)] == 1} {
        set progname "beta"
    } elseif {[ifexists ::settings(app_updates_beta_enabled)] == 2} {
        set progname "nightly"
    }

 	return [translate $progname]
}

proc set_resolution_height_from_width { {discard {}} } {
	set ::settings(screen_size_height) [expr {int($::settings(screen_size_width)/1.6)}]

	# check the width and make sure it is a multiple of 160. If not, pick the nearest setting.
	for {set x [expr {$::settings(screen_size_width) - 0}]} {$x <= 2800} {incr x} {
		set ratio [expr {$x / 160.0}]
		if {$ratio == int($ratio)} {
			set ::settings(screen_size_width) $x
			set ::settings(screen_size_height) [expr {int($::settings(screen_size_width)/1.6)}]
			break
		}
	}
}