#! /bin/sh
# This script is a hand-made configure script. It contains a lot of
# code stolen from GNU autoconf. I removed all the code that was not
# useful for configuring a LyX installation.







# Be Bourne compatible (taken from autoconf 2.53)
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  set -o posix
fi

####some configuration variables
outfile=lyxrc.defaults
rc_entries=
lyx_check_config=yes
lyx_keep_temps=no
srcdir=
version_suffix=

#### Parse the command line
for ac_option do
  case "$ac_option" in
    -help | --help | -h)
      cat << EOF
Usage: configure [options]
Options:
  --help                   show this help lines
  --keep-temps             keep temporary files (for debug. purposes)
  --without-latex-config   do not run LaTeX to determine configuration
  --with-version-suffix=suffix suffix of binary installed files
EOF
      exit 0;;
    --without-latex-config)
      lyx_check_config=no ;;
    --keep-temps)
      lyx_keep_temps=yes ;;
    --with-version-suffix*)
      version_suffix=`echo "$ac_option" | sed 's,--with-version-suffix=,,'`
  esac
done


#### Checking for some echo oddities
if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='	'
  else
    ac_n=-n ac_c= ac_t=
  fi
else
  ac_n= ac_c='\c' ac_t=
fi

# For language diagnostic purposes
USERLANG=${LC_ALL:-${LC_CTYPE:-${LANG:-POSIX}}}

#### I do not really know why this is useful, but we might as well keep it.
# NLS nuisances.
# Only set these to C if already set.  These must not be set unconditionally
# because not all systems understand e.g. LANG=C (notably SCO).
# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
# Non-C LC_CTYPE values break the ctype check.
if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi


#### Guess the directory in which configure is located.
ac_prog=$0
srcdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
test "x${srcdir}" = "x$ac_prog" && srcdir=.
if test ! -r "${srcdir}"/chkconfig.ltx ; then
  echo "configure: error: cannot find chkconfig.ltx script"
  exit 1
fi

#### Adjust PATH for Win32 (Cygwin)
use_cygwin_path_fix=''
case `uname -s` in
   CYGWIN*)
     tmpfname="/tmp/x$$.ltx";
     echo "\\documentstyle{article}" > $tmpfname
     echo "\\begin{document}\\end{document}" >> $tmpfname
     inpname=`cygpath -w $tmpfname | tr '\\\\' /`
     echo "\\input{$inpname}" > wrap_temp$$.ltx
     check_err=`latex wrap_temp$$.ltx 2>&1 < /dev/null | grep Error`
     rm -f wrap_temp$$.* /tmp/x$$.*
     if [ x"$check_err" = "x" ]
     then
       echo "configure: cygwin detected; path correction"
       srcdir=`cygpath -w "${srcdir}" | tr '\\\\' /`
       echo "srcdir=${srcdir}"
       use_cygwin_path_fix='true'
     else
       echo "configure: cygwin detected; path correction is not needed"
       use_cygwin_path_fix='false'
     fi
     ;;
esac

#### Create the build directories if necessary
for dir in bind clipart doc examples help images kbd layouts reLyX \
    scripts templates ui xfonts; do
  test ! -d $dir && mkdir $dir
done


#### Searching some useful programs
# Search LaTeX2e
echo $ac_n "checking for a LaTeX2e program""... $ac_c"
echo "$ac_t""(latex latex2e)"
LATEX=
for ac_prog in latex latex2e
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      LATEX="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$LATEX"; then
    ac_result=yes
    
## Check whether this is really LaTeX2e
rm -f chklatex.ltx
cat >chklatex.ltx <<EOF
\\nonstopmode\\makeatletter
\\ifx\\undefined\\documentclass\\else
  \\message{ThisIsLaTeX2e}
\\fi
\\@@end
EOF
if eval ${LATEX} chklatex.ltx </dev/null 2>/dev/null \
		       | grep 'ThisIsLaTeX2e' >/dev/null; then
  :
else
  LATEX=
  ac_result="not useable"
fi
rm -f chklatex.ltx chklatex.log
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$LATEX" && break
fi
done

if test -z "$LATEX" ; then
  LATEX=none
    lyx_check_config=no
fi

latex_to_dvi=$LATEX
test -z "$latex_to_dvi" && latex_to_dvi="none"

# Search for pdflatex
if test ${lyx_check_config} = no ; then
  latex_to_pdf=none
else
  echo $ac_n "checking for the pdflatex program""... $ac_c"
echo "$ac_t""(pdflatex)"
latex_to_pdf=
for ac_prog in pdflatex
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      latex_to_pdf="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$latex_to_pdf"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$latex_to_pdf" && break
fi
done

if test -z "$latex_to_pdf" ; then
  latex_to_pdf=none
fi

fi

# Search for latex2rtf
if test ${lyx_check_config} = no ; then
  latex_to_rtf=none
else
  echo $ac_n "checking for the latex2rtf program""... $ac_c"
echo "$ac_t""(latex2rtf)"
latex_to_rtf=
for ac_prog in latex2rtf
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      latex_to_rtf="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$latex_to_rtf"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$latex_to_rtf" && break
fi
done

if test -z "$latex_to_rtf" ; then
  latex_to_rtf=none
fi

fi

test $latex_to_dvi != "none" && latex_to_dvi="$latex_to_dvi \$\$i"
test $latex_to_pdf != "none" && latex_to_pdf="$latex_to_pdf \$\$i"
test $latex_to_rtf != "none" && latex_to_rtf="$latex_to_rtf \$\$i"

# Search for an installed reLyX or a ready-to-install one
save_PATH=${PATH}
PATH=${PATH}:./reLyX/
echo $ac_n "checking for a LaTeX -> LyX converter""... $ac_c"
echo "$ac_t""(reLyX)"
tex_to_lyx_command=
for ac_prog in reLyX
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      tex_to_lyx_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$tex_to_lyx_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$tex_to_lyx_command" && break
fi
done

if test -z "$tex_to_lyx_command" ; then
  tex_to_lyx_command=none
fi

PATH=${save_PATH}
test $tex_to_lyx_command = "reLyX" && tex_to_lyx_command="reLyX -f \$\$i"
tex_to_lyx_command=`echo $tex_to_lyx_command | sed "s,reLyX,reLyX$version_suffix,"`

echo $ac_n "checking for a Noweb -> LyX converter""... $ac_c"
echo "$ac_t""(noweb2lyx)"
literate_to_lyx_command=
for ac_prog in noweb2lyx
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      literate_to_lyx_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$literate_to_lyx_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$literate_to_lyx_command" && break
fi
done

if test -z "$literate_to_lyx_command" ; then
  literate_to_lyx_command=none
fi

test $literate_to_lyx_command = "noweb2lyx" && literate_to_lyx_command="noweb2lyx \$\$i \$\$o"
literate_to_lyx_command=`echo $literate_to_lyx_command | sed "s,noweb2lyx,noweb2lyx$version_suffix,"`

# Search something to process a literate document
echo $ac_n "checking for a Noweb -> LaTeX converter""... $ac_c"
echo "$ac_t""(noweave)"
literate_to_tex_command=
for ac_prog in noweave
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      literate_to_tex_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$literate_to_tex_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$literate_to_tex_command" && break
fi
done

if test -z "$literate_to_tex_command" ; then
  literate_to_tex_command=none
fi

test $literate_to_tex_command = "noweave" && literate_to_tex_command="noweave -delay -index \$\$i > \$\$o"

echo $ac_n "checking for an HTML -> LaTeX converter""... $ac_c"
echo "$ac_t""(html2latex)"
html_to_latex_command=
for ac_prog in html2latex
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      html_to_latex_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$html_to_latex_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$html_to_latex_command" && break
fi
done

if test -z "$html_to_latex_command" ; then
  html_to_latex_command=none
fi

test $html_to_latex_command = "html2latex" && html_to_latex_command="html2latex \$\$i"

echo $ac_n "checking for an MS Word -> LaTeX converter""... $ac_c"
echo "$ac_t""(wvCleanLatex word2x)"
word_to_latex_command=
for ac_prog in wvCleanLatex word2x
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      word_to_latex_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$word_to_latex_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$word_to_latex_command" && break
fi
done

if test -z "$word_to_latex_command" ; then
  word_to_latex_command=none
fi

test "$word_to_latex_command" = "wvCleanLatex" && word_to_latex_command="wvCleanLatex \$\$i \$\$o"
test "$word_to_latex_command" = "word2x" && word_to_latex_command="word2x -f latex \$\$i"

# tex4ht generates HTML output that is well-suited for MS Word
echo $ac_n "checking for a LaTeX -> MS Word converter""... $ac_c"
echo "$ac_t""(htlatex)"
latex_to_word_command=
for ac_prog in htlatex
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      latex_to_word_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$latex_to_word_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$latex_to_word_command" && break
fi
done

if test -z "$latex_to_word_command" ; then
  latex_to_word_command=none
fi

test "$latex_to_word_command" = "htlatex" && latex_to_word_command="htlatex \$\$i 'html,word' 'symbol/!' '-cvalidate'"

echo $ac_n "checking for Image converter""... $ac_c"
echo "$ac_t""(convert)"
image_command=
for ac_prog in convert
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      image_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$image_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$image_command" && break
fi
done

if test -z "$image_command" ; then
  image_command=none
fi

test $image_command = "convert" && image_command="convert \$\$i \$\$o"

# Search something to preview postscript
echo $ac_n "checking for a Postscript previewer""... $ac_c"
echo "$ac_t""(gsview32 gv ghostview kghostview)"
GHOSTVIEW=
for ac_prog in gsview32 gv ghostview kghostview
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      GHOSTVIEW="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$GHOSTVIEW"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$GHOSTVIEW" && break
fi
done

if test -z "$GHOSTVIEW" ; then
  GHOSTVIEW=none
fi

case $GHOSTVIEW in
  ghostview) PS_VIEWER="$GHOSTVIEW -swap" ;;
  *) PS_VIEWER="$GHOSTVIEW";;
esac
EPS_VIEWER=$GHOSTVIEW

# Search for a program to preview pdf
echo $ac_n "checking for a PDF previewer""... $ac_c"
echo "$ac_t""(acrobat acrord32 gsview32 acroread gv ghostview xpdf kpdf kghostview)"
PDF_VIEWER=
for ac_prog in acrobat acrord32 gsview32 acroread gv ghostview xpdf kpdf kghostview
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      PDF_VIEWER="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$PDF_VIEWER"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$PDF_VIEWER" && break
fi
done

if test -z "$PDF_VIEWER" ; then
  PDF_VIEWER=none
fi


# Search for a program to preview rtf
echo $ac_n "checking for a RTF preview""... $ac_c"
echo "$ac_t""(abiword oowriter kword)"
RTF_VIEWER=
for ac_prog in abiword oowriter kword
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      RTF_VIEWER="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$RTF_VIEWER"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$RTF_VIEWER" && break
fi
done

if test -z "$RTF_VIEWER" ; then
  RTF_VIEWER=none
fi


# Search something to preview dvi
echo $ac_n "checking for a DVI previewer""... $ac_c"
echo "$ac_t""(xdvi windvi yap kdvi)"
DVI_VIEWER=
for ac_prog in xdvi windvi yap kdvi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      DVI_VIEWER="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$DVI_VIEWER"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$DVI_VIEWER" && break
fi
done

if test -z "$DVI_VIEWER" ; then
  DVI_VIEWER=none
fi


# Search something to preview html
echo $ac_n "checking for an HTML previewer""... $ac_c"
echo "$ac_t""("firefox file://\$\$p\$\$i" netscape)"
HTML_VIEWER=
for ac_prog in "firefox file://\$\$p\$\$i" netscape
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      HTML_VIEWER="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$HTML_VIEWER"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$HTML_VIEWER" && break
fi
done

if test -z "$HTML_VIEWER" ; then
  HTML_VIEWER=none
fi


# Search for a program to convert ps to pdf
echo $ac_n "checking for a PS to PDF converter""... $ac_c"
echo "$ac_t""("ps2pdf13 \$\$i")"
ps_to_pdf_command=
for ac_prog in "ps2pdf13 \$\$i"
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      ps_to_pdf_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$ps_to_pdf_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$ps_to_pdf_command" && break
fi
done

if test -z "$ps_to_pdf_command" ; then
  ps_to_pdf_command=none
fi


# Search for a program to convert dvi to ps
echo $ac_n "checking for a DVI to PS converter""... $ac_c"
echo "$ac_t""(dvips)"
dvi_to_ps_command=
for ac_prog in dvips
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      dvi_to_ps_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$dvi_to_ps_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$dvi_to_ps_command" && break
fi
done

if test -z "$dvi_to_ps_command" ; then
  dvi_to_ps_command=none
fi

test $dvi_to_ps_command = "dvips" && dvi_to_ps_command="dvips -o \$\$o \$\$i"

# Search for a program to convert dvi to pdf
echo $ac_n "checking for a DVI to PDF converter""... $ac_c"
echo "$ac_t""(dvipdfm)"
dvi_to_pdf_command=
for ac_prog in dvipdfm
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      dvi_to_pdf_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$dvi_to_pdf_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$dvi_to_pdf_command" && break
fi
done

if test -z "$dvi_to_pdf_command" ; then
  dvi_to_pdf_command=none
fi

test $dvi_to_pdf_command = "dvipdfm" && dvi_to_pdf_command="dvipdfm \$\$i"

# We have a script to convert previewlyx to ppm
lyxpreview_to_bitmap_command="python \$\$s/scripts/lyxpreview2ppm.py"

# Search a *roff program (used to translate tables in ASCII export)
echo $ac_n "checking for a *roff formatter""... $ac_c"
echo "$ac_t""("groff -t -Tlatin1 \$\$FName" nroff)"
prog=
for ac_prog in "groff -t -Tlatin1 \$\$FName" nroff
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      prog="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$prog"; then
    ac_result=yes
    test "$prog" = "nroff" && prog='tbl $$FName | nroff'
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$prog" && break
fi
done

if test -z "$prog" ; then
  prog=none
fi

rc_entries="$rc_entries
\ascii_roff_command \"$prog\""

# Search the ChkTeX program
echo $ac_n "checking for ChkTeX""... $ac_c"
echo "$ac_t""("chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38")"
prog=
for ac_prog in "chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38"
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      prog="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$prog"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$prog" && break
fi
done

if test -z "$prog" ; then
  prog=none
fi

rc_entries="$rc_entries
\chktex_command \"$prog\""

# Search for a spellchecker
echo $ac_n "checking for a spellchecker""... $ac_c"
echo "$ac_t""(ispell)"
prog=
for ac_prog in ispell
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      prog="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$prog"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$prog" && break
fi
done

if test -z "$prog" ; then
  prog=none
fi

rc_entries="$rc_entries
\spell_command \"$prog\""

# Search for computer algebra systems
echo $ac_n "checking for Octave""... $ac_c"
echo "$ac_t""(octave)"
OCTAVE=
for ac_prog in octave
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      OCTAVE="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$OCTAVE"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$OCTAVE" && break
fi
done

if test -z "$OCTAVE" ; then
  OCTAVE=none
fi

echo $ac_n "checking for Maple""... $ac_c"
echo "$ac_t""(maple)"
MAPLE=
for ac_prog in maple
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      MAPLE="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$MAPLE"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$MAPLE" && break
fi
done

if test -z "$MAPLE" ; then
  MAPLE=none
fi



# Search a GUI Fax program
echo $ac_n "checking for a fax program""... $ac_c"
echo "$ac_t""(kdeprintfax ksendfax)"
fax_command=
for ac_prog in kdeprintfax ksendfax
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      fax_command="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$fax_command"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$fax_command" && break
fi
done

if test -z "$fax_command" ; then
  fax_command=none
fi

test $fax_command != "none" && fax_command="$fax_command \$\$i"

# Search for LinuxDoc support
echo $ac_n "checking for SGML-tools 1.x (LinuxDoc)""... $ac_c"
echo "$ac_t""(sgml2lyx)"
LINUXDOC=
for ac_prog in sgml2lyx
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      LINUXDOC="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$LINUXDOC"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$LINUXDOC" && break
fi
done

if test -z "$LINUXDOC" ; then
  LINUXDOC=none
fi

if test $LINUXDOC != none; then
  chk_linuxdoc=yes
  bool_linuxdoc=true
  linuxdoc_cmd="\\def\\haslinuxdoc{yes}"
else
  chk_linuxdoc=no
  bool_linuxdoc=false
fi

case $LINUXDOC in
  sgml2lyx)
    linuxdoc_to_latex_command="sgml2latex \$\$i"
    linuxdoc_to_dvi_command="sgml2latex -o dvi \$\$i"
    linuxdoc_to_html_command="sgml2html \$\$i"
    linuxdoc_to_lyx_command="sgml2lyx \$\$i";;
  none)
    linuxdoc_to_latex_command="none"
    linuxdoc_to_dvi_command="none"
    linuxdoc_to_html_command="none"
    linuxdoc_to_lyx_command="none";;
esac

# Search for DocBook support
echo $ac_n "checking for SGML-tools 2.x (DocBook) or db2x scripts""... $ac_c"
echo "$ac_t""(sgmltools db2dvi)"
DOCBOOK=
for ac_prog in sgmltools db2dvi
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      DOCBOOK="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$DOCBOOK"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$DOCBOOK" && break
fi
done

if test -z "$DOCBOOK" ; then
  DOCBOOK=none
fi

if test $DOCBOOK != none; then
  chk_docbook=yes
  bool_docbook=true
  docbook_cmd="\\def\\hasdocbook{yes}"
else
  chk_docbook=no
  bool_docbook=false
fi

case $DOCBOOK in
  sgmltools)
    docbook_to_dvi_command="sgmltools -b dvi \$\$i"
    docbook_to_html_command="sgmltools -b html \$\$i";;
  db2dvi)
    docbook_to_dvi_command="db2dvi \$\$i"
    docbook_to_html_command="db2html \$\$i";;
  none)
    docbook_to_dvi_command="none"
    docbook_to_html_command="none";;
esac

# Search for a spool command
echo $ac_n "checking for a spool command""... $ac_c"
echo "$ac_t""(lp lpr)"
prog=
for ac_prog in lp lpr
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      prog="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$prog"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$prog" && break
fi
done

if test -z "$prog" ; then
  prog=none
fi

rc_entries="$rc_entries
\print_spool_command \"$prog\""
case $prog in
  lp) print_spool_printerprefix="-d ";;
 lpr) print_spool_printerprefix="-P";;
   *) :;; # leave to empty values
esac
rc_entries="$rc_entries
\print_spool_printerprefix \"$print_spool_printerprefix\""

echo $ac_n "checking for a LaTeX -> HTML converter""... $ac_c"
echo "$ac_t""(htlatex tth latex2html hevea)"
TOHTML=
for ac_prog in htlatex tth latex2html hevea
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      TOHTML="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$TOHTML"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$TOHTML" && break
fi
done

if test -z "$TOHTML" ; then
  TOHTML=none
fi

latex_to_html_command=$TOHTML
case $TOHTML in
    htlatex) latex_to_html_command="htlatex \$\$i";;
	tth) latex_to_html_command="tth -t -e2 -L\$\$b < \$\$i > \$\$o";;
 latex2html) latex_to_html_command="latex2html -no_subdir -split 0 -show_section_numbers \$\$i";;
      hevea) latex_to_html_command="hevea -s \$\$i";;
esac

#### Explore the LaTeX configuration
echo $ac_n "checking LaTeX configuration""... $ac_c"
# First, remove the files that we want to re-create
rm -f textclass.lst packages.lst chkconfig.sed
if test ${lyx_check_config} = no ; then
  echo "$ac_t""default values"
  echo $ac_n "+checking list of textclasses""... $ac_c"
  cat >textclass.lst <<EOF
# This file declares layouts and their associated definition files
# (include dir. relative to the place where this file is).
# It contains only default values, since chkconfig.ltx could not be run
# for some reason. Run ./configure if you need to update it after a
# configuration change.
EOF
  # build the list of available layout files and convert it to entries
  # for the default textclass.lst file
  for file in ./layouts/*.layout "${srcdir}"/layouts/*.layout ; do
    case $file in
      */\*.layout) ;;
      *) if test -r "$file" ; then
           class=`echo $file | sed -e 's%^.*layouts/\(.*\)\.layout$%\1%'`
           cleanclass=`echo $class | tr ' -' '__'`
           # make sure the same class is not considered twice
           if test  x`eval echo $ac_n '${found_'$cleanclass'}'` = x ; then
             eval "found_$cleanclass=yes"
	     sed -n '
# We manipulate only those lines that contain
# "\Declare(LaTeX|DocBook|LinuxDoc)Class"
/\\DeclareLaTeXClass/bmatch
/\\DeclareDocBookClass/bmatch
/\\DeclareLinuxDocClass/bmatch
b

:match
# Remove the \DeclareFOOClass macro and add the correct boolean 
# at the end of the line telling whether the class is 
# available
s/^.*\DeclareLaTeXClass *\(.*\)/\1 "false"/
s/^.*\DeclareDocBookClass *\(.*\)/\1 "'$bool_docbook'"/
s/^.*\DeclareLinuxDocClass *\(.*\)/\1 "'$bool_linuxdoc'"/
# If the macro had an optional argument with several 
# parameters, only keep the first one
s/\[\([^,]*\),[^]]*\]/[\1]/
# If the macro did not have an optional argument, provide one 
# (equal to the class name)
s/^{/['$class']{/
# Remove brackets and replace with correctly quoted entries
s/\[\([^]]*\)\] *{\([^}]*\)}/"'$class'" "\1" "\2"/
# Print the maninpulated text
p
# We are interested in the first instance of \DeclareFOOClass only,
# so now quit
q
' "$file" >> textclass.lst
           fi
	 fi ;;
    esac
  done
  echo "$ac_t""done"
else
  echo "$ac_t""auto"
  rm -f wrap_chkconfig.ltx chkconfig.vars chkconfig.classes chklayouts.tex
  if test ! -r "chkconfig.ltx" ; then
    cp "${srcdir}"/chkconfig.ltx .
    rmcopy=true
  fi
  cat >wrap_chkconfig.ltx <<EOF
${linuxdoc_cmd}
${docbook_cmd}
\\input{chkconfig.ltx}
EOF
  ## Construct the list of classes to test for.
  # build the list of available layout files and convert it to commands
  # for chkconfig.ltx
  for file in ./layouts/*.layout "${srcdir}"/layouts/*.layout ; do
    case $file in
      */\*.layout) ;;
      *) if test -r "$file" ; then
           class=`echo $file | sed -e 's%^.*layouts/\(.*\)\.layout$%\1%'`
	   # Generate the proper TestDocClass command for this layout
	   sed -n '
# We manipulate only those lines that contain
# "\Declare(LaTeX|DocBook|LinuxDoc)Class"
/\\DeclareLaTeXClass/bmatch
/\\DeclareDocBookClass/bmatch
/\\DeclareLinuxDocClass/bmatch
b

:match
# Wrap the entire line (minus the leading "# ") inside a
# "\TestDocClass{CLASS}{...}" command
s/^\# *\(.*\)$/\\TestDocClass{'${class}'}{\1}/
# Print the result and quit.
p
q
' "$file"
	 fi ;;
    esac
  done > chklayouts.tex
  ${LATEX} wrap_chkconfig.ltx 2>/dev/null | grep '^\+'
  eval `cat chkconfig.vars | sed 's/-/_/g'`
  test -n "${rmcopy}" && rm -f chkconfig.ltx
fi

# Do we have all the files we need? Useful if latex did not run

# if chkconfig.sed does not exist (because LaTeX did not run),
# then provide a standard version.
if test ! -f chkconfig.sed ; then
  cat >chkconfig.sed <<EOF
s/@.*@/???/g
EOF
fi

echo "creating packages.lst"
# if packages.lst does not exist (because LaTeX did not run),
# then provide a standard version.
if test ! -f packages.lst ; then
  cat >packages.lst <<EOF
# This file should contain the list of LaTeX packages that have been
# recognized by LyX. Unfortunately, since configure could not find
# your LaTeX2e program, the tests have not been run. Run ./configure
# if you need to update it after a configuration change.

EOF
fi

echo "creating doc/LaTeXConfig.lyx"
echo "s/@chk_linuxdoc@/$chk_linuxdoc/g" >> chkconfig.sed
echo "s/@chk_docbook@/$chk_docbook/g" >> chkconfig.sed

if test `uname -s | grep 'MINGW'` ; then
    # Before running chkconfig.sed, remove the trailing '\r'
    # characters that can bugger up various versions of sed.
    tr -d '\r' < chkconfig.sed > chkconfig2.sed
    mv -f chkconfig2.sed chkconfig.sed
fi

sed -f chkconfig.sed "${srcdir}"/doc/LaTeXConfig.lyx.in >doc/LaTeXConfig.lyx

### Let's check whether spaces are allowed in TeX file names
echo $ac_n "checking whether TeX allows spaces in file names""... $ac_c"
if test ${lyx_check_config} = no ; then
  tex_allows_spaces=false
else
  fname="a b"
  rm -f "$fname".tex
  echo "\\message{working^^J}" >"$fname".tex
  if ${LATEX} "$fname" </dev/null | grep 'working' >/dev/null ; then
    echo "$ac_t""yes"
    tex_allows_spaces=true
  else
    echo "$ac_t""no"
    tex_allows_spaces=false
  fi
  rm -f "$fname".* texput.log
fi

echo "creating $outfile"
cat >$outfile <<EOF
# This file has been automatically generated by LyX' lib/configure
# script. It contains default settings that have been determined by
# examining your system. PLEASE DO NOT MODIFY ANYTHING HERE! If you
# want to customize LyX, make a copy of the file LYXDIR/lyxrc as
# ~/.lyx/lyxrc and edit this file instead. Any setting in lyxrc will
# override the values given here.
\\Format text	  txt	ASCII		A
\\Format textparagraph txt ASCII(paragraphs)	""
\\Format docbook  sgml	DocBook		B
\\Format bmp      bmp	BMP		""
\\Format dvi	  dvi	DVI		D
\\Format dia	  dia	DIA		""
\\Format svg	  svg	SVG		""
\\Format eps	  eps	EPS		""
\\Format fax	  ""	Fax		""
\\Format fig	  fig	FIG		""
\\Format agr      agr	Grace		""
\\Format html	  html	HTML		H
\\Format gif	  gif	GIF		""
\\Format jpg	  jpg	JPEG		""
\\Format latex	  tex	LaTeX		L
\\Format rtf	  rtf	RTF		R
\\Format linuxdoc sgml	LinuxDoc	x
\\Format lyx      lyx	LyX		""
\\Format literate nw	NoWeb		N
\\Format pdf	  pdf  "PDF (ps2pdf)"	P
\\Format pdf2	  pdf  "PDF (pdflatex)"	F
\\Format pdf3	  pdf  "PDF (dvipdfm)"	m
\\Format png	  png	PNG		""
\\Format ppm	  ppm	PPM		""
\\Format pgm	  pgm	PGM		""
\\Format pbm	  pbm	PBM		""
\\Format ps	  ps	Postscript	t
\\Format program  ""	Program		""
\\Format tgif     obj	Tgif		""
\\Format tiff     tif	TIFF		""
\\Format word	  doc  "MS Word"	W
\\Format wordhtml html "MS Word (HTML)" ""
\\Format xbm	  xbm	XBM		""
\\Format xpm	  xpm	XPM		""
\\Format lyxpreview	lyxpreview	"LyX Preview"		""

\\converter latex dvi "$latex_to_dvi" "latex"
\\converter latex pdf2 "$latex_to_pdf" "latex"
\\converter latex rtf "$latex_to_rtf" "latex"
\\converter latex html "$latex_to_html_command" "originaldir,needaux"
\\converter latex wordhtml "$latex_to_word_command" ""
\\converter literate latex "$literate_to_tex_command" ""
\\converter dvi pdf3 "$dvi_to_pdf_command" ""
\\converter dvi ps "$dvi_to_ps_command" ""
\\converter ps pdf "$ps_to_pdf_command" ""
\\converter ps fax "$fax_command" ""
\\converter linuxdoc lyx "$linuxdoc_to_lyx_command" ""
\\converter linuxdoc latex "$linuxdoc_to_latex_command" ""
\\converter linuxdoc dvi "$linuxdoc_to_dvi_command" ""
\\converter linuxdoc html "$linuxdoc_to_html_command" ""
\\converter docbook dvi "$docbook_to_dvi_command" ""
\\converter docbook html "$docbook_to_html_command" ""
\\converter lyxpreview ppm "$lyxpreview_to_bitmap_command" ""

\\converter latex lyx "$tex_to_lyx_command" ""
\\converter literate lyx "$literate_to_lyx_command" ""
\\converter html latex "$html_to_latex_command" ""
\\converter word latex "$word_to_latex_command" ""
\converter dia eps "dia \$\$i -e \$\$o" ""
\converter dia ppm "/usr/share/lyx/scripts/dia2ppm.sh \$\$i \$\$o" ""
\converter svg eps "inkscape -z \$\$i -E \$\$o" ""
\converter svg ppm "/usr/share/lyx/scripts/svg2ppm.sh \$\$i \$\$o" ""

\\viewer dvi "$DVI_VIEWER"
\\viewer html "$HTML_VIEWER"
\\viewer pdf "$PDF_VIEWER"
\\viewer pdf2 "$PDF_VIEWER"
\\viewer pdf3 "$PDF_VIEWER"
\\viewer rtf "$RTF_VIEWER"
\\viewer dia "dia"
\\viewer svg "inkview"
\\viewer ps "$PS_VIEWER"
\\viewer eps "$EPS_VIEWER"

$rc_entries
\\font_encoding "$chk_fontenc"
\\tex_allows_spaces $tex_allows_spaces
EOF

if [ "x$use_cygwin_path_fix" != "x" ]
then
  echo "\\cygwin_path_fix_needed $use_cygwin_path_fix" >> $outfile
fi

### the graphic converter part with the predefined ones
#### Search for the nonstandard converting progs
#
echo $ac_n "checking for a FIG -> EPS/PPM/PNG converter""... $ac_c"
echo "$ac_t""(fig2dev)"
FIG2DEV=
for ac_prog in fig2dev
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      FIG2DEV="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$FIG2DEV"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$FIG2DEV" && break
fi
done

if test -z "$FIG2DEV" ; then
  FIG2DEV=none
fi

if test "$FIG2DEV" = "fig2dev"; then
cat >>$outfile <<EOF
\\converter fig eps "fig2dev -L eps \$\$i \$\$o" ""
\\converter fig ppm "fig2dev -L ppm \$\$i \$\$o" ""
\\converter fig png "fig2dev -L png \$\$i \$\$o" ""
EOF
fi

echo $ac_n "checking for a TIFF -> PS converter""... $ac_c"
echo "$ac_t""(tiff2ps)"
TIFF2PS=
for ac_prog in tiff2ps
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      TIFF2PS="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$TIFF2PS"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$TIFF2PS" && break
fi
done

if test -z "$TIFF2PS" ; then
  TIFF2PS=none
fi

if test "$TIFF2PS" = "tiff2ps"; then
cat >>$outfile <<EOF
\\converter tiff eps "tiff2ps \$\$i > \$\$o" ""
EOF
fi

echo $ac_n "checking for a Tgif -> EPS/PNG/PDF converter""... $ac_c"
echo "$ac_t""(tgif)"
TGIF=
for ac_prog in tgif
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      TGIF="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$TGIF"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$TGIF" && break
fi
done

if test -z "$TGIF" ; then
  TGIF=none
fi

if test "$TGIF" = "tgif"; then
cat >>$outfile <<EOF
\\converter tgif eps "tgif -stdout -print -color -eps \$\$i > \$\$o" ""
\\converter tgif png "tgif -stdout -print -color -xpm \$\$i | xpmtoppm | pnmtopng > \$\$o" ""
\\converter tgif pdf "tgif -stdout -print -color -pdf \$\$i > \$\$o" ""
EOF
fi

echo $ac_n "checking for an EPS -> PDF converter""... $ac_c"
echo "$ac_t""(epstopdf)"
EPSTOPDF=
for ac_prog in epstopdf
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      EPSTOPDF="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$EPSTOPDF"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$EPSTOPDF" && break
fi
done

if test -z "$EPSTOPDF" ; then
  EPSTOPDF=none
fi

if test "$EPSTOPDF" = "epstopdf"; then
cat >>$outfile <<EOF
\\converter eps pdf "epstopdf --outfile=\$\$o \$\$i" ""
EOF
fi

#### Add Grace conversions (xmgrace needs an Xserver, gracebat doesn't.)
echo $ac_n "checking for a Grace -> Image converter""... $ac_c"
echo "$ac_t""(gracebat)"
GRACE=
for ac_prog in gracebat
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog ; ac_word=$2
if test -n "$ac_word"; then
  echo $ac_n "+checking for \"$ac_word\"""... $ac_c"
  IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -x $ac_dir/$ac_word; then
      GRACE="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"

  if test -n "$GRACE"; then
    ac_result=yes
    
  else
    ac_result=no
  fi
  echo "$ac_t""$ac_result"
  test -n "$GRACE" && break
fi
done

if test -z "$GRACE" ; then
  GRACE=none
fi

if test "$GRACE" = "gracebat"; then
cat >>$outfile <<EOF
\\converter agr eps "gracebat -hardcopy -printfile \$\$o -hdevice EPS \$\$i 2>/dev/null" ""
\\converter agr png "gracebat -hardcopy -printfile \$\$o -hdevice PNG \$\$i 2>/dev/null" ""
\\converter agr jpg "gracebat -hardcopy -printfile \$\$o -hdevice JPEG \$\$i 2>/dev/null" ""
\\converter agr ppm "gracebat -hardcopy -printfile \$\$o -hdevice PNM \$\$i 2>/dev/null" ""
EOF
fi

######### Set user tmp as tmp
if [ -n "$TMPDIR" ] ; then
cat >>$outfile <<EOF
\\tempdir_path $TMPDIR
EOF
fi
######### Cyrillic defaults for user settings
##########################
CHNR=koi8
CHNU=koi8-u
echo Add predefined settings for ${USERLANG} locale
case "${USERLANG}" in
    ru_RU.KOI8-R)
cat >>$outfile <<EOF
\\default_language russian
\\default_papersize "a4"
\\screen_font_scalable false
\\screen_font_encoding koi8-r
\\kbmap true
\\kbmap_primary "null.kmap"
\\kbmap_secondary "koi8-r.kmap"
EOF
	;;
    ru_RU.CP1251)
	cat >>$outfile <<EOF
\\default_language russian
\\default_papersize "a4"
\\screen_font_scalable false
\\screen_font_encoding cp1251
EOF
CHNR=cp1251
	;;
    uk_UA.CP1251)
	cat >>$outfile <<EOF
\\default_language ukrainian
\\default_papersize "a4"
\\screen_font_scalable false
\\screen_font_encoding cp1251
EOF
CHNU=cp1251
	;;
    uk_UA.KOI8-U)
	cat >>$outfile <<EOF
\\default_language ukrainian
\\default_papersize "a4"
\\screen_font_scalable false
\\screen_font_encoding koi8-u
\\kbmap true
\\kbmap_primary "null.kmap"
\\kbmap_secondary "koi8-u.kmap"
EOF
CHNU=koi8-u

	;;
    ru_RU.PT154)
	cat >>$outfile <<EOF
\\default_language kazakh
\\default_papersize "a4"
\\screen_font_scalable false
\\screen_font_encoding paratype-cp154
EOF
	;;
    *) :;;	
esac 
cat $(dirname $0)/languages.template | perl -pi -e "s/koi8 +ru/$CHNR  ru/g" |
	perl -pi -e "s/koi8-u +uk/$CHNU  uk/g" >languages

######## X FONTS
# create a fonts.dir file to make X fonts available to LyX
echo "checking for TeX fonts"

fontlist="cmex10 cmmi10 cmr10 cmsy10 eufm10 msam10 msbm10 wasy10"
rm -f xfonts/fonts.dir xfonts/fonts.scale xfonts/tmpfonts

num=0
touch xfonts/tmpfonts
for font in $fontlist ; do
  echo $ac_n "+checking for $font""... $ac_c"
  result=no
  for ext in pfb pfa ttf ; do
    if filepath=`kpsewhich $font.$ext` ; then
      result="yes ($ext)"
      rm -f xfonts/$font.$ext
      ln -s $filepath xfonts 2>/dev/null
      echo "$font.$ext -unknown-$font-medium-r-normal--0-0-0-0-p-0-adobe-fontspecific" >>xfonts/tmpfonts
      num=`expr $num + 1`
      break
    fi
  done
  echo "$ac_t""$result"
done

if test ! $num = 0 ; then
  echo $num >xfonts/fonts.scale
  cat xfonts/tmpfonts >>xfonts/fonts.scale
  cp xfonts/fonts.scale xfonts/fonts.dir
  # create a resource list file for Display Postscript
  (cd xfonts ; rm -f PSres.upr ; makepsres) 2>/dev/null || true
fi
rm -f xfonts/tmpfonts


# Remove superfluous files if we are not writing in the main lib
# directory
for file in $outfile textclass.lst packages.lst \
	    doc/LaTeXConfig.lyx xfonts/fonts.dir ; do
  # we rename the file first, so that we avoid comparing a file with itself
  mv $file $file.new
  if test -r "${srcdir}"/$file && diff $file.new "${srcdir}"/$file >/dev/null 2>/dev/null ;
  then
    echo "removing $file, which is identical to the system global version"
    rm -f $file.new
  else
    mv $file.new $file
  fi
done
if test ! -r xfonts/fonts.dir ; then
    echo "removing font links"
    rm -f xfonts/*.pfb xfonts/fonts.scale
fi

# Final clean-up
if test $lyx_keep_temps = no ; then
rm -f chkconfig.sed chkconfig.vars wrap_chkconfig.* chklayouts.tex \
      missfont.log
fi
