#!/bin/sh

test -f /bin/sh5 && test -z "$RUNNING_SH5" \
  && test x"`(uname -s) 2>&1`" = xULTRIX \
  && { RUNNING_SH5=true; export RUNNING_SH5; exec /bin/sh5 $0 ${1+"$@"}; }
RUNNING_SH5=

test -f /bin/bsh && test -z "$RUNNING_BSH" \
  && test x"`(uname -s) 2>&1`" = xAIX \
  && { RUNNING_BSH=true; export RUNNING_BSH; exec /bin/bsh $0 ${1+"$@"}; }
RUNNING_BSH=

SAVE_ARGS=${1+"$@"}

version=teTeX
#version='TeX Live'

# TeX-Config version 0.9 for teTeX and TeX Live. I hope, you will love
# this script :-)

# More comments, more verbose messages, and better error handling are needed.
# It sould give more help (e.g on ls-R and localfont) and ask a bit more
# for confirmations.

# Any comments, improvements, ... please via Email to:
# Thomas Esser, te@informatik.uni-hannover.de
# Copyright: Thomas Esser, 1994, 1995, 1996, 1997

# You may override DIALOG_TERMINFO and DIALOG_TERM in your environment.

progname=`basename $0`
tmpdir=${TMP-/tmp}/texconf$$
tmpmenu=$tmpdir/menu.out
tmpans=$tmpdir/answer.out
std_pager=more
xdvi_shrink_scale=75
std_editor=vi

envvars="
AFMFONTS BIBINPUTS BSTINPUTS DVILJFONTS DVIPSFONTS DVIPSHEADERS GFFONTS
GLYPHFONTS INDEXSTYLE MFBASES MFINPUTS MFPOOL MFTINPUTS MPINPUTS MPMEMS
MPPOOL MPSUPPORT OCPINPUTS OFMFONTS OPLFONTS OTPINPUTS OVFFONTS OVPFONTS
PKFONTS PSHEADERS T1FONTS T1INPUTS TEXBIB TEXCONFIG TEXDOCS TEXFONTMAPS
TEXFONTS TEXFORMATS TEXINDEXSTYLE TEXINPUTS TEXMFCNF TEXMFDBS TEXMFINI
TEXPICTS TEXPKS TEXPOOL TEXPSHEADERS TEXSOURCES TFMFONTS TRFONTS VFFONTS
XDVIFONTS XDVIVFS
"

kpsevars='MetaPost support
PostScript header
TeX system documentation
TeX system sources
Troff fonts
afm
base
bib
bitmap font
bst
cnf
dvips config
fmt
gf
graphic/figure
ist
ls-R
map
mem
mf
mfpool
mft
mp
mppool
ocp
ofm
opl
other text files
otp
ovf
ovp
pk
tex
texpool
tfm
truetype fonts
type1 fonts
type42 fonts
vf
web2c files'

umask 022

PATH=$PATH:`pwd`; export PATH
log=$tmpdir/logfile
unset mode

echo_a()
{
	echo -n "$@"
}

echo_b()
{
	echo "$@\c"
}

echo_c()
{
	echo -e "$@\c"
}

echo_d()
{
	/bin/echo -n "$@"
}

echo_e()
{
	/bin/echo "$@\c"
}

echo_f()
{
	/bin/echo -e "$@\c"
}


find_echo()
{
	for i in a b c d e f; do
		test "`echo_$i c``echo_$i a`"  = ca &&
			echon=echo_$i && return
	done
	echon=echo
}

find_echo

find_fmt()
{
  FMT=fmt
  test ! -x /bin/fmt && test ! -f /usr/bin/fmt &&
    { test -x /bin/adjust || test -x /usr/bin/adjust; } && FMT=adjust
}

find_fmt

cls()
{
  test -z "$NO_CLEAR" && clear
}

# Some systems have their own dialog. Use it then and do not use
# faked TERM and TERMINFO variables when calling that dialog.
find_dialogtype()
{
  own_dialog=false
  { u=`uname -s`; } 2>/dev/null
  case "$u" in
    FreeBSD)
      DIALOG_PROG=/usr/bin/dialog
      test -x "$DIALOG_PROG" && own_dialog=true;;
  esac
}
 
find_dialogtype
 
run_dialog()
{
  test -z "$NO_CLEAR" && clear
  if $own_dialog; then
    $DIALOG_PROG --title "$version setup utility" "$@"
  else
    TERM=$DIALOG_TERM TERMINFO=$DIALOG_TERMINFO dialog --title "$version setup utility" "$@"
  fi
}

check_environ()
{
	found=
	for i in $envvars; do
		eval var=\"\$$i\"
		if [ ! -z "$var" ]; then
			case $var in
				:*|*:|*::*)	;;
				*)	found="$found $i"
					;;
			esac
		fi
	done
	test -z "$found" && return
	clear
	cat <<-eof
		$progname has found the following environment variables set:

	eof
	for i in $found; do
		eval echo \"	\$i = \$$i\"
	done
	cat <<-eof

		Please make sure, their values are ok, and otherwise change or unset them.
		If you continue with wrong values for the above variables, $progname
		might run into trouble when locating files on the disk.

		Note that you can refer to the default path by giving an "empty" path
		component (i.e. a colon in front or in the end, or a doubled colon
		somewhere in the middle).

		If you set TEXINPUTS, e.g. to :~/TeX/macros, (La)TeX will search along
		the default path and then in ~/TeX/macros.

		For more information, see the Kpathsea and the teTeX manual.

	eof
	
	$echon "Press RETURN to continue (or Control-C to abort)... "
	read dummy
}

fonts_ro()
{
  clear
  echo "Removing global write permissions in fonts tree:" >&2
  find $TC_TEXMFMAIN/fonts -perm -2 -type d -exec sh -c '
		chmod -t $1 || exit;
		chmod go-w $1 || exit;
		echo $1 >&2;
	' sh '{}' \;
  chmod go-w $TC_TEXMFMAIN/ls-R && echo $TC_TEXMFMAIN/ls-R >&2
  echo "Done." >&2
}

fonts_rw()
{
  clear
  echo "Adding global write permissions in fonts tree:" >&2
  find $TC_TEXMFMAIN/fonts/tfm $TC_TEXMFMAIN/fonts/pk $TC_TEXMFMAIN/fonts/source/jknappen \
	-type d -exec sh -c '
		case $1 in
		*/adobe*|*/bitstrea*)	exit;;
		esac
		chmod 1777 $1 || exit;
		echo $1 >&2;
	' sh '{}' \;
  chmod 1777 $TC_TEXMFMAIN/fonts || exit
  echo $TC_TEXMFMAIN/fonts >&2
  chmod 666 $TC_TEXMFMAIN/ls-R && echo $TC_TEXMFMAIN/ls-R >&2
  echo "Done." >&2
}

check_terminal()
{
	terminfo=${DIALOG_TERMINFO-/usr/lib/terminfo}

	test -f $terminfo/`echo $DIALOG_TERM | sed 's/\(.\).*/\1/'`/$DIALOG_TERM && return
	cat >&2 <<-eof
		TERM=$DIALOG_TERM is not supported by your terminfo system.
		See terminfo(5), tic(1m) and term(5) for help.

		$progname failed. Program aborted.
	eof
	exit 1
}

fix_pager_more()
{
	case "$PAGER" in
		less*)	: ;;
		*)	$echon 'Press return to continue... ' >&2
			read foo;;
	esac
}

exist_test()
{
	type=$1 ; name=$2
	if [ ! "$type" "$name" ] && [ -z "$name" ]; then
            run_dialog --msgbox \
                "'$name' does not exist.\\n\\nThe programm will show you the error-log and then exit." 23 80
	    clear
	    <$log eval $PAGER
	    fix_pager_more
	    exit 1
	fi
}

choose_editor()
{
	run_dialog --inputbox \
		"Your editor for changing config-files currently\\nis set to $EDIT.\\n\\nPress RETURN to accept this default or enter\\nthe name of the editor of your choice.\\n\\n" \
		23 80 2>$tmpmenu || return
	x=`cat $tmpmenu`
	test -z "$x" || EDIT=$x
}

choose_pager()
{
        run_dialog --inputbox \
                "Your pager to view the logfile currently\\nis set to $PAGER.\\n\\nPress RETURN to accept this default or enter\\nthe name of the pager of your choice.\\n\\n" \
                23 80 2>$tmpmenu || return
        x=`cat $tmpmenu`
        test -z "$x" || PAGER=$x
}


setup_preferences()
{
    while true ; do
        run_dialog \
                --menu "\\n\\nSet up your editor and pager for this texconfig session.\\n\\n" \
                23 80 4 \
		RETURN 'back to main menu' \
                EDITOR 'set up editor for changing config-files' \
                PAGER 'set up pager to view the logfile' \
		"LOG"	'view logfile' \
                2>$tmpmenu || return
        ans=`cat $tmpmenu`
        test -z "$ans" && return
        case "$ans" in
            EDITOR)       choose_editor ;;
            PAGER)      choose_pager ;;
	    LOG)	clear; <$log eval $PAGER; fix_pager_more ;;
            RETURN)     return ;;
        esac
    done
}

run_config_tex()
{
  rm -f *.log *.*fmt
  case "$1" in
  tex*)
    echo "Running tex to create plain format..."
      (
	require_binary tex
        tex -ini  tex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/tex.fmt &&
          { rm -f $formats/plain.fmt; ln -s tex.fmt $formats/plain.fmt;
            $TC_MKTEXUPD $formats tex.fmt; $TC_MKTEXUPD $formats plain.fmt; }
        test -f $formats/tex.efmt &&
          { rm -f $formats/plain.efmt; ln -s tex.efmt $formats/plain.efmt;
            $TC_MKTEXUPD $formats tex.efmt; $TC_MKTEXUPD $formats plain.efmt; }
      ) </dev/null
    echo "Done."; echo;;
  eplain*)
    echo "Running eplain to create eplain format..."
      (
	require_binary eplain
	touch eplain.aux
        eplain -ini  eplain.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
	test -f $formats/eplain.fmt && $TC_MKTEXUPD $formats eplain.fmt
	test -f $formats/eplain.efmt && $TC_MKTEXUPD $formats eplain.efmt
      ) </dev/null
    echo "Done."; echo;;
  latex209*)
    echo "Running latex209 to create latex209 format..."
      (
	require_binary latex209
        latex209 -ini  latex209.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/latex209.fmt && $TC_MKTEXUPD $formats latex209.fmt
        test -f $formats/latex209.efmt && $TC_MKTEXUPD $formats latex209.efmt
      ) </dev/null
    echo "Done."; echo;;
  amstex*)
    echo "Running amstex to create amstex format..."
      (
	require_binary amstex
        amstex -ini  amstex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/amstex.fmt && $TC_MKTEXUPD $formats amstex.fmt
        test -f $formats/amstex.efmt && $TC_MKTEXUPD $formats amstex.efmt
      ) </dev/null
    echo "Done."; echo;;
  jadetex*)
    echo "Running jadetex to create jadetex format..."
      (
        # rm -f $formats/amstex.fmt $formats/amstex.log
	require_binary jadetex
        jadetex -ini  \&latex jadetex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/jadetex.fmt && $TC_MKTEXUPD $formats jadetex.fmt
        test -f $formats/jadetex.efmt && $TC_MKTEXUPD $formats jadetex.efmt
      ) </dev/null
    echo "Done."; echo;;
  latex.*)
    echo "Running latex to create LaTeX format..."
      (
        # rm -f $formats/latex.fmt $formats/latex.log
	require_binary latex
        latex -ini  latex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/latex.fmt && $TC_MKTEXUPD $formats latex.fmt
        test -f $formats/latex.efmt && $TC_MKTEXUPD $formats latex.efmt
      ) </dev/null
    echo "Done."; echo;;
  etex*)
    echo "Running etex to create e-TeX plain format (extended mode)..."
      (
        # rm -f $formats/etex.fmt $formats/etex.log
	require_binary etex
        etex -ini  \*etex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/etex.fmt && $TC_MKTEXUPD $formats etex.fmt
        test -f $formats/etex.efmt && $TC_MKTEXUPD $formats etex.efmt
      ) </dev/null
    echo "Done."; echo;;
  lambda.*)
    echo "Running lambda to create Omega Lambda (LaTeX) format ..."
      (
        # rm -f $formats/lambda.fmt $formats/lambda.log
	require_binary lambda
        lambda -ini  lambda.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        $TC_MKTEXUPD $formats lambda.fmt
      ) </dev/null
    echo "Done."; echo;;
  omega.*)
    echo "Running omega to create Omega plain format ..."
      (
        # rm -f $formats/omega.fmt $formats/omega.log
	require_binary omega
        omega -ini  omega.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        $TC_MKTEXUPD $formats omega.fmt
      ) </dev/null
    echo "Done."; echo;;
  elatex.*)
    echo "Running tex to create e-TeX LaTeX format (extended mode)..."
      (
        # rm -f $formats/elatex.fmt $formats/elatex.log
	require_binary elatex
        elatex -ini  \*elatex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/elatex.fmt && $TC_MKTEXUPD $formats elatex.fmt
        test -f $formats/elatex.efmt && $TC_MKTEXUPD $formats elatex.efmt
      ) </dev/null
    echo "Done."; echo;;
  pdftex.*)
    echo "Running pdftex to create plain format..."
      (
        # rm -f $formats/pdftex.fmt $formats/pdftex.log
	require_binary pdftex
        pdftex -ini  pdftex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/pdftex.fmt && $TC_MKTEXUPD $formats pdftex.fmt
        test -f $formats/pdftex.efmt && $TC_MKTEXUPD $formats pdftex.efmt
      ) </dev/null
    echo "Done."; echo;;
  pdflatex.*)
    echo "Running pdflatex to create LaTeX format..."
      (
        # rm -f $formats/pdflatex.fmt $formats/pdflatex.log
	require_binary pdflatex
        pdflatex -ini pdflatex.ini || return
	for i in *.log *.*fmt; do rm -f "$formats/$i"; mv "$i" "$formats/$i"; done
        test -f $formats/pdflatex.fmt && $TC_MKTEXUPD $formats pdflatex.fmt
        test -f $formats/pdflatex.efmt && $TC_MKTEXUPD $formats pdflatex.efmt
      ) </dev/null
    echo "Done."; echo;;
  esac
}

config_tex()
{
	exist_test -d $formats
	exist_test -f $language

	clear
	$EDIT $language
        clear; run_config_tex tex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/etex && run_config_tex etex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/pdftex && run_config_tex pdftex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/tex/latex && run_config_tex latex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/etex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex elatex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/pdftex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex pdflatex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/tex/amstex && run_config_tex amstex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/tex/jadetex && run_config_tex jadetex.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/tex/eplain && run_config_tex eplain.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/tex/latex209 && run_config_tex latex209.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/omega && run_config_tex omega.ini 2>&1 | tee -a $log
        clear; test -d $TC_TEXMFMAIN/omega &&
	  test -d $TC_TEXMFMAIN/tex/latex && run_config_tex lambda.ini 2>&1 | tee -a $log
}

choose_mode()
{
	out=$1
	choose_mode_msg="$2"
	mode=$default_mode
	exist_test -f $modes
	if [ ! -z "$mode" ] ; then
		if yesno "\\n\\nUse mode $mode as default $3?\\n\\n" 23 80 ; then
			: # nothing
		else
			mode=""
		fi
	fi
	if [ -z "$mode" ] ; then
		#--title \"teTeX-Config: MetaFont mode\" \
	    eval run_dialog \
		--menu \"\$choose_mode_msg\" \
		23 80 14 `list_mf_modes $modes` \
		2>$out
	else
		echo $mode >$out
	fi
}

get_default_mode()
{
	choose_mode $tmpans 'Choose a default mode for xdvi, dvips and metafont. As a rule\nof thumb, choose the most commonly mode used for printing at your site.'
	default_mode=`cat $tmpans`
	test -z "$default_mode" && return

	clear
	do_set_default_mode "$default_mode" 2>&1 | tee -a $log

}

do_set_default_mode()
{
	mode=$1
	set x `find_res $mode`; shift
	res_x=$1; res_y=$2
	dvips_conf=$dvips_conf_dir/config.ps

	run_setup_mf_mode $mode
	run_dvips_setup_mode $mode $res_x $res_y
	run_xdvi_setup_mode $mode $res_x
	config_replace $maketex_site_file '^: ..MODE' ": \${MODE=$mode}"
	config_replace $maketex_site_file '^: ..BDPI' ": \${BDPI=$res_x}"

	run_config_mf

}

run_config_mf()
{
	exist_test -d $bases
	exist_test -f $modes

	echo "Running mf to create plain base ..."
	run_create_mf_base
	echo "Done."; echo
}

run_setup_mf_mode()
{
	mode="$1"
	ed $modes >/dev/null 2>&1 <<-eof
		/^localfont :=/
		c
		localfont := $mode;
		.
		w
		q
	eof
}

run_create_mf_base()
{
    (
	rm -f *.log *.base
	mf -ini mf.mf </dev/null || return
	for i in *.log *.base; do rm -f "$bases/$i"; mv "$i" "$bases/$i"; done
	rm -f $bases/plain.base
	ln -s mf.base $bases/plain.base
	$TC_MKTEXUPD $bases mf.base 2>/dev/null
	$TC_MKTEXUPD $bases plain.base 2>/dev/null
    )
}

run_config_mp()
{
	exist_test -d $mems

	echo "Running mpost to create plain mem ..."
	run_create_mp_mem
	echo "Done."; echo
}

run_create_mp_mem()
{
    (
	rm -f *.log *.mem
	mpost -ini mpost.mp </dev/null || return
	for i in *.log *.mem; do rm -f "$mems/$i"; mv "$i" "$mems/$i"; done
	rm -f $mems/plain.mem
	ln -s mpost.mem $mems/plain.mem
	$TC_MKTEXUPD $mems plain.mem
	$TC_MKTEXUPD $mems mpost.mem
    )
}

config_dvips_paper()
{
		#--title \"teTeX-Config: dvips default paper\" \
	eval run_dialog \
		--menu \'\\n\\nChoose the default papersize definition for dvips.\\n\\n\' \
		23 80 8 `list_dvips_papers $dvips_conf` \
		2>$tmpmenu || return
	paper=`cat $tmpmenu`
	test -z "$paper" && return ;
	setup_dvips_paper "$paper" 2>&1 | tee -a $log
}

dvips_choose_printcmd()
{
        run_dialog --inputbox \
                "\\n\\nEnter the command to print to the printer '$printer'.\\nIn general, you need a command like 'lpr' or 'lpr -Pfoo'.\\n\\nNOTE: If you just press return, printing will be disabled\\nand the output saved to a file by default.\\n\\n" \
                23 80 2>$tmpmenu || return
        x=`cat $tmpmenu`
        if [ -z "$x" ] ; then
		echo save-to-file >&2
	else
		echo $x >&2
	fi

}

has_latex()
{
	test -d $TC_TEXMFMAIN/tex/latex && return 0
	run_dialog --msgbox \
		"This funtion needs LaTeX to be installed." 23 80
	return 1
}

dvips_test_print()
{
	has_latex || return
	cd $tmpdir					
	clear
	latex testpage					2>&1 | tee -a $log
	case $printer in
	    default)	dvips testpage ;;
	    *)		dvips -P$printer testpage ;;
	esac						2>&1 | tee -a $log
	
}

yesno()
{
	run_dialog --yesno "$@"
}

dvips_setup_mode()
{
        choose_mode $tmpans "Choose the metafont mode for printer '$printer'" "for printer $printer"
        mode=`cat $tmpans`
        test -z "$mode" && return
	run_dvips_setup_mode "$mode" 2>&1 | tee -a $log
}

run_dvips_setup_mode()
{
  mode="$1"
  if test -z "$2"; then
    set x `find_res $mode`; shift
    res_x=$1; res_y=$2
  else
    res_x=$2
    res_y=${3-$2}
  fi
  config_replace $dvips_conf '^M' "M $mode"
  config_replace $dvips_conf '^D' "D $res_x"
  config_replace $dvips_conf '^X' "X $res_x"
  config_replace $dvips_conf '^Y' "Y $res_y"
}

dvips_setup_printcmd()
{
        dvips_choose_printcmd 2>$tmpans
        printcmd=`cat $tmpans`
        test -z "$printcmd" && return
	do_dvips_setup_printcmd "$printcmd" 2>&1 | tee -a $log
}

do_dvips_setup_printcmd()
{
	printcmd="$@"
	if test "$printcmd" = save-to-file; then
		config_replace $dvips_conf '^o' 'o'
	else
		config_replace $dvips_conf '^o' "o |$printcmd"
	fi
}

dvips_setup_offset()
{
        run_dialog --inputbox \
                "

Enter a dimension pair (A rightwards offset and a downwards
offset), e.g. 2mm,-0.5in (right 2mm and up .5in):

" \
                23 80 2>$tmpmenu || return
        x=`cat $tmpmenu`
	test -z "$x" || run_dvips_setup_offset "$x" 2>&1 | tee -a $log
}

do_dvips_setup_offset()
{
	x="$1"
	if test -z "$x"; then
		echo "Error: no offset given to do_dvips_setup_offset. Skipped." >&2
		return
	fi
	run_dvips_setup_offset "$x"
}

run_dvips_setup_offset()
{
	x="$1"
	config_replace $dvips_conf '^O' "O $x"
}

dvips_config_local()
{
    exist_test -d $dvips_conf_dir

    while true ; do
        run_dialog \
                --menu "\\n\\n$version: set up printer '$printer' for dvips\\n\\n" \
                23 80 5 \
                RETURN 'Back to dvips main menu' \
                MODE 'Set up mf mode (resolution will be calculated as well)' \
                CMD 'Set up the command to print on this printer' \
                OFFSETS 'Set up offsets for printing' \
                TEST 'Print a testpage' \
                2>$tmpmenu || return
        ans=`cat $tmpmenu`
        test -z "$ans" && return
        case "$ans" in
	    MODE)	dvips_setup_mode ;;
	    CMD)	dvips_setup_printcmd ;;
	    OFFSETS)	dvips_setup_offset ;;
	    TEST)	dvips_test_print ;;
	    RETURN)	return ;;
	esac
    done
}

dvips_config_global()
{
	config_dvips_paper
	printer=default
	dvips_config_local
}

dvips_get_printername()
{
	run_dialog --inputbox \
		"Printer name" \
		23 80 2>$tmpmenu || return
	x=`cat $tmpmenu`
	test -z "$x" || echo $x >&2
}

config_dvips()
{
    while true ; do
	run_dialog \
		--menu '
dvips section: If you only have no more than one printer, you
only need to go through the GLOBAL menu. You can use dvips for non
PostScript printers, if you can setup your printing system to convert
PostScript to a format that your printer can handle. Maybe, you can
use GhostScript to do the conversation (if you printer is supported).

A definition for a printer PRINTER directly corresponds to a
configuration file config.PRINTER in the $TEXMFLOCAL/dvips directory.

' \
		23 80 6 \
		RETURN 'back to main menu' \
		GLOBAL 'global settings' \
		ADD 'add a printer configuration (to be used via -P flag)' \
		DEL 'remove a printer definition' \
		CHANGE 'change an existing printer definition' \
		"LOG"	'view logfile' \
		2>$tmpmenu || return
	ans=`cat $tmpmenu`
	test -z "$ans" && return
	case "$ans" in
		ADD|DEL|CHANGE)
			dvips_get_printername 2>$tmpans
			printer=`cat $tmpans`
			test -z "$printer" && continue
			dvips_conf=$dvips_conf_dir/config.$printer
			;;
	esac
	case "$ans" in
	    GLOBAL) 	dvips_conf=$dvips_conf_dir/config.ps
			dvips_config_global ;;
	    ADD)	if [ -f $dvips_conf_dir/config.$printer ] ; then
				run_dialog --msgbox \
					"Configuration for $printer already exists." 23 80
				continue
			fi
			touch $dvips_conf_dir/config.$printer
			$TC_MKTEXUPD $dvips_conf_dir config.$printer
			dvips_config_local ;;
	    DEL)	rm -f $dvips_conf_dir/config.$printer $dvips_conf_dir/config.$printer.orig ;;
	    CHANGE)	if [ ! -f $dvips_conf_dir/config.$printer ] ; then
				run_dialog --msgbox \
					"Configuration for $printer not found." 23 80
				continue
			fi
			dvips_config_local ;;
	    LOG)	clear; <$log eval $PAGER; fix_pager_more;;
	    RETURN)	return ;;
	esac
    done
}

do_dvips_setup_paper()
{
	paper="$1"
	list=`list_dvips_papers $dvips_conf | awk '{print $1}'`
	if test_in_list "$paper" $list; then
		setup_dvips_paper "$paper"
	fi
}

do_xdvi_setup_paper()
{
	paper="$1"
	list=`list_xdvi_papers | awk '{print $1}'`
	if test_in_list "$paper" $list; then
		run_xdvi_setup_paper "$paper"
	fi
}

run_xdvi_setup_paper()
{
	paper="$1"
	config_replace $xdvi_app_file 'paper:' "XDvi*paper: $paper"
}

xdvi_setup_paper()
{
                #--title \"TeX-Config: xdvi default paper\" \
        eval run_dialog \
                --menu \"Choose the default papersize definition for xdvi.\" \
                23 80 15 `list_xdvi_papers` \
                2>$tmpmenu || return
        paper=`cat $tmpmenu`
        test -z "$paper" && return
        run_xdvi_setup_paper "$paper" 2>&1 | tee -a $log
}

do_dvips_setup_mode()
{
	mode="$1"
	if test -z "$mode"; then
		echo "Error: no mode given to do_dvips_setup_mode. Skipped.">&2
		return 1
	fi
	list=`list_mf_modes $modes | awk '{print $1}'`
	if test_in_list "$mode" $list; then
		run_dvips_setup_mode "$mode"
	fi
}

cmd_mode_maketex()
{
	case "$1" in
		vardir)
			if test -z "$2"; then
				echo "Usage: texconfig font vardir DIR" >&2
				return 1
			else
				do_setup_mt_vardir "$2"
			fi
			;;
                ro)
			fonts_ro;;
                rw)	fonts_rw;;
		options)
			shift
			if test $# = 0; then
				echo "Usage: texconfig options OPTIONS ..." >&2
				return 1
			fi
			if test "$*" = -; then
				set_mt_options
			else
				set_mt_options "$@"
			fi
			;;
		*)
			echo "Usage: texconfig font vardir DIR" >&2
			echo "       texconfig font ro" >&2
			echo "       texconfig font rw" >&2
			echo "       texconfig font options OPTIONS ..." >&2
			echo >&2
			echo "       valid OPTIONS: $all_mt_features -" >&2
			echo "       the special OPTION '-' can be used to disable all OPTIONS" >&2
			return 1
			;;
	esac
}

cmd_mode_set_default_mode()
{
	mode="$1"
	case "$mode" in
		"") echo "Usage: texconfig mode MODE" >&2
		    echo "       Valid modes:" >&2
		    echo >&2
		    list_mf_modes $modes | awk '{print $1}' | $FMT >&2
		    echo >&2
		    echo "See file $modes" >&2
		    echo "for more information about these modes." >&2
		    return 1;;
	esac
	list=`list_mf_modes $modes | awk '{print $1}'`
	if test_in_list "$mode" $list; then
		do_set_default_mode "$mode"
	fi
}

run_xdvi_setup_mode()
{
	mode="$1"
        res=${2-`find_res $mode 2>>$log | awk '{ print $1 }'`}
        shrink=`expr $res / $xdvi_shrink_scale`
        config_replace $xdvi_app_file 'mfMode:' "XDvi*mfMode: $mode"                    2>&1 | tee -a $log
        config_replace $xdvi_app_file 'pixelsPerInch:' "XDvi*pixelsPerInch: $res"       2>&1 | tee -a $log
        config_replace $xdvi_app_file 'shrinkFactor:' "XDvi*shrinkFactor: $shrink"      2>&1 | tee -a $log
}

xdvi_make_test()
{
	if [ -z "$DISPLAY" ] ; then
		:
	fi
	cd $tmpdir 2>&1 | tee -a $log
	clear
	tex '\input story\end' 2>&1 | tee -a $log
	clear
	xdvi story 2>&1 | tee -a $log
}


config_xdvi()
{
    test -d $xdvi_app_dir || $TC_MKTEXDIR $xdvi_app_dir
    test -f $xdvi_app_file || touch $xdvi_app_file
    exist_test -f $xdvi_app_file

    while true ; do
        run_dialog \
                --menu '\n\nSet up xdvi via application ressources.\n\nNote 1: set the mode from the main menu.\nNote 2: a symbolic Link for the app-default file is no longer necessary.\n\n' \
                23 80 4 \
                RETURN 'back to main menu' \
                PAPER 'default papertype' \
                TEST 'view a testfile' \
		"LOG"	'view logfile' \
                2>$tmpmenu || return
        ans=`cat $tmpmenu`
        test -z "$ans" && return
        case "$ans" in
            PAPER)        xdvi_setup_paper ;;
            TEST)       xdvi_make_test ;;
	    LOG)	clear; <$log eval $PAGER; fix_pager_more;;
            RETURN)     return ;;
        esac
    done
}

keep_mode()
{
  yesno "\\n\\nUse mode $mode\\n\\n" 23 80
}

config_replace()
{
	config=$1
	pattern=$2
	replacement=$3

	require_binary ed

	test -f "$config" > /dev/null 2>&1
	if [ $? != 0 ]; then
		echo "config_replace: file '$config' not found." >&2
		return
	fi

	test -w "$config" > /dev/null 2>&1
	if [ $? != 0 ]; then
		echo "config_replace: cannot write to file '$config'." >&2
		return
	fi

	egrep -e "$pattern" "$config" > /dev/null 2>&1 
	if [ $? != 0 ]; then
		echo "$replacement" >> "$config"
	else
		ed $config >/dev/null 2>&1 <<-eof
			/$pattern/c
			$replacement
			.
			w
			q
		eof
		error=$?
		if [ $error != 0 ]; then
			echo "config_replace: ed returned error code '$error'." >&2
			return
		fi
	fi
}

find_res()
{
  cat >mftmp.mf <<'eof'
let myexit = primitive_end_;
mode_setup;
string xdpi;
xdpi := decimal round pixels_per_inch;
message "XDPI = " & xdpi;
string ydpi;
ydpi := decimal round (pixels_per_inch * aspect_ratio);
message "YDPI = " & ydpi;
fontmaking := 0;
myexit;
eof
  mf '\mode='"$1"';  \input ./mftmp' </dev/null | awk '$1 == "XDPI" || $1 == "YDPI" { print $3 }'
}

mode_name()
{
  mf '\mode='"$1"';  \input modename' | sed -n '/^MODENAME/!d; s/.*= //; s/_.*//; p'
}

list_dvips_papers()
{
  grep '@ ' $1 | sed "s/..//;s/ / '/;s/\$/' /"
}

list_mf_modes()
{
  grep mode_def $1 |
  sed -e "s/mode_def //" \
      -e "s/ .*%[^ ]* / '/" \
      -e "s/\$/' /" |
  egrep -v "^(help|%)" | sort
}

list_xdvi_papers()
{
	cat <<-'eof'
		us           "8.5x11"
		usr          "11x8.5"
		legal        "8.5x14"
		foolscap     "13.5x17.0"
		a1           "59.4x84.0cm"
		a2           "42.0x59.4cm"
		a3           "29.7x42.0cm"
		a4           "21.0x29.7cm"
		a5           "14.85x21.0cm"
		a6           "10.5x14.85cm"
		a7           "7.42x10.5cm"
		a1r          "84.0x59.4cm"
		a2r          "59.4x42.0cm"
		a3r          "42.0x29.7cm"
		a4r          "29.7x21.0cm"
		a5r          "21.0x14.85cm"
		a6r          "14.85x10.5cm"
		a7r          "10.5x7.42cm"
		b1           "70.6x100.0cm"
		b2           "50.0x70.6cm"
		b3           "35.3x50.0cm"
		b4           "25.0x35.3cm"
		b5           "17.6x25.0cm"
		b6           "13.5x17.6cm"
		b7           "8.8x13.5cm"
		b1r          "100.0x70.6cm"
		b2r          "70.6x50.0cm"
		b3r          "50.0x35.3cm"
		b4r          "35.3x25.0cm"
		b5r          "25.0x17.6cm"
		b6r          "17.6x13.5cm"
		b7r          "13.5x8.8cm"
		c1           "64.8x91.6cm"
		c2           "45.8x64.8cm"
		c3           "32.4x45.8cm"
		c4           "22.9x32.4cm"
		c5           "16.2x22.9cm"
		c6           "11.46x16.2cm"
		c7           "8.1x11.46cm"
		c1r          "91.6x64.8cm"
		c2r          "64.8x45.8cm"
		c3r          "45.8x32.4cm"
		c4r          "32.4x22.9cm"
		c5r          "22.9x16.2cm"
		c6r          "16.2x11.46cm"
		c7r          "11.46x8.1cm"
	eof
}

setup_dvips_paper()
{
	config=$dvips_conf
	paper=$1

	test -f "$config" > /dev/null 2>&1
	if [ $? != 0 ]; then
		echo "setup_dvips_paper: global dvips config file '$config' not found." >&2
		return
	fi

	test -w "$config" > /dev/null 2>&1
	if [ $? != 0 ]; then
		echo "setup_dvips_paper: cannot write to file '$config'." >&2
		return
	fi

	grep "@ $paper" "$config" > /dev/null 2>&1 
	if [ $? != 0 ]; then
		echo "setup_dvips_paper: paper '$paper' not found in file '$config'." >&2
		return
	fi

	ed $config > /dev/null 2>&1 <<-eof
		/@ /ka
		\$a
		@ 
		.
		/@ $paper/;/@ /-1m'a-1
		\$d
		w
		q
	eof

	error=$?

	if [ $error != 0 ]; then
		echo "setup_dvips_paper: ed returned error code '$error'." >&2
	fi
}

cmd_mode()
{
	case "$1" in
		faq)	clear; test -f $FAQ && <$FAQ eval $PAGER; fix_pager_more;;
		conf)	do_print_setup;;
		hyphen)	edit_hyphen;;
		mode)	shift; cmd_mode_set_default_mode ${1+"$@"} ;;
		xdvi)	shift; cmd_mode_xdvi ${1+"$@"};;
		dvips)	shift; cmd_mode_dvips ${1+"$@"};;
		font) shift; cmd_mode_maketex ${1+"$@"};;
		confall) do_print_all_setup;;
		init)	init_all;;
		*)	echo "Usage: texconfig conf" >&2
			echo "       texconfig confall" >&2
			echo "       texconfig rehash" >&2
			echo "       texconfig hyphen" >&2
			echo "       texconfig mode    [options]" >&2
			echo "       texconfig xdvi    [options] ..." >&2
			echo "       texconfig dvips   [options] ..." >&2
			echo "       texconfig font    [options] ..." >&2
			echo "       texconfig faq" >&2
			echo "       texconfig init" >&2
			echo >&2
			echo "Get help with:" >&2
			echo "       texconfig help" >&2
			echo "       texconfig mode" >&2
			echo "       texconfig xdvi" >&2
			echo "       texconfig dvips" >&2
			echo "       texconfig font" >&2
			exit 1;;
	esac
	exit
}

cmd_mode_dvips()
{
	printer=""
	dvips_conf="$dvips_conf_dir/config.ps"
	case "$1" in
		-P)	printer=$2; shift; shift;;
		-P*)	printer=`echo $2 | sed 's/..//'`; shift;;
	esac
	test -z "$printer" || dvips_conf="$dvips_conf_dir/config.$printer"
	case "$1" in
		add)	if test -z "$2"; then
				echo "Usage: texconfig dvips add PRINTER" >&2
			else
				touch "$dvips_conf_dir/config.$2"
				$TC_MKTEXUPD "$dvips_conf_dir" "config.$2"
			fi;;
		del)	if test -z "$2"; then
				echo "Usage: texconfig dvips del PRINTER" >&2
			else
				rm -f "$dvips_conf_dir/config.$2"
			fi;;
		mode)
			if test -z "$2"; then
			  echo "Usage: texconfig dvips [-P PRINTER] mode MODE" >&2
			  echo "       Valid modes:" >&2                                 
			  echo >&2
			  list_mf_modes $modes | awk '{print $1}' | $FMT >&2       
			  echo >&2
			  echo "See file $modes" >&2                 
			  echo "for more information about these modes." >&2
			else
			  do_dvips_setup_mode "$2"
			fi;;

		printcmd)
			case "$2" in
				"")	echo "Usage: dvips [-P PRINTER] printcmd CMD" >&2
					echo "       For printing, the output will be piped to the CMD" >&2
					echo "       Typically, CMD is set to 'lpr' or 'lpr -P SOME-NAME'." >&2
					echo >&2
					echo "       Use - as CMD to disable direct drinting." >&2;;
				-)	do_dvips_setup_printcmd save-to-file;;
				*)	shift; do_dvips_setup_printcmd ${1+"$@"};;
			esac;;
		offset)	if test -z "$2"; then
				echo "Usage: dvips [-P PRINTER] offset OFFSET" >&2
				echo "       For OFFSET choose a dimension pair, such as '0.4in,-2in'." >&2
			else
			  do_dvips_setup_offset "$2"
			fi;;
		paper)
			if test -z "$2"; then
			  echo "Usage: texconfig dvips paper PAPER" >&2
			  echo "       Valid papertypes:" >&2
			  echo >&2
			  list_dvips_papers $dvips_conf | awk '{print $1}' | $FMT >&2
			else
			  dvips_conf="$dvips_conf_dir/config.ps"
			  do_dvips_setup_paper "$2"
			fi;;
		*)	cat<<-'eof'
			Usage: texconfig dvips add PRINTER
			       texconfig dvips del PRINTER
			       texconfig dvips paper PAPER
			       texconfig dvips [-P PRINTER] mode MODE
			       texconfig dvips [-P PRINTER] offset OFFSET
			       texconfig dvips [-P PRINTER] printcmd CMD
			eof
	esac
}

cmd_mode_xdvi()
{
	case $# in
	    1)	do_xdvi_setup_paper "$1";;
	    *)	{ echo 'Usage: texconfig xdvi PAPER'
		  echo "       recognised papersizes are:"; echo
		  echo "`list_xdvi_papers | awk '{print $1}' | $FMT`"; } >&2
	esac
}

test_in_list()
{
	obj="$1"; shift
	test -z "$obj" && return 1
	for i
	do
		test "$obj" = "$i" && return 0
	done
	echo "Error: value '$obj' not in list '$@'." >&2
	return 1
}
	

init_tex_formats()
{
	run_config_tex tex.ini
	test -d $TC_TEXMFMAIN/etex && run_config_tex etex.ini
	test -d $TC_TEXMFMAIN/pdftex && run_config_tex pdftex.ini
	test -d $TC_TEXMFMAIN/tex/latex && run_config_tex latex.ini
	test -d $TC_TEXMFMAIN/etex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex elatex.ini
	test -d $TC_TEXMFMAIN/pdftex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex pdflatex.ini
	test -d $TC_TEXMFMAIN/tex/amstex && run_config_tex amstex.ini
	test -d $TC_TEXMFMAIN/tex/jadetex && run_config_tex jadetex.ini
	test -d $TC_TEXMFMAIN/tex/eplain && run_config_tex eplain.ini
	test -d $TC_TEXMFMAIN/tex/latex209 && run_config_tex latex209.ini
        test -d $TC_TEXMFMAIN/omega && run_config_tex omega.ini
        test -d $TC_TEXMFMAIN/omega &&
	  test -d $TC_TEXMFMAIN/tex/latex && run_config_tex lambda.ini

}

init_all()
{
	init_tex_formats
	run_config_mf
	check_for_binary mpost >/dev/null && run_config_mp
}


edit_hyphen()
{
	$EDIT $language
	init_tex_formats
}

check_for_binary()
{
  testbin=$1
  set x `echo "$PATH" | sed 's/^:/.:/; s/:$/:./; s/::/:.:/g; s/:/ /g'`; shift
  for i
  do
    if [ -x "$i/$testbin" ]; then
      echo "$i/$testbin"
      return 0
    fi
  done
  return 1
}

require_binary()
{
	for this_binary
	do
		check_for_binary $this_binary >/dev/null
		if [ $? != 0 ]; then
			echo "texconfig: binary $this_binary not found. Please set up your PATH correctly" >&2
			exit 1
		fi
	done
}

echo_locate_binary()
{
	for locate_this_bin
	do
		location=`check_for_binary $locate_this_bin`
		if [ $? = 0 ]; then
			echo "$locate_this_bin:	$location"
		else
			echo "$locate_this_bin not found."
		fi
	done
}

echo_show_variable()
{
	for this_var
	do
		var=$this_var
		eval val=\"\${$var+=}\${$var- is unset}\"
		echo "$var$val"
	done | grep -v 'is unset$'
}

echo_file_location()
{
	if [ -f "$2" ]; then
		echo "$1: $2"
	else
		echo "$1 not found."
	fi
}

do_print_setup()
{
	echo '==================== binaries found by searching $PATH ==================='
	echo_locate_binary tex etex pdftex omega mf mpost dialog dvips xdvi kpsewhich mktexpk mktextfm
	echo
	echo '=========================== Kpathsea variables ==========================='
	echo_show_variable TEXMF TEXMFMAIN TEXMFLOCAL
	echo
	echo '=============== environment variables (ok if no output here) ============='
	echo_show_variable $envvars
}

show_path()
{
  OIFS=$IFS
  IFS='
'
  echo
  echo '============================= search paths ==============================='
  for i in $kpsevars
  do
    echo $i | awk '{printf("%25s: ", $0)}'
    kpsewhich -show-path="$i"
  done
  IFS=$OIFS
}

do_print_all_setup()
{
  do_print_setup
  show_path $kpsevars
}

print_setup()
{
	do_print_setup | eval $PAGER; fix_pager_more
}

all_mt_features='appendonlydir dosnames nomode stripsupplier striptypeface varfonts'
get_mt_options()
{
	MT_FEATURES=`grep '^:.*MT_FEATURES' $maketex_site_file | sed 's/.*=//;s/}.*//'`
	for feature in $all_mt_features; do
		case "$MT_FEATURES" in
		  *${feature}*)
			eval $feature=on;;
		  *)
			eval $feature=off;;
		esac
	done
}

set_mt_options()
{
	args="$*"
	exist_test -f $texmfcnf

	for feature in $all_mt_features; do
		eval $feature=off
	done

        set x $args; shift
	reslist=
	for i
	do
		test_in_list "$i" $all_mt_features || continue
		reslist="$reslist $i"
	done

	set x $reslist; shift

	MT_FEATURES=$1; test $# -ge 1 && shift
	for i
	do
		MT_FEATURES="$MT_FEATURES:$i"
	done
	config_replace $maketex_site_file '^: ..MT_FEATURES' ": \${MT_FEATURES=$MT_FEATURES}"
}

setup_mt_options()
{
	get_mt_options
	run_dialog --checklist '\nSelect options for mktex scripts. Use the spacebar for enable/disable.\n\n' \
		23 80 6 \
		appendonlydir "set stick bit on new directories (recommended)" $appendonlydir \
		dosnames "dpiNNN/NAME.pk instead of NAME.NNNpk" $dosnames \
		nomode "leave out MODE (e.g. ljfour)" $nomode \
		stripsupplier "leave out SUPPLIER (e.g. ams)" $stripsupplier \
		striptypeface "leave out TYPEFACE (e.g. euler)" $striptypeface \
		varfonts "use \$VARTEXFONTS instead of \$TEXMFLOCAL/fonts" $varfonts \
		  2>$tmpmenu || return
		eval set_mt_options `cat $tmpmenu`
}

setup_query_mkdir()
{
	yesno "\\n\\nCreate directory $1?\\n\\n" 23 80
}

setup_mt_vardir()
{
	VARTEXFONTS=`kpsewhich -expand-var '$VARTEXFONTS'`
	run_dialog --inputbox \
	"Your \$VARTEXFONTS directory currently\\nis set to $VARTEXFONTS.\\n\\nPress RETURN to accept this default or enter\\nthe name of an other directory.\\n\\n" \
	23 80 2>$tmpmenu || return
	x=`cat $tmpmenu`
	test -z "$x" && return
	test -d "$x" || setup_query_mkdir "$x" || return
	do_setup_mt_vardir "$x" 2>&1 | tee -a $log
}

do_setup_mt_vardir()
{
	vardir=$1
	test -d "$vardir" ||
		{ mkdir "$vardir" && chmod 755 "$vardir"; } || return 1
	test -d "$vardir/pk" ||
		{ mkdir "$vardir/pk" && chmod 1777 "$vardir/pk"; } || return 1
	test -d "$vardir/tfm" ||
		{ mkdir "$vardir/tfm" && chmod 1777 "$vardir/tfm"; } || return 1
	test -d "$vardir/source" ||
		{ mkdir "$vardir/source" && chmod 1777 "$vardir/source"; } || return 1

	config_replace $texmfcnf '^VARTEXFONTS' "VARTEXFONTS  = $vardir"
}


setup_mt()
{
    while true; do
	ex=eufm10
	OIFS=$IFS
	IFS=': '
	set x `$MT_MKTEXNAM $ex`
	IFS=$OIFS
	pk=$2 tfm=$3
	run_dialog \
		--menu "\nSet up target directories for font creation.\n\nExample: current settings for font $ex with default mode\\n         are (tfm resp. pk):\\n\\n $tfm\\n $pk\n\n" \
		23 80 7 \
		RETURN 'back to main menu' \
		FONTRO 'remove global write permissions from standard fonts tree' \
		FONTRW 'add global write permissions to standard fonts tree' \
		OPTIONS 'set up options for mktex scripts' \
		VARDIR 'directory for new fonts (if varfonts option active)' \
		LOG   'view logfile' \
		2>$tmpmenu || return
	ans=`cat $tmpmenu`
	test -z "$ans" && return
	case "$ans" in
		VARDIR)      setup_mt_vardir ;;
		OPTIONS)      setup_mt_options ;;
		FONTRO)
			get_mt_options
			VARTEXFONTS=`kpsewhich -expand-var '$VARTEXFONTS'`
			if test "$varfonts" != on; then
				run_dialog --msgbox \
					'\n\n\nPlease enable the varfonts feature (OPTIONS menue) first.' \
					23 80
				continue
			fi
			if test ! -d "$VARTEXFONTS"; then
				run_dialog --msgbox \
					'\n\n\nPlease make sure that the VARTEXFONTS directory exists and try again.' \
					23 80
				continue
			fi
			if test -z "$VARTEXFONTS"; then
				run_dialog --msgbox \
					'\n\n\nPlease set up a non-empty VARTEXFONTS directory (VARDIR menue) first.' \
					23 80
				continue
			fi
			fonts_ro;;
		FONTRW) fonts_rw;;
		LOG)      clear; <$log eval $PAGER; fix_pager_more;;
		RETURN)   return ;;
	esac
    done
}

locate_files()
{
	language=`kpsewhich -format=.tex language.dat`
	modes=`kpsewhich modes.mf`
	texmfcnf=`kpsewhich texmf.cnf`
	maketex_site_file=`kpsewhich --format='web2c files' mktex.cnf`
	xdvi_app_file=`XDVIINPUTS="$XDVIINPUTS":'$TEXMF/{xdvi,web2c}' kpsewhich -progname=xdvi --format='other text files' XDvi`
}

# This function rebuilds the html index to the local documentation
# By Ottavio G. Rizzo
rebuild_doc()
{
	run_dialog --inputbox \
		"I assume the local TeX documentation is in\\n$doc\\n\\nPress RETURN if this is true or enter the name of the directory.\\n\\n" \
		23 80 2>$tmpmenu || return
	x=`cat $tmpmenu`
	test -z "$x" || doc=$x
	if  test -d $doc 
	# Did I get a meaningful directory?
	then
	   (
		cd $doc 
		helpindex=`\ls -l helpindex.html 2>/dev/null | awk '{print $NF}'`
		case $helpindex in
		  "") helpindex=$doc/helpindex.html;;
		  /*) ;;
		  *)  helpindex=$doc/$helpindex;;
		esac
		mv -f $helpindex $helpindex.BAK
		# Warn the user it's going to take a while
		run_dialog --infobox \
			"This could take some time, please wait." \
			3 80
		./mkhtml > $helpindex  2>> $log
	   )
	else
		clear
		echo -e '\n\n\n\n'
		echo "$doc doesn't exist!" | tee -a $log
		echo "Press a key to continue"
		read foo
	fi
}

#------------------ begin: initialisation -----------------------------------
check_environ
require_binary kpsewhich pwd

: ${TC_TEXMFMAIN=`kpsewhich --expand-path='$TEXMFMAIN'`}
TEXMFMAIN=$TC_TEXMFMAIN

if test -z "$TEXMFMAIN"; then
  echo "$0: No \$TEXMFMAIN; set the environment variable or in texmf.cnf." >&2
  exit 1
fi

: ${TC_MKTEX_OPT=`kpsewhich --format='web2c files' mktex.opt`}
test -n "$TC_MKTEX_OPT" || TC_MKTEX_OPT="$TC_TEXMFMAIN/web2c/mktex.opt"

: ${TC_MKTEXDIR=`kpsewhich --format='web2c files' mktexdir`}
test -n "$TC_MKTEXDIR" || TC_MKTEXDIR="$TC_TEXMFMAIN/web2c/mktexdir"

: ${TC_MKTEXUPD=`kpsewhich --format='web2c files' mktexupd`}
test -n "$TC_MKTEXUPD" || TC_MKTEXUPD="$TC_TEXMFMAIN/web2c/mktexupd"

: ${TC_MKTEXNAM=`kpsewhich --format='web2c files' mktexnam`}
test -n "$TC_MKTEXNAM" || TC_MKTEXNAM="$TC_TEXMFMAIN/web2c/mktexnam"

# The texmf tree where we put generated files into. Defaults to system tree:
: ${TC_TEXMF_CNF=`kpsewhich -expand-var='$TEXMF_CNF'`}
test -n "$TC_TEXMF_CNF" || TC_TEXMF_CNF=$TC_TEXMFMAIN

: ${TC_DFT_XDVI_APP=`XDVIINPUTS="$XDVIINPUTS":'$TEXMF/{xdvi,web2c}' kpsewhich -progname=xdvi --format='other text files' XDvi`}
test -n "$TC_DFT_XDVI_APP" && TC_DFT_XDVI_APP="$TC_TEXMFMAIN/xdvi/XDvi"

: ${TC_DFT_MKTEX_CNF=`kpsewhich --format='web2c files' mktex.cnf`}
test -n "$TC_DFT_MKTEX_CNF" && test -f "$TC_TEXMFMAIN/web2c/mktex.cnf" &&
  TC_DFT_MKTEX_CNF="$TC_TEXMFMAIN/web2c/mktex.cnf"

: ${TC_DFT_CONFIG_PS=`kpsewhich -format='dvips config' config.ps`}
test -n "$TC_DFT_CONFIG_PS" && TC_DFT_CONFIG_PS=$TC_TEXMFMAIN/dvips/config/config.ps

: ${TC_DFT_LANGUAGE_DAT=`kpsewhich -format=.tex language.dat`}
test -n "$TC_DFT_LANGUAGE_DAT" && TC_DFT_LANGUAGE_DAT=$TC_TEXMFMAIN/tex/generic/config/language.dat

# The fallback directory for private scripts and config files.
: ${TEXMF=`kpsewhich -expand-var '$TEXMF'`}
: ${DIALOG_TERMINFO=$TC_TEXMFMAIN/texconfig}
: ${DIALOG_TERM=generic}

formats=$TC_TEXMF_CNF/web2c
bases=$TC_TEXMF_CNF/web2c
mems=$TC_TEXMF_CNF/web2c
xdvi_app_dir=$TC_TEXMF_CNF/xdvi
xdvi_app_file=$xdvi_app_dir/XDvi
dvips_conf_dir=$TC_TEXMF_CNF/dvips/config
maketex_site_dir=$TC_TEXMF_CNF/web2c
maketex_site_file=$maketex_site_dir/mktex.cnf
language_dat_dir=$TC_TEXMF_CNF/tex/generic/config
language_dat_file=$language_dat_dir/language.dat
doc=$TC_TEXMFMAIN/doc

FAQ=$doc/tetex/teTeX-FAQ

# don't make ls-R files twice, so we check for a rehash option first:
set x $SAVE_ARGS; shift
case "$1" in
  rehash) mktexlsr; exit;;
esac

# no rehash option, so make sure we have all necessary ls-R files:
for dir in $TC_TEXMFMAIN $TC_TEXMF_CNF; do
  if [ ! -r $dir/ls-R ]; then
    require_binary mktexlsr
    mktexlsr $dir
  fi
done

for i in "$dvips_conf_dir" "$formats" "$bases" "$mems" "$xdvi_app_dir" \
  "$language_dat_dir"; do
  test -d $i || $TC_MKTEXDIR "$i"
done

test -f $maketex_site_file || {
  if test -n "$TC_DFT_MKTEX_CNF" && test -f "$TC_DFT_MKTEX_CNF"; then
    cp "$TC_DFT_MKTEX_CNF" $maketex_site_file
  else
    touch $maketex_site_file
  fi
  $TC_MKTEXUPD $maketex_site_dir mktex.cnf
}

test -f $xdvi_app_file || {
  cp $TC_DFT_XDVI_APP $xdvi_app_file
  $TC_MKTEXUPD $xdvi_app_dir XDvi
}

test -f $dvips_conf_dir/config.ps || {
  cp $TC_DFT_CONFIG_PS $dvips_conf_dir/config.ps
  $TC_MKTEXUPD $dvips_conf_dir config.ps
}

if test ! -f $language_dat_file; then
  cp $TC_DFT_LANGUAGE_DAT $language_dat_file
  $TC_MKTEXUPD $language_dat_dir language.dat
fi

locate_files

exist_test -d $tmpdir

EDIT=${VISUAL-${EDITOR-$std_editor}}
PAGER=${PAGER-$std_pager}

check_for_binary dialog >/dev/null
dialogok=$?

# we have called some shellfunctions, so for HP-UX's shell, we need
# to set the positional parameters this again:
set x $SAVE_ARGS; shift
if [ $dialogok != 0 ] && [ $# = 0 ]; then
        set help
fi

#------------------ end: initialisation -----------------------------------

if test $# -ge 1; then
	test -d $tmpdir || mkdir $tmpdir
	cd $tmpdir
	trap 'cd / ; rm -rf $tmpdir; trap '' 0; exit 0' 0 1 2 6 13 15
	cmd_mode ${1+"$@"}
fi

test -f $mems/mpost.mem ||
	run_config_mp

test -f $bases/mf.base ||
	run_config_mf

test -f $formats/tex.fmt ||
  test -f $formats/tex.efmt ||
	{ run_config_tex tex.ini; }

test -f $formats/etex.fmt ||
  test -f $formats/etex.efmt ||
        { test -d $TC_TEXMFMAIN/etex && run_config_tex etex.ini; }

test -f $formats/pdftex.fmt ||
  test -f $formats/pdftex.efmt ||
        { test -d $TC_TEXMFMAIN/pdftex && run_config_tex pdftex.ini; }

test -f $formats/latex.fmt ||
  test -f $formats/latex.efmt ||
        { test -d $TC_TEXMFMAIN/tex/latex && run_config_tex latex.ini; }

test -f $formats/elatex.fmt ||
  test -f $formats/elatex.efmt ||
        { test -d $TC_TEXMFMAIN/etex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex elatex.ini; }

test -f $formats/pdflatex.fmt ||
  test -f $formats/pdflatex.efmt ||
        { test -d $TC_TEXMFMAIN/pdftex &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex pdflatex.ini; }

test -f $formats/amstex.fmt ||
  test -f $formats/amstex.efmt ||
        { test -d $TC_TEXMFMAIN/tex/amstex && run_config_tex amstex.ini; }

test -f $formats/jadetex.fmt ||
  test -f $formats/jadetex.efmt ||
        { test -d $TC_TEXMFMAIN/tex/jadetex && run_config_tex jadetex.ini; }

test -f $formats/eplain.fmt ||
  test -f $formats/eplain.efmt ||
        { test -d $TC_TEXMFMAIN/tex/eplain && run_config_tex eplain.ini; }

test -f $formats/latex209.fmt ||
  test -f $formats/latex209.efmt ||
        { test -d $TC_TEXMFMAIN/tex/latex209 && run_config_tex latex209.ini; }

test -f $formats/omega.fmt ||
        { test -d $TC_TEXMFMAIN/omega && run_config_tex omega.ini; }

test -f $formats/lambda.fmt ||
        { test -d $TC_TEXMFMAIN/omega &&
          test -d $TC_TEXMFMAIN/tex/latex && run_config_tex lambda.ini; }

check_terminal
cat <<eof

The interactive texconfig utility will be started now. Make sure your
screen has at least 24 rows and 80 columns. If texconfig crashes now,
you can still set up your $version system using the batch mode of texconfig.
Try 'texconfig help' to get a list of options.

eof
$echon "Starting dialog utility... "

# The steps below will clear the screen. Make sure, all error messages
# can be read. The sleep may be annoying, but I think, it is useful if
# something goes wrong.
sleep 4

trap 'cd /; rm -rf $tmpdir; trap 0; exit 0' 0 1 2 6 13 15
test -d $tmpdir && { echo "$tmpdir: directory already exists."; exit; }
mkdir $tmpdir || exit
cd $tmpdir || exit
echo "TeX-Config. Start on `date`" >$log

while true ; do
		#--title "TeX-Config main menu" \
	run_dialog \
		--menu "
Hint: all output of external commands (e.g. tex) is logged into
a file. You can look at this file using "LOG". If cursor keys make
trouble, you may have more luck with +/- and TAB.

" 23 80 12 \
		"EXIT"	'exit' \
		"PREF"	'personal preferences' \
		"CONF"	'show configuration' \
		"REHASH"	'rebuild ls-R database' \
		"HYPHEN"	'hyphenation table (tex/latex)' \
		"MODE"	'default mode (xdvi/dvips/mf)' \
		"XDVI"	'xdvi configuration' \
		"DVIPS"	'dvips configuration' \
		"FONT"	'directories for font creation' \
		"DOC"	'rebuild html documentation' \
                "FAQ"   'frequently asked questions + answers' \
		"LOG"	'view logfile' \
		2>$tmpmenu

	
	case "`cat $tmpmenu`" in
	FAQ)	clear; test -f $FAQ && <$FAQ eval $PAGER; fix_pager_more;;
	CONF)	clear; print_setup;;
	PREF)	setup_preferences ;;
	REHASH)	clear; mktexlsr; locate_files ;;
	HYPHEN)	config_tex;;
	MODE)	get_default_mode;;
	XDVI)	config_xdvi ;;
	DVIPS)	config_dvips ;;
	FONT)	setup_mt;;
	DOC)	rebuild_doc;;
	LOG)	clear; <$log eval $PAGER; fix_pager_more;;
	*)	reset 2>/dev/null; stty sane 2>/dev/null;
		reset 2>/dev/null; clear; exit 0;;
	esac
done
