lib/configure.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #
   4 # file configure.py
   5 # This file is part of LyX, the document processor.
   6 # Licence details can be found in the file COPYING.
   7
   8 # \author Bo Peng
   9 # Full author contact details are available in file CREDITS.
  10
  11 import glob, logging, os, re, shutil, subprocess, sys
  12
  13 # set up logging
  14 logging.basicConfig(level = logging.DEBUG,
  15     format = '%(levelname)s: %(message)s', # ignore application name
  16     filename = 'configure.log',
  17     filemode = 'w')
  18 #
  19 # Add a handler to log to console
  20 console = logging.StreamHandler()
  21 console.setLevel(logging.INFO) # the console only print out general information
  22 formatter = logging.Formatter('%(message)s') # only print out the message itself
  23 console.setFormatter(formatter)
  24 logger = logging.getLogger('LyX')
  25 logger.addHandler(console)
  26
  27 def writeToFile(filename, lines, append = False):
  28     " utility function: write or append lines to filename "
  29     if append:
  30         file = open(filename, 'a')
  31     else:
  32         file = open(filename, 'w')
  33     file.write(lines)
  34     file.close()
  35
  36
  37 def addToRC(lines):
  38     ''' utility function: shortcut for appending lines to outfile
  39         add newline at the end of lines.
  40     '''
  41     if lines.strip() != '':
  42         writeToFile(outfile, lines + '\n', append = True)
  43         logger.debug('Add to RC:\n' + lines + '\n\n')
  44
  45
  46 def removeFiles(filenames):
  47     '''utility function: 'rm -f'
  48         ignore errors when file does not exist, or is a directory.
  49     '''
  50     for file in filenames:
  51         try:
  52             os.remove(file)
  53             logger.debug('Removing file %s' % file)
  54         except:
  55             logger.debug('Failed to remove file %s' % file)
  56             pass
  57
  58
  59 def cmdOutput(cmd):
  60     '''utility function: run a command and get its output as a string
  61         cmd: command to run
  62     '''
  63     if os.name == 'nt':
  64         b = False
  65         cmd = 'cmd /d /c ' + cmd
  66     else:
  67         b = True
  68     pipe = subprocess.Popen(cmd, shell=b, close_fds=b, stdin=subprocess.PIPE, \
  69                             stdout=subprocess.PIPE, universal_newlines=True)
  70     pipe.stdin.close()
  71     output = pipe.stdout.read()
  72     pipe.stdout.close()
  73     return output.strip()
  74
  75
  76 def setEnviron():
  77     ''' I do not really know why this is useful, but we might as well keep it.
  78         NLS nuisances.
  79         Only set these to C if already set.  These must not be set unconditionally
  80         because not all systems understand e.g. LANG=C (notably SCO).
  81         Fixing LC_MESSAGES prevents Solaris sh from translating var values in set!
  82         Non-C LC_CTYPE values break the ctype check.
  83     '''
  84     os.environ['LANG'] = os.getenv('LANG', 'C')
  85     os.environ['LC'] = os.getenv('LC_ALL', 'C')
  86     os.environ['LC_MESSAGE'] = os.getenv('LC_MESSAGE', 'C')
  87     os.environ['LC_CTYPE'] = os.getenv('LC_CTYPE', 'C')
  88
  89
  90 def createDirectories():
  91     ''' Create the build directories if necessary '''
  92     for dir in ['bind', 'clipart', 'doc', 'examples', 'images', 'kbd', \
  93         'layouts', 'scripts', 'templates', 'ui' ]:
  94         if not os.path.isdir( dir ):
  95             try:
  96                 os.mkdir( dir)
  97                 logger.debug('Create directory %s.' % dir)
  98             except:
  99                 logger.error('Failed to create directory %s.' % dir)
 100                 sys.exit(1)
 101
 102
 103 def checkTeXPaths():
 104     ''' Determine the path-style needed by the TeX engine on Win32 (Cygwin) '''
 105     windows_style_tex_paths = ''
 106     if LATEX == '':
 107         return windows_style_tex_paths
 108     if os.name == 'nt' or sys.platform == 'cygwin':
 109         from tempfile import mkstemp
 110         fd, tmpfname = mkstemp(suffix='.ltx')
 111         if os.name == 'nt':
 112             from locale import getdefaultlocale
 113             from ctypes import windll, create_unicode_buffer
 114             GetShortPathName = windll.kernel32.GetShortPathNameW
 115             language, encoding = getdefaultlocale()
 116             if encoding == None:
 117                 encoding = 'latin1'
 118             longname = unicode(tmpfname, encoding)
 119             shortlen = GetShortPathName(longname, 0, 0)
 120             shortname = create_unicode_buffer(shortlen)
 121             if GetShortPathName(longname, shortname, shortlen):
 122                 inpname = shortname.value.replace('\\', '/')
 123             else:
 124                 inpname = tmpfname.replace('\\', '/')
 125         else:
 126             inpname = cmdOutput('cygpath -m ' + tmpfname)
 127         logname = os.path.basename(inpname.replace('.ltx', '.log'))
 128         inpname = inpname.replace('~', '\\string~')
 129         os.write(fd, r'\relax')
 130         os.close(fd)
 131         latex_out = cmdOutput(r'latex "\nonstopmode\input{%s}\makeatletter\@@end"' % inpname)
 132         if 'Error' in latex_out:
 133             latex_out = cmdOutput(r'latex "\nonstopmode\input{\"%s\"}\makeatletter\@@end"' % inpname)
 134         if 'Error' in latex_out:
 135             logger.warning("configure: TeX engine needs posix-style paths in latex files")
 136             windows_style_tex_paths = 'false'
 137         else:
 138             logger.info("configure: TeX engine needs windows-style paths in latex files")
 139             windows_style_tex_paths = 'true'
 140         removeFiles([tmpfname, logname, 'texput.log'])
 141     return windows_style_tex_paths
 142
 143
 144 ## Searching some useful programs
 145 def checkProg(description, progs, rc_entry = [], path = [], not_found = ''):
 146     '''
 147         This function will search a program in $PATH plus given path
 148         If found, return directory and program name (not the options).
 149
 150         description: description of the program
 151
 152         progs: check programs, for each prog, the first word is used
 153             for searching but the whole string is used to replace
 154             %% for a rc_entry. So, feel free to add '$$i' etc for programs.
 155
 156         path: additional pathes
 157
 158         rc_entry: entry to outfile, can be
 159             1. emtpy: no rc entry will be added
 160             2. one pattern: %% will be replaced by the first found program,
 161                 or '' if no program is found.
 162             3. several patterns for each prog and not_found. This is used
 163                 when different programs have different usages. If you do not
 164                 want not_found entry to be added to the RC file, you can specify
 165                 an entry for each prog and use '' for the not_found entry.
 166
 167         not_found: the value that should be used instead of '' if no program
 168             was found
 169
 170     '''
 171     # one rc entry for each progs plus not_found entry
 172     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 173         logger.error("rc entry should have one item or item for each prog and not_found.")
 174         sys.exit(2)
 175     logger.info('checking for ' + description + '...')
 176     ## print '(' + ','.join(progs) + ')',
 177     global java, perl
 178     for idx in range(len(progs)):
 179         # ac_prog may have options, ac_word is the command name
 180         ac_prog = progs[idx]
 181         ac_word = ac_prog.split(' ')[0]
 182         if (ac_word.endswith('.class') or ac_word.endswith('.jar')) and java == '':
 183             continue
 184         if ac_word.endswith('.pl') and perl == '':
 185             continue
 186         msg = '+checking for "' + ac_word + '"... '
 187         path = os.environ["PATH"].split(os.pathsep) + path
 188         extlist = ['']
 189         if "PATHEXT" in os.environ:
 190             extlist = extlist + os.environ["PATHEXT"].split(os.pathsep)
 191         for ac_dir in path:
 192             for ext in extlist:
 193                 if os.path.isfile( os.path.join(ac_dir, ac_word + ext) ):
 194                     logger.info(msg + ' yes')
 195                     # deal with java and perl
 196                     if ac_word.endswith('.class'):
 197                         ac_prog = ac_prog.replace(ac_word, r'%s \"%s\"' % (java, os.path.join(ac_dir, ac_word[:-6])))
 198                     elif ac_word.endswith('.jar'):
 199                         ac_prog = ac_prog.replace(ac_word, r'%s -jar \"%s\"' % (java, os.path.join(ac_dir, ac_word)))
 200                     elif ac_word.endswith('.pl'):
 201                         ac_prog = ac_prog.replace(ac_word, r'%s -w \"%s\"' % (perl, os.path.join(ac_dir, ac_word)))
 202                     # write rc entries for this command
 203                     if len(rc_entry) == 1:
 204                         addToRC(rc_entry[0].replace('%%', ac_prog))
 205                     elif len(rc_entry) > 1:
 206                         addToRC(rc_entry[idx].replace('%%', ac_prog))
 207                     return [ac_dir, ac_word]
 208         # if not successful
 209         logger.info(msg + ' no')
 210     # write rc entries for 'not found'
 211     if len(rc_entry) > 0:  # the last one.
 212         addToRC(rc_entry[-1].replace('%%', not_found))
 213     return ['', not_found]
 214
 215
 216 def checkProgAlternatives(description, progs, rc_entry = [], alt_rc_entry = [], path = [], not_found = ''):
 217     '''
 218         The same as checkProg, but additionally, all found programs will be added
 219         as alt_rc_entries
 220     '''
 221     # one rc entry for each progs plus not_found entry
 222     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 223         logger.error("rc entry should have one item or item for each prog and not_found.")
 224         sys.exit(2)
 225     logger.info('checking for ' + description + '...')
 226     ## print '(' + ','.join(progs) + ')',
 227     found_prime = False
 228     real_ac_dir = ''
 229     real_ac_word = not_found
 230     global java, perl
 231     for idx in range(len(progs)):
 232         # ac_prog may have options, ac_word is the command name
 233         ac_prog = progs[idx]
 234         ac_word = ac_prog.split(' ')[0]
 235         if (ac_word.endswith('.class') or ac_word.endswith('.jar')) and java == '':
 236             continue
 237         if ac_word.endswith('.pl') and perl == '':
 238             continue
 239         msg = '+checking for "' + ac_word + '"... '
 240         path = os.environ["PATH"].split(os.pathsep) + path
 241         extlist = ['']
 242         if "PATHEXT" in os.environ:
 243             extlist = extlist + os.environ["PATHEXT"].split(os.pathsep)
 244         found_alt = False
 245         for ac_dir in path:
 246             for ext in extlist:
 247                 if os.path.isfile( os.path.join(ac_dir, ac_word + ext) ):
 248                     logger.info(msg + ' yes')
 249                     pr = re.compile(r'(\\\S+)(.*)$')
 250                     m = None
 251                     # deal with java and perl
 252                     if ac_word.endswith('.class'):
 253                         ac_prog = ac_prog.replace(ac_word, r'%s \"%s\"' % (java, os.path.join(ac_dir, ac_word[:-6])))
 254                     elif ac_word.endswith('.jar'):
 255                         ac_prog = ac_prog.replace(ac_word, r'%s -jar \"%s\"' % (java, os.path.join(ac_dir, ac_word)))
 256                     elif ac_word.endswith('.pl'):
 257                         ac_prog = ac_prog.replace(ac_word, r'%s -w \"%s\"' % (perl, os.path.join(ac_dir, ac_word)))
 258                     # write rc entries for this command
 259                     if found_prime == False:
 260                         if len(rc_entry) == 1:
 261                             addToRC(rc_entry[0].replace('%%', ac_prog))
 262                         elif len(rc_entry) > 1:
 263                             addToRC(rc_entry[idx].replace('%%', ac_prog))
 264                         real_ac_dir = ac_dir
 265                         real_ac_word = ac_word
 266                         found_prime = True
 267                     if len(alt_rc_entry) == 1:
 268                         alt_rc = alt_rc_entry[0]
 269                         if alt_rc == "":
 270                             # if no explicit alt_rc is given, construct one
 271                             m = pr.match(rc_entry[0])
 272                             if m:
 273                                 alt_rc = m.group(1) + "_alternatives" + m.group(2)
 274                         addToRC(alt_rc.replace('%%', ac_prog))
 275                     elif len(alt_rc_entry) > 1:
 276                         alt_rc = alt_rc_entry[idx]
 277                         if alt_rc == "":
 278                             # if no explicit alt_rc is given, construct one
 279                             m = pr.match(rc_entry[idx])
 280                             if m:
 281                                 alt_rc = m.group(1) + "_alternatives" + m.group(2)
 282                         addToRC(alt_rc.replace('%%', ac_prog))
 283                     found_alt = True
 284                     break
 285             if found_alt:
 286                 break
 287         if found_alt == False:
 288             # if not successful
 289             logger.info(msg + ' no')
 290     if found_prime:
 291         return [real_ac_dir, real_ac_word]
 292     # write rc entries for 'not found'
 293     if len(rc_entry) > 0:  # the last one.
 294         addToRC(rc_entry[-1].replace('%%', not_found))
 295     return ['', not_found]
 296
 297
 298 def addAlternatives(rcs, alt_type):
 299     '''
 300         Returns a \\prog_alternatives string to be used as an alternative
 301         rc entry.  alt_type can be a string or a list of strings.
 302     '''
 303     r = re.compile(r'\\Format (\S+).*$')
 304     m = None
 305     alt = ''
 306     alt_token = '\\%s_alternatives '
 307     if isinstance(alt_type, str):
 308         alt_tokens = [alt_token % alt_type]
 309     else:
 310         alt_tokens = map(lambda s: alt_token % s, alt_type)
 311     for idxx in range(len(rcs)):
 312         if len(rcs) == 1:
 313             m = r.match(rcs[0])
 314             if m:
 315                 alt = '\n'.join([s + m.group(1) + ' "%%"' for s in alt_tokens])
 316         elif len(rcs) > 1:
 317             m = r.match(rcs[idxx])
 318             if m:
 319                 if idxx > 0:
 320                     alt += '\n'
 321                 alt += '\n'.join([s + m.group(1) + ' "%%"' for s in alt_tokens])
 322     return alt
 323
 324
 325 def listAlternatives(progs, alt_type, rc_entry = []):
 326     '''
 327         Returns a list of \\prog_alternatives strings to be used as alternative
 328         rc entries.  alt_type can be a string or a list of strings.
 329     '''
 330     if len(rc_entry) > 1 and len(rc_entry) != len(progs) + 1:
 331         logger.error("rc entry should have one item or item for each prog and not_found.")
 332         sys.exit(2)
 333     alt_rc_entry = []
 334     for idx in range(len(progs)):
 335         if len(rc_entry) == 1:
 336             rcs = rc_entry[0].split('\n')
 337             alt = addAlternatives(rcs, alt_type)
 338             alt_rc_entry.insert(0, alt)
 339         elif len(rc_entry) > 1:
 340             rcs = rc_entry[idx].split('\n')
 341             alt = addAlternatives(rcs, alt_type)
 342             alt_rc_entry.insert(idx, alt)
 343     return alt_rc_entry
 344
 345
 346 def checkViewer(description, progs, rc_entry = [], path = []):
 347     ''' The same as checkProgAlternatives, but for viewers '''
 348     alt_rc_entry = listAlternatives(progs, 'viewer', rc_entry)
 349     return checkProgAlternatives(description, progs, rc_entry, alt_rc_entry, path, not_found = 'auto')
 350
 351
 352 def checkEditor(description, progs, rc_entry = [], path = []):
 353     ''' The same as checkProgAlternatives, but for editors '''
 354     alt_rc_entry = listAlternatives(progs, 'editor', rc_entry)
 355     return checkProgAlternatives(description, progs, rc_entry, alt_rc_entry, path, not_found = 'auto')
 356
 357
 358 def checkViewerNoRC(description, progs, rc_entry = [], path = []):
 359     ''' The same as checkViewer, but do not add rc entry '''
 360     alt_rc_entry = listAlternatives(progs, 'viewer', rc_entry)
 361     rc_entry = []
 362     return checkProgAlternatives(description, progs, rc_entry, alt_rc_entry, path, not_found = 'auto')
 363
 364
 365 def checkEditorNoRC(description, progs, rc_entry = [], path = []):
 366     ''' The same as checkViewer, but do not add rc entry '''
 367     alt_rc_entry = listAlternatives(progs, 'editor', rc_entry)
 368     rc_entry = []
 369     return checkProgAlternatives(description, progs, rc_entry, alt_rc_entry, path, not_found = 'auto')
 370
 371
 372 def checkViewerEditor(description, progs, rc_entry = [], path = []):
 373     ''' The same as checkProgAlternatives, but for viewers and editors '''
 374     alt_rc_entry = listAlternatives(progs, ['editor', 'viewer'], rc_entry)
 375     return checkProgAlternatives(description, progs, rc_entry, alt_rc_entry, path, not_found = 'auto')
 376
 377
 378 def checkDTLtools():
 379     ''' Check whether DTL tools are available (Windows only) '''
 380     # Find programs! Returned path is not used now
 381     if ((os.name == 'nt' or sys.platform == 'cygwin') and
 382             checkProg('DVI to DTL converter', ['dv2dt']) != ['', ''] and
 383             checkProg('DTL to DVI converter', ['dt2dv']) != ['', '']):
 384         dtl_tools = True
 385     else:
 386         dtl_tools = False
 387     return dtl_tools
 388
 389
 390 def checkLatex(dtl_tools):
 391     ''' Check latex, return lyx_check_config '''
 392     path, LATEX = checkProg('a Latex2e program', ['latex $$i', 'latex2e $$i'])
 393     path, PPLATEX = checkProg('a DVI postprocessing program', ['pplatex $$i'])
 394     #-----------------------------------------------------------------
 395     path, PLATEX = checkProg('pLaTeX, the Japanese LaTeX', ['platex $$i'])
 396     if PLATEX != '':
 397         # check if PLATEX is pLaTeX2e
 398         writeToFile('chklatex.ltx', r'\nonstopmode\makeatletter\@@end')
 399         # run platex on chklatex.ltx and check result
 400         if cmdOutput(PLATEX + ' chklatex.ltx').find('pLaTeX2e') != -1:
 401             # We have the Japanese pLaTeX2e
 402             addToRC(r'\converter platex     dvi        "%s -kanji=$$E $$i"      "latex=platex"' % PLATEX)
 403         else:
 404             PLATEX = ''
 405             removeFiles(['chklatex.ltx', 'chklatex.log'])
 406     #-----------------------------------------------------------------
 407     # use LATEX to convert from latex to dvi if PPLATEX is not available
 408     if PPLATEX == '':
 409         PPLATEX = LATEX
 410     if dtl_tools:
 411         # Windows only: DraftDVI
 412         addToRC(r'''\converter latex      dvi2       "%s"       "latex"
 413 \converter dvi2       dvi        "python -tt $$s/scripts/clean_dvi.py $$i $$o"  ""''' % PPLATEX)
 414     else:
 415         addToRC(r'\converter latex      dvi        "%s" "latex"' % PPLATEX)
 416     # no latex
 417     if LATEX != '':
 418         # Check if latex is usable
 419         writeToFile('chklatex.ltx', r'''
 420 \nonstopmode
 421 \ifx\undefined\documentclass\else
 422   \message{ThisIsLaTeX2e}
 423 \fi
 424 \makeatletter
 425 \@@end
 426 ''')
 427         # run latex on chklatex.ltx and check result
 428         if cmdOutput(LATEX + ' chklatex.ltx').find('ThisIsLaTeX2e') != -1:
 429             # valid latex2e
 430             return LATEX
 431         else:
 432             logger.warning("Latex not usable (not LaTeX2e) ")
 433         # remove temporary files
 434         removeFiles(['chklatex.ltx', 'chklatex.log'])
 435     return ''
 436
 437
 438 def checkLuatex():
 439     ''' Check if luatex is there and usable '''
 440     path, LUATEX = checkProg('LuaTeX', ['lualatex $$i'])
 441     path, DVILUATEX = checkProg('LuaTeX (DVI)', ['dvilualatex $$i'])
 442     if LUATEX != '':
 443     # luatex binary is there
 444         msg = "checking if LuaTeX is usable ..."
 445         # Check if luatex is usable
 446         writeToFile('luatest.tex', r'''
 447 \nonstopmode
 448 \documentclass{minimal}
 449 \usepackage{fontspec}
 450 \begin{document}
 451 .
 452 \end{document}
 453 ''')
 454         # run lualatex on luatest.tex and check result
 455         luatest = cmdOutput(LUATEX + ' luatest.tex')
 456         if luatest.find('XeTeX is required to compile this document') != -1:
 457             # fontspec/luatex too old! We do not support this version.
 458             logger.info(msg + ' no (probably not recent enough)')
 459         elif luatest.find('! LaTeX Error: File `fontspec.sty\' not found') != -1:
 460             # fontspec missing
 461             logger.info(msg + ' no (missing fontspec)')
 462         else:
 463             # working luatex
 464             logger.info(msg + ' yes')
 465             addToRC(r'\converter luatex      pdf5       "%s"    "latex=lualatex"' % LUATEX)
 466             if DVILUATEX != '':
 467                 addToRC(r'\converter luatex      dvi3        "%s"       "latex=dvilualatex"' % DVILUATEX)
 468         # remove temporary files
 469         removeFiles(['luatest.tex', 'luatest.log', 'luatest.aux', 'luatest.pdf'])
 470
 471
 472 def checkModule(module):
 473     ''' Check for a Python module, return the status '''
 474     msg = 'checking for "' + module + ' module"... '
 475     try:
 476       __import__(module)
 477       logger.info(msg + ' yes')
 478       return True
 479     except ImportError:
 480       logger.info(msg + ' no')
 481       return False
 482
 483
 484 def checkFormatEntries(dtl_tools):
 485     ''' Check all formats (\Format entries) '''
 486     checkViewerEditor('a Tgif viewer and editor', ['tgif'],
 487         rc_entry = [r'\Format tgif      "obj, tgo" Tgif                 "" "%%" "%%"    "vector"        "application/x-tgif"'])
 488     #
 489     checkViewerEditor('a FIG viewer and editor', ['xfig', 'jfig3-itext.jar', 'jfig3.jar'],
 490         rc_entry = [r'\Format fig        fig     FIG                    "" "%%" "%%"    "vector"        "application/x-xfig"'])
 491     #
 492     checkViewerEditor('a Dia viewer and editor', ['dia'],
 493         rc_entry = [r'\Format dia        dia     DIA                    "" "%%" "%%"    "vector,zipped=native", "application/x-dia-diagram"'])
 494     #
 495     checkViewerEditor('an OpenOffice drawing viewer and editor', ['libreoffice', 'lodraw', 'ooffice', 'oodraw', 'soffice'],
 496         rc_entry = [r'\Format odg        "odg, sxd" "OpenOffice drawing"   "" "%%"      "%%"    "vector,zipped=native"  "application/vnd.oasis.opendocument.graphics"'])
 497     #
 498     checkViewerEditor('a Grace viewer and editor', ['xmgrace'],
 499         rc_entry = [r'\Format agr        agr     Grace                  "" "%%" "%%"    "vector"        ""'])
 500     #
 501     checkViewerEditor('a FEN viewer and editor', ['xboard -lpf $$i -mode EditPosition'],
 502         rc_entry = [r'\Format fen        fen     FEN                    "" "%%" "%%"    ""      ""'])
 503     #
 504     checkViewerEditor('a SVG viewer and editor', ['inkscape'],
 505         rc_entry = [r'\Format svg        svg     SVG                    "" "%%" "%%"    "vector"        "image/svg+xml"'])
 506     #
 507     imageformats = r'''\Format bmp        bmp     BMP                    "" "%s"        "%s"    ""      "image/x-bmp"
 508 \Format gif        gif     GIF                    "" "%s"       "%s"    ""      "image/gif"
 509 \Format jpg       "jpg, jpeg" JPEG                "" "%s"       "%s"    ""      "image/jpeg"
 510 \Format pbm        pbm     PBM                    "" "%s"       "%s"    ""      "image/x-portable-bitmap"
 511 \Format pgm        pgm     PGM                    "" "%s"       "%s"    ""      "image/x-portable-graymap"
 512 \Format png        png     PNG                    "" "%s"       "%s"    ""      "image/x-png"
 513 \Format ppm        ppm     PPM                    "" "%s"       "%s"    ""      "image/x-portable-pixmap"
 514 \Format tiff       tif     TIFF                   "" "%s"       "%s"    ""      "image/tiff"
 515 \Format xbm        xbm     XBM                    "" "%s"       "%s"    ""      "image/x-xbitmap"
 516 \Format xpm        xpm     XPM                    "" "%s"       "%s"    ""      "image/x-xpixmap"'''
 517     path, iv = checkViewerNoRC('a raster image viewer', ['xv', 'kview', 'gimp-remote', 'gimp'], rc_entry = [imageformats])
 518     path, ie = checkEditorNoRC('a raster image editor', ['gimp-remote', 'gimp'], rc_entry = [imageformats])
 519     addToRC(imageformats % \
 520         (iv, ie, iv, ie, iv, ie, iv, ie, iv, ie, iv, ie, iv, ie, iv, ie, iv, ie, iv, ie) )
 521     #
 522     checkViewerEditor('a text editor', ['xemacs', 'gvim', 'kedit', 'kwrite', 'kate', \
 523         'nedit', 'gedit', 'notepad'],
 524         rc_entry = [r'''\Format asciichess asc    "Plain text (chess output)"  "" ""    "%%"    ""      ""
 525 \Format asciiimage asc    "Plain text (image)"         "" ""    "%%"    ""      ""
 526 \Format asciixfig  asc    "Plain text (Xfig output)"   "" ""    "%%"    ""      ""
 527 \Format dateout    tmp    "date (output)"         "" "" "%%"    ""      ""
 528 \Format docbook    sgml    DocBook                B  "" "%%"    "document,menu=export"  ""
 529 \Format docbook-xml xml   "DocBook (XML)"         "" "" "%%"    "document,menu=export"  "application/docbook+xml"
 530 \Format dot        dot    "Graphviz Dot"          "" "" "%%"    "vector"        "text/vnd.graphviz"
 531 \Format dviluatex  tex    "LaTeX (dviluatex)"     "" "" "%%"    "document,menu=export"  ""
 532 \Format platex     tex    "LaTeX (pLaTeX)"        "" "" "%%"    "document,menu=export"  ""
 533 \Format literate   nw      NoWeb                  N  "" "%%"    "document,menu=export"  ""
 534 \Format sweave     Rnw    "Sweave"                S  "" "%%"    "document,menu=export"  ""
 535 \Format r          R      "R/S code"              "" "" "%%"    "document,menu=export"  ""
 536 \Format knitr      Rnw    "Rnw (knitr)"           "" "" "%%"    "document,menu=export"  ""
 537 \Format lilypond   ly     "LilyPond music"        "" "" "%%"    "vector"        "text/x-lilypond"
 538 \Format lilypond-book    lytex "LilyPond book (LaTeX)"   "" ""  "%%"    "document,menu=export"  ""
 539 \Format latex      tex    "LaTeX (plain)"         L  "" "%%"    "document,menu=export"  "text/x-tex"
 540 \Format luatex     tex    "LaTeX (LuaTeX)"        "" "" "%%"    "document,menu=export"  ""
 541 \Format pdflatex   tex    "LaTeX (pdflatex)"      "" "" "%%"    "document,menu=export"  ""
 542 \Format xetex      tex    "LaTeX (XeTeX)"         "" "" "%%"    "document,menu=export"  ""
 543 \Format text       txt    "Plain text"            a  "" "%%"    "document,menu=export"  "text/plain"
 544 \Format text2      txt    "Plain text (pstotext)" "" "" "%%"    "document"      ""
 545 \Format text3      txt    "Plain text (ps2ascii)" "" "" "%%"    "document"      ""
 546 \Format text4      txt    "Plain text (catdvi)"   "" "" "%%"    "document"      ""
 547 \Format textparagraph txt "Plain Text, Join Lines" "" ""        "%%"    "document"      ""''' ])
 548    #Spreadsheets using ssconvert from gnumeric
 549     checkViewer('gnumeric spreadsheet software', ['gnumeric'],
 550       rc_entry = [r'''\Format gnumeric gnumeric "Gnumeric spreadsheet" "" ""    "%%"   "document"       "application/x-gnumeric"
 551 \Format excel      xls    "Excel spreadsheet"      "" "" "%%"    "document"     "application/vnd.ms-excel"
 552 \Format oocalc     ods    "OpenOffice spreadsheet" "" "" "%%"    "document"     "application/vnd.oasis.opendocument.spreadsheet"'''])
 553  #
 554     checkViewer('an HTML previewer', ['firefox', 'mozilla file://$$p$$i', 'netscape'],
 555         rc_entry = [r'\Format xhtml      xhtml   "LyXHTML"              y "%%" ""    "document,menu=export"     "application/xhtml+xml"'])
 556  #
 557     checkEditor('a BibTeX editor', ['jabref', 'JabRef', \
 558         'pybliographic', 'bibdesk', 'gbib', 'kbib', \
 559         'kbibtex', 'sixpack', 'bibedit', 'tkbibtex' \
 560         'xemacs', 'gvim', 'kedit', 'kwrite', 'kate', \
 561         'nedit', 'gedit', 'notepad'],
 562         rc_entry = [r'''\Format bibtex bib    "BibTeX"         "" ""    "%%"    ""      "text/x-bibtex"''' ])
 563     #
 564     #checkProg('a Postscript interpreter', ['gs'],
 565     #  rc_entry = [ r'\ps_command "%%"' ])
 566     checkViewer('a Postscript previewer', ['kghostview', 'okular', 'evince', 'gv', 'ghostview -swap'],
 567         rc_entry = [r'''\Format eps        eps     EPS                    "" "%%"       ""      "vector"        "image/x-eps"
 568 \Format eps2       eps    "EPS (uncropped)"       "" "%%"       ""      "vector"        ""
 569 \Format ps         ps      Postscript             t  "%%"       ""      "document,vector,menu=export"   "application/postscript"'''])
 570     # for xdg-open issues look here: http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg151818.html
 571     checkViewer('a PDF previewer', ['kpdf', 'okular', 'evince', 'kghostview', 'xpdf', 'acrobat', 'acroread', \
 572                     'gv', 'ghostview'],
 573         rc_entry = [r'''\Format pdf        pdf    "PDF (ps2pdf)"          P  "%%"       ""      "document,vector,menu=export"   "application/pdf"
 574 \Format pdf2       pdf    "PDF (pdflatex)"        F  "%%"       ""      "document,vector,menu=export"   ""
 575 \Format pdf3       pdf    "PDF (dvipdfm)"         m  "%%"       ""      "document,vector,menu=export"   ""
 576 \Format pdf4       pdf    "PDF (XeTeX)"           X  "%%"       ""      "document,vector,menu=export"   ""
 577 \Format pdf5       pdf    "PDF (LuaTeX)"          u  "%%"       ""      "document,vector,menu=export"   ""'''])
 578     #
 579     checkViewer('a DVI previewer', ['xdvi', 'kdvi', 'okular', 'yap', 'dviout -Set=!m'],
 580         rc_entry = [r'''\Format dvi        dvi     DVI                    D  "%%"       ""      "document,vector,menu=export"   "application/x-dvi"
 581 \Format dvi3       dvi     "DVI (LuaTeX)"          V  "%%"      ""      "document,vector,menu=export"   ""'''])
 582     if dtl_tools:
 583         # Windows only: DraftDVI
 584         addToRC(r'\Format dvi2       dvi     DraftDVI               ""  ""      ""      "vector"        ""')
 585     #
 586     checkViewer('an HTML previewer', ['firefox', 'mozilla file://$$p$$i', 'netscape'],
 587         rc_entry = [r'\Format html      "html, htm" HTML                H  "%%" ""      "document,menu=export"  "text/html"'])
 588     #
 589     checkViewerEditor('Noteedit', ['noteedit'],
 590         rc_entry = [r'\Format noteedit   not     Noteedit               "" "%%" "%%"    "vector"        ""'])
 591     #
 592     checkViewerEditor('an OpenDocument/OpenOffice viewer', ['libreoffice', 'lwriter', 'swriter', 'oowriter', 'abiword'],
 593         rc_entry = [r'''\Format odt        odt     OpenDocument           "" "%%"       "%%"    "document,vector,menu=export"   "application/vnd.oasis.opendocument.text"
 594 \Format sxw        sxw    "OpenOffice.Org (sxw)"  "" "" ""      "document,vector"       "application/vnd.sun.xml.writer"'''])
 595     #
 596     checkViewerEditor('a Rich Text and Word viewer', ['libreoffice', 'lwriter', 'swriter', 'oowriter', 'abiword'],
 597         rc_entry = [r'''\Format rtf        rtf    "Rich Text Format"      "" "%%"       "%%"    "document,vector,menu=export"   "application/rtf"
 598 \Format word       doc    "MS Word"               W  "%%"       "%%"    "document,vector,menu=export"   "application/msword"'''])
 599     #
 600     # entries that do not need checkProg
 601     addToRC(r'''\Format date       ""     "date command"          "" "" ""      ""      ""
 602 \Format csv        csv    "Table (CSV)"           "" "" ""      "document"      "text/csv"
 603 \Format fax        ""      Fax                    "" "" ""      "document"      ""
 604 \Format lyx        lyx     LyX                    "" "" ""      ""      "application/x-lyx"
 605 \Format lyx13x     13.lyx "LyX 1.3.x"             "" "" ""      "document"      ""
 606 \Format lyx14x     14.lyx "LyX 1.4.x"             "" "" ""      "document"      ""
 607 \Format lyx15x     15.lyx "LyX 1.5.x"             "" "" ""      "document"      ""
 608 \Format lyx16x     16.lyx "LyX 1.6.x"             "" "" ""      "document,menu=export"  ""
 609 \Format lyx20x     20.lyx "LyX 2.0.x"             "" "" ""      "document,menu=export"  ""
 610 \Format clyx       cjklyx "CJK LyX 1.4.x (big5)"  "" "" ""      "document"      ""
 611 \Format jlyx       cjklyx "CJK LyX 1.4.x (euc-jp)" "" ""        ""      "document"      ""
 612 \Format klyx       cjklyx "CJK LyX 1.4.x (euc-kr)" "" ""        ""      "document"      ""
 613 \Format lyxpreview lyxpreview "LyX Preview"       "" "" ""      ""      ""
 614 \Format pdftex     pdftex_t PDFTEX                "" "" ""      ""      ""
 615 \Format program    ""      Program                "" "" ""      ""      ""
 616 \Format pstex      pstex_t PSTEX                  "" "" ""      ""      ""
 617 \Format wmf        wmf    "Windows Metafile"      "" "" ""      "vector"        "image/x-wmf"
 618 \Format emf        emf    "Enhanced Metafile"     "" "" ""      "vector"        "image/x-emf"
 619 \Format wordhtml  "html, htm" "HTML (MS Word)"    "" "" ""      "document"      ""
 620 ''')
 621
 622
 623 def checkConverterEntries():
 624     ''' Check all converters (\converter entries) '''
 625     checkProg('the pdflatex program', ['pdflatex $$i'],
 626         rc_entry = [ r'\converter pdflatex   pdf2       "%%"    "latex=pdflatex"' ])
 627
 628     checkProg('XeTeX', ['xelatex $$i'],
 629         rc_entry = [ r'\converter xetex      pdf4       "%%"    "latex=xelatex"' ])
 630
 631     checkLuatex()
 632
 633     # Look for tex2lyx in this order (see bugs #3308 and #6986):
 634     #   1)  If we're running LyX in-place then tex2lyx will be found
 635     #       in ../src/tex2lyx with respect to the srcdir.
 636     #   2)  If LyX was configured with a version suffix then tex2lyx
 637     #       will also have this version suffix.
 638     #   3)  Otherwise always use tex2lyx.
 639     in_place = os.path.join(srcdir, '..', 'src', 'tex2lyx', 'tex2lyx')
 640     in_place = os.path.abspath(in_place)
 641
 642     path, t2l = checkProg('a LaTeX/Noweb -> LyX converter', [in_place, 'tex2lyx' + version_suffix, 'tex2lyx'],
 643         rc_entry = [r'''\converter latex      lyx        "%% -f $$i $$o"        ""
 644 \converter literate   lyx        "%% -n -f $$i $$o"     ""'''], not_found = 'tex2lyx')
 645     if path == '':
 646         logger.warning("Failed to find tex2lyx on your system.")
 647
 648     #
 649     checkProg('a Noweb -> LaTeX converter', ['noweave -delay -index $$i > $$o'],
 650         rc_entry = [r'''\converter literate   latex      "%%"   ""
 651 \converter literate   pdflatex      "%%"        ""'''])
 652     #
 653     checkProg('a Sweave -> LaTeX converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxsweave.R $$p$$i $$p$$o $$e $$r'],
 654         rc_entry = [r'''\converter sweave   latex      "%%"     ""
 655 \converter sweave   pdflatex   "%%"     ""
 656 \converter sweave   xetex      "%%"     ""
 657 \converter sweave   luatex     "%%"     ""'''])
 658     #
 659     checkProg('a knitr -> LaTeX converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxknitr.R $$p$$i $$p$$o $$e $$r'],
 660         rc_entry = [r'''\converter knitr   latex      "%%"      ""
 661 \converter knitr   pdflatex   "%%"      ""
 662 \converter knitr   xetex      "%%"      ""
 663 \converter knitr   luatex     "%%"      ""'''])
 664     #
 665     checkProg('a Sweave -> R/S code converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxstangle.R $$i $$e $$r'],
 666         rc_entry = [ r'\converter sweave      r      "%%"    ""' ])
 667     #
 668     checkProg('a knitr -> R/S code converter', ['Rscript --verbose --no-save --no-restore $$s/scripts/lyxknitr.R $$p$$i $$p$$o $$e $$r tangle'],
 669         rc_entry = [ r'\converter knitr      r      "%%"    ""' ])
 670     #
 671     checkProg('an HTML -> LaTeX converter', ['html2latex $$i', 'gnuhtml2latex $$i',
 672         'htmltolatex -input $$i -output $$o', 'htmltolatex.jar -input $$i -output $$o'],
 673         rc_entry = [ r'\converter html       latex      "%%"    ""' ])
 674     #
 675     checkProg('an MS Word -> LaTeX converter', ['wvCleanLatex $$i $$o'],
 676         rc_entry = [ r'\converter word       latex      "%%"    ""' ])
 677
 678     # eLyXer: search as an executable (elyxer.py, elyxer)
 679     path, elyxer = checkProg('a LyX -> HTML converter',
 680         ['elyxer.py --directory $$r $$i $$o', 'elyxer --directory $$r $$i $$o'],
 681         rc_entry = [ r'\converter lyx      html       "%%"      ""' ])
 682     path, elyxer = checkProg('a LyX -> HTML (MS Word) converter',
 683         ['elyxer.py --html --directory $$r $$i $$o', 'elyxer --html --directory $$r $$i $$o'],
 684         rc_entry = [ r'\converter lyx      wordhtml       "%%"  ""' ])
 685     if elyxer.find('elyxer') >= 0:
 686       addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py -e html,png,jpg,jpeg,css $$i $$o"''')
 687       addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py -e html,png,jpg,jpeg,css $$i $$o"''')
 688     else:
 689       # search for HTML converters other than eLyXer
 690       # On SuSE the scripts have a .sh suffix, and on debian they are in /usr/share/tex4ht/
 691       path, htmlconv = checkProg('a LaTeX -> HTML converter', ['htlatex $$i', 'htlatex.sh $$i', \
 692           '/usr/share/tex4ht/htlatex $$i', 'tth  -t -e2 -L$$b < $$i > $$o', \
 693           'latex2html -no_subdir -split 0 -show_section_numbers $$i', 'hevea -s $$i'],
 694           rc_entry = [ r'\converter latex      html       "%%"  "needaux"' ])
 695       if htmlconv.find('htlatex') >= 0 or htmlconv == 'latex2html':
 696         addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py -e html,png,css $$i $$o"''')
 697       else:
 698         addToRC(r'''\copier    html       "python -tt $$s/scripts/ext_copy.py $$i $$o"''')
 699       path, htmlconv = checkProg('a LaTeX -> HTML (MS Word) converter', ["htlatex $$i 'html,word' 'symbol/!' '-cvalidate'", \
 700           "htlatex.sh $$i 'html,word' 'symbol/!' '-cvalidate'", \
 701           "/usr/share/tex4ht/htlatex $$i 'html,word' 'symbol/!' '-cvalidate'"],
 702           rc_entry = [ r'\converter latex      wordhtml   "%%"  "needaux"' ])
 703       if htmlconv.find('htlatex') >= 0:
 704         addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py -e html,png,css $$i $$o"''')
 705       else:
 706         addToRC(r'''\copier    wordhtml       "python -tt $$s/scripts/ext_copy.py $$i $$o"''')
 707
 708
 709     # Check if LyXBlogger is installed
 710     lyxblogger_found = checkModule('lyxblogger')
 711     if lyxblogger_found:
 712       addToRC(r'\Format    blog       blog       "LyXBlogger"           "" "" ""  "document"')
 713       addToRC(r'\converter xhtml      blog       "python -m lyxblogger $$i"       ""')
 714
 715     #
 716     checkProg('an OpenOffice.org -> LaTeX converter', ['w2l -clean $$i'],
 717         rc_entry = [ r'\converter sxw        latex      "%%"    ""' ])
 718     #
 719     checkProg('an OpenDocument -> LaTeX converter', ['w2l -clean $$i'],
 720         rc_entry = [ r'\converter odt        latex      "%%"    ""' ])
 721     #
 722     checkProg('an OpenDocument -> PDF converter', ['unoconv -f pdf --stdout $$i > $$o'],
 723         rc_entry = [ r'\converter odt        pdf        "%%"    ""' ])
 724     # According to http://www.tug.org/applications/tex4ht/mn-commands.html
 725     # the command mk4ht oolatex $$i has to be used as default,
 726     # but as this would require to have Perl installed, in MiKTeX oolatex is
 727     # directly available as application.
 728     # On SuSE the scripts have a .sh suffix, and on debian they are in /usr/share/tex4ht/
 729     # Both SuSE and debian have oolatex
 730     checkProg('a LaTeX -> Open Document converter', [
 731         'oolatex $$i', 'mk4ht oolatex $$i', 'oolatex.sh $$i', '/usr/share/tex4ht/oolatex $$i',
 732         'htlatex $$i \'xhtml,ooffice\' \'ooffice/! -cmozhtf\' \'-coo\' \'-cvalidate\''],
 733         rc_entry = [ r'\converter latex      odt        "%%"    "needaux"' ])
 734     # On windows it is called latex2rt.exe
 735     checkProg('a LaTeX -> RTF converter', ['latex2rtf -p -S -o $$o $$i', 'latex2rt -p -S -o $$o $$i'],
 736         rc_entry = [ r'\converter latex      rtf        "%%"    "needaux"' ])
 737     #
 738     checkProg('a RTF -> HTML converter', ['unrtf --html  $$i > $$o'],
 739         rc_entry = [ r'\converter rtf      html        "%%"     ""' ])
 740     #
 741     checkProg('a PS to PDF converter', ['ps2pdf13 $$i $$o'],
 742         rc_entry = [ r'\converter ps         pdf        "%%"    ""' ])
 743     #
 744     checkProg('a PS to TXT converter', ['pstotext $$i > $$o'],
 745         rc_entry = [ r'\converter ps         text2      "%%"    ""' ])
 746     #
 747     checkProg('a PS to TXT converter', ['ps2ascii $$i $$o'],
 748         rc_entry = [ r'\converter ps         text3      "%%"    ""' ])
 749     # Need to call ps2eps in a pipe, otherwise it would name the output file
 750     # depending on the extension of the input file. We do not know the input
 751     # file extension in general, so the resultfile= flag would not help.
 752     # Since ps2eps crops the image, we do not use it to convert from ps->eps.
 753     # This would create additional paths in the converter graph with unwanted
 754     # side effects (e.g. ps->pdf via ps2pdf would create a different result
 755     # than ps->eps->pdf via ps2eps and epstopdf).
 756     checkProg('a PS to EPS converter', ['ps2eps -- < $$i > $$o'],
 757         rc_entry = [ r'\converter eps2       eps      "%%"      ""' ])
 758     #
 759     checkProg('a PDF to PS converter', ['pdf2ps $$i $$o', 'pdftops $$i $$o'],
 760         rc_entry = [ r'\converter pdf         ps        "%%"    ""' ])
 761     #
 762     checkProg('a PDF to EPS converter', ['pdftops -eps -f 1 -l 1 $$i $$o'],
 763         rc_entry = [ r'\converter pdf         eps        "%%"   ""' ])
 764     #
 765     checkProg('a DVI to TXT converter', ['catdvi $$i > $$o'],
 766         rc_entry = [ r'\converter dvi        text4      "%%"    ""' ])
 767     #
 768     checkProg('a DVI to PS converter', ['dvips -o $$o $$i'],
 769         rc_entry = [ r'\converter dvi        ps         "%%"    ""' ])
 770     #
 771     checkProg('a DVI to PDF converter', ['dvipdfmx -o $$o $$i', 'dvipdfm -o $$o $$i'],
 772         rc_entry = [ r'\converter dvi        pdf3       "%%"    ""' ])
 773     #
 774     checkProg('a fax program', ['kdeprintfax $$i', 'ksendfax $$i', 'hylapex $$i'],
 775         rc_entry = [ r'\converter ps         fax        "%%"    ""'])
 776     #
 777     path, fig2dev = checkProg('a FIG -> Image converter', ['fig2dev'])
 778     if fig2dev == "fig2dev":
 779         addToRC(r'''\converter fig        eps        "fig2dev -L eps $$i $$o"   ""
 780 \converter fig        ppm        "fig2dev -L ppm $$i $$o"       ""
 781 \converter fig        png        "fig2dev -L png $$i $$o"       ""
 782 \converter fig        pdftex     "python -tt $$s/scripts/fig2pdftex.py $$i $$o" ""
 783 \converter fig        pstex      "python -tt $$s/scripts/fig2pstex.py $$i $$o"  ""''')
 784     #
 785     checkProg('a TIFF -> PS converter', ['tiff2ps $$i > $$o'],
 786         rc_entry = [ r'\converter tiff       eps        "%%"    ""', ''])
 787     #
 788     checkProg('a TGIF -> EPS/PPM converter', ['tgif'],
 789         rc_entry = [
 790             r'''\converter tgif       eps        "tgif -print -color -eps -stdout $$i > $$o"    ""
 791 \converter tgif       png        "tgif -print -color -png -o $$d $$i"   ""
 792 \converter tgif       pdf        "tgif -print -color -pdf -stdout $$i > $$o"    ""''',
 793             ''])
 794     #
 795     checkProg('a WMF -> EPS converter', ['metafile2eps $$i $$o', 'wmf2eps -o $$o $$i'],
 796         rc_entry = [ r'\converter wmf        eps        "%%"    ""'])
 797     #
 798     checkProg('an EMF -> EPS converter', ['metafile2eps $$i $$o', 'wmf2eps -o $$o $$i'],
 799         rc_entry = [ r'\converter emf        eps        "%%"    ""'])
 800     #
 801     checkProg('an EPS -> PDF converter', ['epstopdf'],
 802         rc_entry = [ r'\converter eps        pdf        "epstopdf --outfile=$$o $$i"    ""', ''])
 803     #
 804     checkProg('an EPS -> PNG converter', ['convert $$i $$o'],
 805         rc_entry = [ r'\converter eps        png        "%%"    ""', ''])
 806     #
 807     # no agr -> pdf converter, since the pdf library used by gracebat is not
 808     # free software and therefore not compiled in in many installations.
 809     # Fortunately, this is not a big problem, because we will use epstopdf to
 810     # convert from agr to pdf via eps without loss of quality.
 811     checkProg('a Grace -> Image converter', ['gracebat'],
 812         rc_entry = [
 813             r'''\converter agr        eps        "gracebat -hardcopy -printfile $$o -hdevice EPS $$i 2>/dev/null"       ""
 814 \converter agr        png        "gracebat -hardcopy -printfile $$o -hdevice PNG $$i 2>/dev/null"       ""
 815 \converter agr        jpg        "gracebat -hardcopy -printfile $$o -hdevice JPEG $$i 2>/dev/null"      ""
 816 \converter agr        ppm        "gracebat -hardcopy -printfile $$o -hdevice PNM $$i 2>/dev/null"       ""''',
 817             ''])
 818     #
 819     checkProg('a Dot -> Image converter', ['dot'],
 820         rc_entry = [
 821             r'''\converter dot        eps        "dot -Teps $$i -o $$o" ""
 822 \converter dot        png        "dot -Tpng $$i -o $$o" ""''',
 823             ''])
 824     #
 825     checkProg('a Dia -> PNG converter', ['dia -e $$o -t png $$i'],
 826         rc_entry = [ r'\converter dia        png        "%%"    ""'])
 827     #
 828     checkProg('a Dia -> EPS converter', ['dia -e $$o -t eps $$i'],
 829         rc_entry = [ r'\converter dia        eps        "%%"    ""'])
 830     # Actually, this produces EPS, but with a wrong bounding box (usually A4 or letter).
 831     # The eps2->eps converter then fixes the bounding box by cropping.
 832     # Although unoconv can convert to png and pdf as well, do not define
 833     # odg->png and odg->pdf converters, since the bb would be too large as well.
 834     checkProg('an OpenOffice -> EPS converter', ['libreoffice -headless -nologo -convert-to eps $$i', 'unoconv -f eps --stdout $$i > $$o'],
 835         rc_entry = [ r'\converter odg        eps2       "%%"    ""'])
 836     #
 837     checkProg('a SVG -> PDF converter', ['rsvg-convert -f pdf -o $$o $$i', 'inkscape --file=$$i --export-area-drawing --without-gui --export-pdf=$$o'],
 838         rc_entry = [ r'\converter svg        pdf        "%%"    ""'])
 839     #
 840     checkProg('a SVG -> EPS converter', ['rsvg-convert -f ps -o $$o $$i', 'inkscape --file=$$i --export-area-drawing --without-gui --export-eps=$$o'],
 841         rc_entry = [ r'\converter svg        eps        "%%"    ""'])
 842     #
 843     checkProg('a SVG -> PNG converter', ['rsvg-convert -f png -o $$o $$i', 'inkscape --without-gui --file=$$i --export-png=$$o'],
 844         rc_entry = [ r'\converter svg        png        "%%"    ""'])
 845
 846     #
 847     # gnumeric/xls/ods to tex
 848     checkProg('a spreadsheet -> latex converter', ['ssconvert'],
 849        rc_entry = [ r'''\converter gnumeric latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
 850 \converter oocalc latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""
 851 \converter excel  latex "ssconvert --export-type=Gnumeric_html:latex $$i $$o" ""''',
 852 ''])
 853
 854     path, lilypond = checkProg('a LilyPond -> EPS/PDF/PNG converter', ['lilypond'])
 855     if (lilypond != ''):
 856         version_string = cmdOutput("lilypond --version")
 857         match = re.match('GNU LilyPond (\S+)', version_string)
 858         if match:
 859             version_number = match.groups()[0]
 860             version = version_number.split('.')
 861             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 11):
 862                 addToRC(r'''\converter lilypond   eps        "lilypond -dbackend=eps -dsafe --ps $$i"   ""
 863 \converter lilypond   png        "lilypond -dbackend=eps -dsafe --png $$i"      ""''')
 864                 addToRC(r'\converter lilypond   pdf        "lilypond -dbackend=eps -dsafe --pdf $$i"    ""')
 865                 logger.info('+  found LilyPond version %s.' % version_number)
 866             elif int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 6):
 867                 addToRC(r'''\converter lilypond   eps        "lilypond -b eps --ps --safe $$i"  ""
 868 \converter lilypond   png        "lilypond -b eps --png $$i"    ""''')
 869                 if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 9):
 870                     addToRC(r'\converter lilypond   pdf        "lilypond -b eps --pdf --safe $$i"       ""')
 871                 logger.info('+  found LilyPond version %s.' % version_number)
 872             else:
 873                 logger.info('+  found LilyPond, but version %s is too old.' % version_number)
 874         else:
 875             logger.info('+  found LilyPond, but could not extract version number.')
 876     #
 877     path, lilypond_book = checkProg('a LilyPond book (LaTeX) -> LaTeX converter', ['lilypond-book'])
 878     if (lilypond_book != ''):
 879         version_string = cmdOutput("lilypond-book --version")
 880         match = re.match('^(\S+)$', version_string)
 881         if match:
 882             version_number = match.groups()[0]
 883             version = version_number.split('.')
 884             if int(version[0]) > 2 or (len(version) > 1 and int(version[0]) == 2 and int(version[1]) >= 13):
 885                 # Note: The --lily-output-dir flag is required because lilypond-book
 886                 #       does not process input again unless the input has changed,
 887                 #       even if the output format being requested is different. So
 888                 #       once a .eps file exists, lilypond-book won't create a .pdf
 889                 #       even when requested with --pdf. This is a problem if a user
 890                 #       clicks View PDF after having done a View DVI. To circumvent
 891                 #       this, use different output folders for eps and pdf outputs.
 892                 addToRC(r'\converter lilypond-book latex    "lilypond-book --safe --lily-output-dir=ly-eps $$i"                                ""')
 893                 addToRC(r'\converter lilypond-book pdflatex "lilypond-book --safe --pdf --latex-program=pdflatex --lily-output-dir=ly-pdf $$i" ""')
 894                 addToRC(r'\converter lilypond-book xetex    "lilypond-book --safe --pdf --latex-program=xelatex --lily-output-dir=ly-pdf $$i"  ""')
 895                 addToRC(r'\converter lilypond-book luatex   "lilypond-book --safe --pdf --latex-program=lualatex --lily-output-dir=ly-pdf $$i" ""')
 896                 logger.info('+  found LilyPond-book version %s.' % version_number)
 897             else:
 898                 logger.info('+  found LilyPond-book, but version %s is too old.' % version_number)
 899         else:
 900             logger.info('+  found LilyPond-book, but could not extract version number.')
 901     #
 902     checkProg('a Noteedit -> LilyPond converter', ['noteedit --export-lilypond $$i'],
 903         rc_entry = [ r'\converter noteedit   lilypond   "%%"    ""', ''])
 904     #
 905     # Currently, lyxpak outputs a gzip compressed tar archive on *nix
 906     # and a zip archive on Windows.
 907     # So, we configure the appropriate version according to the platform.
 908     cmd = r'\converter lyx %s "python -tt $$s/scripts/lyxpak.py $$r/$$f" ""'
 909     if os.name == 'nt':
 910         addToRC(r'\Format lyxzip     zip    "LyX Archive (zip)"     "" "" ""  "document,menu=export"    ""')
 911         addToRC(cmd % "lyxzip")
 912     else:
 913         addToRC(r'\Format lyxgz      gz     "LyX Archive (tar.gz)"  "" "" ""  "document,menu=export"    ""')
 914         addToRC(cmd % "lyxgz")
 915
 916     #
 917     # FIXME: no rc_entry? comment it out
 918     # checkProg('Image converter', ['convert $$i $$o'])
 919     #
 920     # Entries that do not need checkProg
 921     addToRC(r'''
 922 \converter csv        lyx        "python -tt $$s/scripts/csv2lyx.py $$i $$o"    ""
 923 \converter date       dateout    "python -tt $$s/scripts/date.py %d-%m-%Y > $$o"        ""
 924 \converter docbook    docbook-xml "cp $$i $$o"  "xml"
 925 \converter fen        asciichess "python -tt $$s/scripts/fen2ascii.py $$i $$o"  ""
 926 \converter lyx        lyx13x     "python -tt $$s/lyx2lyx/lyx2lyx -t 221 $$i > $$o"      ""
 927 \converter lyx        lyx14x     "python -tt $$s/lyx2lyx/lyx2lyx -t 245 $$i > $$o"      ""
 928 \converter lyx        lyx15x     "python -tt $$s/lyx2lyx/lyx2lyx -t 276 $$i > $$o"      ""
 929 \converter lyx        lyx16x     "python -tt $$s/lyx2lyx/lyx2lyx -t 345 $$i > $$o"      ""
 930 \converter lyx        lyx20x     "python -tt $$s/lyx2lyx/lyx2lyx -t 413 $$i > $$o"      ""
 931 \converter lyx        clyx       "python -tt $$s/lyx2lyx/lyx2lyx -c big5 -t 245 $$i > $$o"      ""
 932 \converter lyx        jlyx       "python -tt $$s/lyx2lyx/lyx2lyx -c euc_jp -t 245 $$i > $$o"    ""
 933 \converter lyx        klyx       "python -tt $$s/lyx2lyx/lyx2lyx -c euc_kr -t 245 $$i > $$o"    ""
 934 \converter clyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c big5 $$i > $$o"     ""
 935 \converter jlyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_jp $$i > $$o"   ""
 936 \converter klyx       lyx        "python -tt $$s/lyx2lyx/lyx2lyx -c euc_kr $$i > $$o"   ""
 937 \converter lyxpreview png        "python -tt $$s/scripts/lyxpreview2bitmap.py --png"    ""
 938 \converter lyxpreview ppm        "python -tt $$s/scripts/lyxpreview2bitmap.py --ppm"    ""
 939 ''')
 940
 941
 942 def checkDocBook():
 943     ''' Check docbook '''
 944     path, DOCBOOK = checkProg('SGML-tools 2.x (DocBook), db2x scripts or xsltproc', ['sgmltools', 'db2dvi', 'xsltproc'],
 945         rc_entry = [
 946             r'''\converter docbook    dvi        "sgmltools -b dvi $$i" ""
 947 \converter docbook    html       "sgmltools -b html $$i"        ""''',
 948             r'''\converter docbook    dvi        "db2dvi $$i"   ""
 949 \converter docbook    html       "db2html $$i"  ""''',
 950             r'''\converter docbook    dvi        ""     ""
 951 \converter docbook    html       "" ""''',
 952             r'''\converter docbook    dvi        ""     ""
 953 \converter docbook    html       ""     ""'''])
 954     #
 955     if DOCBOOK != '':
 956         return ('yes', 'true', '\\def\\hasdocbook{yes}')
 957     else:
 958         return ('no', 'false', '')
 959
 960
 961 def checkOtherEntries():
 962     ''' entries other than Format and Converter '''
 963     checkProg('ChkTeX', ['chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38'],
 964         rc_entry = [ r'\chktex_command "%%"' ])
 965     checkProgAlternatives('BibTeX or alternative programs', ['bibtex', 'bibtex8', 'biber'],
 966         rc_entry = [ r'\bibtex_command "%%"' ],
 967         alt_rc_entry = [ r'\bibtex_alternatives "%%"' ])
 968     checkProg('a specific Japanese BibTeX variant', ['pbibtex', 'jbibtex', 'bibtex'],
 969         rc_entry = [ r'\jbibtex_command "%%"' ])
 970     checkProgAlternatives('available index processors', ['texindy', 'makeindex -c -q', 'xindy'],
 971         rc_entry = [ r'\index_command "%%"' ],
 972         alt_rc_entry = [ r'\index_alternatives "%%"' ])
 973     checkProg('an index processor appropriate to Japanese', ['mendex -c -q', 'jmakeindex -c -q', 'makeindex -c -q'],
 974         rc_entry = [ r'\jindex_command "%%"' ])
 975     checkProg('the splitindex processor', ['splitindex.pl', 'splitindex',
 976         'splitindex.class'], rc_entry = [ r'\splitindex_command "%%"' ])
 977     checkProg('a nomenclature processor', ['makeindex'],
 978         rc_entry = [ r'\nomencl_command "makeindex -s nomencl.ist"' ])
 979     ## FIXME: OCTAVE is not used anywhere
 980     # path, OCTAVE = checkProg('Octave', ['octave'])
 981     ## FIXME: MAPLE is not used anywhere
 982     # path, MAPLE = checkProg('Maple', ['maple'])
 983     checkProg('a spool command', ['lp', 'lpr'],
 984         rc_entry = [
 985             r'''\print_spool_printerprefix "-d "
 986 \print_spool_command "lp"''',
 987             r'''\print_spool_printerprefix "-P",
 988 \print_spool_command "lpr"''',
 989             ''])
 990     # Add the rest of the entries (no checkProg is required)
 991     addToRC(r'''\copier    fig        "python -tt $$s/scripts/fig_copy.py $$i $$o"
 992 \copier    pstex      "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
 993 \copier    pdftex     "python -tt $$s/scripts/tex_copy.py $$i $$o $$l"
 994 \copier    program    "python -tt $$s/scripts/ext_copy.py $$i $$o"
 995 ''')
 996
 997
 998 def processLayoutFile(file, bool_docbook):
 999     ''' process layout file and get a line of result
1000
1001         Declare lines look like this: (article.layout, scrbook.layout, svjog.layout)
1002
1003         \DeclareLaTeXClass{article}
1004         \DeclareLaTeXClass[scrbook]{book (koma-script)}
1005         \DeclareLaTeXClass[svjour,svjog.clo]{article (Springer - svjour/jog)}
1006
1007         we expect output:
1008
1009         "article" "article" "article" "false" "article.cls"
1010         "scrbook" "scrbook" "book (koma-script)" "false" "scrbook.cls"
1011         "svjog" "svjour" "article (Springer - svjour/jog)" "false" "svjour.cls,svjog.clo"
1012     '''
1013     def checkForClassExtension(x):
1014         '''if the extension for a latex class is not
1015            provided, add .cls to the classname'''
1016         if not '.' in x:
1017             return x.strip() + '.cls'
1018         else:
1019             return x.strip()
1020     classname = file.split(os.sep)[-1].split('.')[0]
1021     # return ('LaTeX', '[a,b]', 'a', ',b,c', 'article') for \DeclareLaTeXClass[a,b,c]{article}
1022     p = re.compile(r'\Declare(LaTeX|DocBook)Class\s*(\[([^,]*)(,.*)*\])*\s*{(.*)}')
1023     for line in open(file).readlines():
1024         res = p.search(line)
1025         if res != None:
1026             (classtype, optAll, opt, opt1, desc) = res.groups()
1027             avai = {'LaTeX':'false', 'DocBook':bool_docbook}[classtype]
1028             if opt == None:
1029                 opt = classname
1030                 prereq_latex = checkForClassExtension(classname)
1031             else:
1032                 prereq_list = optAll[1:-1].split(',')
1033                 prereq_list = map(checkForClassExtension, prereq_list)
1034                 prereq_latex = ','.join(prereq_list)
1035             prereq_docbook = {'true':'', 'false':'docbook'}[bool_docbook]
1036             prereq = {'LaTeX':prereq_latex, 'DocBook':prereq_docbook}[classtype]
1037             return '"%s" "%s" "%s" "%s" "%s"\n' % (classname, opt, desc, avai, prereq)
1038     logger.warning("Layout file " + file + " has no \DeclareXXClass line. ")
1039     return ""
1040
1041
1042 def checkLatexConfig(check_config, bool_docbook):
1043     ''' Explore the LaTeX configuration
1044         Return None (will be passed to sys.exit()) for success.
1045     '''
1046     msg = 'checking LaTeX configuration... '
1047     # if --without-latex-config is forced, or if there is no previous
1048     # version of textclass.lst, re-generate a default file.
1049     if not os.path.isfile('textclass.lst') or not check_config:
1050         # remove the files only if we want to regenerate
1051         removeFiles(['textclass.lst', 'packages.lst'])
1052         #
1053         # Then, generate a default textclass.lst. In case configure.py
1054         # fails, we still have something to start lyx.
1055         logger.info(msg + ' default values')
1056         logger.info('+checking list of textclasses... ')
1057         tx = open('textclass.lst', 'w')
1058         tx.write('''
1059 # This file declares layouts and their associated definition files
1060 # (include dir. relative to the place where this file is).
1061 # It contains only default values, since chkconfig.ltx could not be run
1062 # for some reason. Run ./configure.py if you need to update it after a
1063 # configuration change.
1064 ''')
1065         # build the list of available layout files and convert it to commands
1066         # for chkconfig.ltx
1067         foundClasses = []
1068         for file in glob.glob( os.path.join('layouts', '*.layout') ) + \
1069             glob.glob( os.path.join(srcdir, 'layouts', '*.layout' ) ) :
1070             # valid file?
1071             if not os.path.isfile(file):
1072                 continue
1073             # get stuff between /xxxx.layout .
1074             classname = file.split(os.sep)[-1].split('.')[0]
1075             #  tr ' -' '__'`
1076             cleanclass = classname.replace(' ', '_')
1077             cleanclass = cleanclass.replace('-', '_')
1078             # make sure the same class is not considered twice
1079             if foundClasses.count(cleanclass) == 0: # not found before
1080                 foundClasses.append(cleanclass)
1081                 retval = processLayoutFile(file, bool_docbook)
1082                 if retval != "":
1083                     tx.write(retval)
1084         tx.close()
1085         logger.info('\tdone')
1086     if not check_config:
1087         return None
1088     # the following will generate textclass.lst.tmp, and packages.lst.tmp
1089     logger.info(msg + '\tauto')
1090     removeFiles(['chkconfig.classes', 'chkconfig.vars', 'chklayouts.tex',
1091         'wrap_chkconfig.ltx'])
1092     rmcopy = False
1093     if not os.path.isfile( 'chkconfig.ltx' ):
1094         shutil.copyfile( os.path.join(srcdir, 'chkconfig.ltx'), 'chkconfig.ltx' )
1095         rmcopy = True
1096     writeToFile('wrap_chkconfig.ltx', '%s\n\\input{chkconfig.ltx}\n' % docbook_cmd)
1097     # Construct the list of classes to test for.
1098     # build the list of available layout files and convert it to commands
1099     # for chkconfig.ltx
1100     declare = re.compile(r'\Declare(LaTeX|DocBook)Class\s*(\[([^,]*)(,.*)*\])*\s*{(.*)}')
1101     empty = re.compile(r'^\s*$')
1102     testclasses = list()
1103     for file in glob.glob( os.path.join('layouts', '*.layout') ) + \
1104         glob.glob( os.path.join(srcdir, 'layouts', '*.layout' ) ) :
1105         nodeclaration = False
1106         if not os.path.isfile(file):
1107             continue
1108         classname = file.split(os.sep)[-1].split('.')[0]
1109         for line in open(file).readlines():
1110             if not empty.match(line) and line[0] != '#':
1111                 logger.warning("Failed to find valid \Declare line for layout file `" + file + "'.\n\t=> Skipping this file!")
1112                 nodeclaration = True
1113                 break
1114             if declare.search(line) == None:
1115                 continue
1116             testclasses.append("\\TestDocClass{%s}{%s}" % (classname, line[1:].strip()))
1117             break
1118         if nodeclaration:
1119             continue
1120     testclasses.sort()
1121     cl = open('chklayouts.tex', 'w')
1122     for line in testclasses:
1123         cl.write(line + '\n')
1124     cl.close()
1125     #
1126     # we have chklayouts.tex, then process it
1127     ret = 1
1128     latex_out = cmdOutput(LATEX + ' wrap_chkconfig.ltx')
1129     for line in latex_out.splitlines():
1130         if re.match('^\+', line):
1131             logger.info(line.strip())
1132             # return None if the command succeeds
1133             if line == "+Inspection done.":
1134                 ret = None
1135     #
1136     # remove the copied file
1137     if rmcopy:
1138         removeFiles( [ 'chkconfig.ltx' ] )
1139     #
1140     # currently, values in chhkconfig are only used to set
1141     # \font_encoding
1142     values = {}
1143     for line in open('chkconfig.vars').readlines():
1144         key, val = re.sub('-', '_', line).split('=')
1145         val = val.strip()
1146         values[key] = val.strip("'")
1147     # chk_fontenc may not exist
1148     try:
1149         addToRC(r'\font_encoding "%s"' % values["chk_fontenc"])
1150     except:
1151         pass
1152     # if configure successed, move textclass.lst.tmp to textclass.lst
1153     # and packages.lst.tmp to packages.lst
1154     if os.path.isfile('textclass.lst.tmp') and len(open('textclass.lst.tmp').read()) > 0 \
1155         and os.path.isfile('packages.lst.tmp') and len(open('packages.lst.tmp').read()) > 0:
1156         shutil.move('textclass.lst.tmp', 'textclass.lst')
1157         shutil.move('packages.lst.tmp', 'packages.lst')
1158     return ret
1159
1160
1161 def checkModulesConfig():
1162   removeFiles(['lyxmodules.lst', 'chkmodules.tex'])
1163
1164   logger.info('+checking list of modules... ')
1165   tx = open('lyxmodules.lst', 'w')
1166   tx.write('''## This file declares modules and their associated definition files.
1167 ## It has been automatically generated by configure
1168 ## Use "Options/Reconfigure" if you need to update it after a
1169 ## configuration change.
1170 ## "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1171 ''')
1172
1173   # build the list of available modules
1174   seen = []
1175   # note that this searches the local directory first, then the
1176   # system directory. that way, we pick up the user's version first.
1177   for file in glob.glob( os.path.join('layouts', '*.module') ) + \
1178       glob.glob( os.path.join(srcdir, 'layouts', '*.module' ) ) :
1179       # valid file?
1180       logger.info(file)
1181       if not os.path.isfile(file):
1182           continue
1183
1184       filename = file.split(os.sep)[-1]
1185       filename = filename[:-7]
1186       if seen.count(filename):
1187           continue
1188
1189       seen.append(filename)
1190       retval = processModuleFile(file, filename, bool_docbook)
1191       if retval != "":
1192           tx.write(retval)
1193   tx.close()
1194   logger.info('\tdone')
1195
1196
1197 def processModuleFile(file, filename, bool_docbook):
1198     ''' process module file and get a line of result
1199
1200         The top of a module file should look like this:
1201           #\DeclareLyXModule[LaTeX Packages]{ModuleName}
1202           #DescriptionBegin
1203           #...body of description...
1204           #DescriptionEnd
1205           #Requires: [list of required modules]
1206           #Excludes: [list of excluded modules]
1207           #Category: [category name]
1208         The last three lines are optional (though do give a category).
1209         We expect output:
1210           "ModuleName" "filename" "Description" "Packages" "Requires" "Excludes" "Category"
1211     '''
1212     remods = re.compile(r'\DeclareLyXModule\s*(?:\[([^]]*?)\])?{(.*)}')
1213     rereqs = re.compile(r'#+\s*Requires: (.*)')
1214     reexcs = re.compile(r'#+\s*Excludes: (.*)')
1215     recaty = re.compile(r'#+\s*Category: (.*)')
1216     redbeg = re.compile(r'#+\s*DescriptionBegin\s*$')
1217     redend = re.compile(r'#+\s*DescriptionEnd\s*$')
1218
1219     modname = desc = pkgs = req = excl = catgy = ""
1220     readingDescription = False
1221     descLines = []
1222
1223     for line in open(file).readlines():
1224       if readingDescription:
1225         res = redend.search(line)
1226         if res != None:
1227           readingDescription = False
1228           desc = " ".join(descLines)
1229           # Escape quotes.
1230           desc = desc.replace('"', '\\"')
1231           continue
1232         descLines.append(line[1:].strip())
1233         continue
1234       res = redbeg.search(line)
1235       if res != None:
1236         readingDescription = True
1237         continue
1238       res = remods.search(line)
1239       if res != None:
1240           (pkgs, modname) = res.groups()
1241           if pkgs == None:
1242             pkgs = ""
1243           else:
1244             tmp = [s.strip() for s in pkgs.split(",")]
1245             pkgs = ",".join(tmp)
1246           continue
1247       res = rereqs.search(line)
1248       if res != None:
1249         req = res.group(1)
1250         tmp = [s.strip() for s in req.split("|")]
1251         req = "|".join(tmp)
1252         continue
1253       res = reexcs.search(line)
1254       if res != None:
1255         excl = res.group(1)
1256         tmp = [s.strip() for s in excl.split("|")]
1257         excl = "|".join(tmp)
1258         continue
1259       res = recaty.search(line)
1260       if res != None:
1261         catgy = res.group(1)
1262         continue
1263
1264     if modname == "":
1265       logger.warning("Module file without \DeclareLyXModule line. ")
1266       return ""
1267
1268     if pkgs != "":
1269         # this module has some latex dependencies:
1270         # append the dependencies to chkmodules.tex,
1271         # which is \input'ed by chkconfig.ltx
1272         testpackages = list()
1273         for pkg in pkgs.split(","):
1274             if "->" in pkg:
1275                 # this is a converter dependency: skip
1276                 continue
1277             if pkg.endswith(".sty"):
1278                 pkg = pkg[:-4]
1279             testpackages.append("\\TestPackage{%s}" % (pkg,))
1280         cm = open('chkmodules.tex', 'a')
1281         for line in testpackages:
1282             cm.write(line + '\n')
1283         cm.close()
1284
1285     return '"%s" "%s" "%s" "%s" "%s" "%s" "%s"\n' % (modname, filename, desc, pkgs, req, excl, catgy)
1286
1287
1288 def checkTeXAllowSpaces():
1289     ''' Let's check whether spaces are allowed in TeX file names '''
1290     tex_allows_spaces = 'false'
1291     if lyx_check_config:
1292         msg = "Checking whether TeX allows spaces in file names... "
1293         writeToFile('a b.tex', r'\message{working^^J}' )
1294         if LATEX != '':
1295             if os.name == 'nt' or sys.platform == 'cygwin':
1296                 latex_out = cmdOutput(LATEX + r""" "\nonstopmode\input{\"a b\"}\makeatletter\@@end" """)
1297             else:
1298                 latex_out = cmdOutput(LATEX + r""" '\nonstopmode\input{"a b"}\makeatletter\@@end' """)
1299         else:
1300             latex_out = ''
1301         if 'working' in latex_out:
1302             logger.info(msg + 'yes')
1303             tex_allows_spaces = 'true'
1304         else:
1305             logger.info(msg + 'no')
1306             tex_allows_spaces = 'false'
1307         addToRC(r'\tex_allows_spaces ' + tex_allows_spaces)
1308         removeFiles( [ 'a b.tex', 'a b.log', 'texput.log' ])
1309
1310
1311 def removeTempFiles():
1312     # Final clean-up
1313     if not lyx_keep_temps:
1314         removeFiles(['chkconfig.vars', 'chklatex.ltx', 'chklatex.log',
1315             'chklayouts.tex', 'chkmodules.tex', 'missfont.log',
1316             'wrap_chkconfig.ltx', 'wrap_chkconfig.log'])
1317
1318
1319 if __name__ == '__main__':
1320     lyx_check_config = True
1321     outfile = 'lyxrc.defaults'
1322     lyxrc_fileformat = 7
1323     rc_entries = ''
1324     lyx_keep_temps = False
1325     version_suffix = ''
1326     ## Parse the command line
1327     for op in sys.argv[1:]:   # default shell/for list is $*, the options
1328         if op in [ '-help', '--help', '-h' ]:
1329             print '''Usage: configure [options]
1330 Options:
1331     --help                   show this help lines
1332     --keep-temps             keep temporary files (for debug. purposes)
1333     --without-latex-config   do not run LaTeX to determine configuration
1334     --with-version-suffix=suffix suffix of binary installed files
1335 '''
1336             sys.exit(0)
1337         elif op == '--without-latex-config':
1338             lyx_check_config = False
1339         elif op == '--keep-temps':
1340             lyx_keep_temps = True
1341         elif op[0:22] == '--with-version-suffix=':  # never mind if op is not long enough
1342             version_suffix = op[22:]
1343         else:
1344             print "Unknown option", op
1345             sys.exit(1)
1346     #
1347     # check if we run from the right directory
1348     srcdir = os.path.dirname(sys.argv[0])
1349     if srcdir == '':
1350         srcdir = '.'
1351     if not os.path.isfile( os.path.join(srcdir, 'chkconfig.ltx') ):
1352         logger.error("configure: error: cannot find chkconfig.ltx script")
1353         sys.exit(1)
1354     setEnviron()
1355     createDirectories()
1356     dtl_tools = checkDTLtools()
1357     ## Write the first part of outfile
1358     writeToFile(outfile, '''# This file has been automatically generated by LyX' lib/configure.py
1359 # script. It contains default settings that have been determined by
1360 # examining your system. PLEASE DO NOT MODIFY ANYTHING HERE! If you
1361 # want to customize LyX, use LyX' Preferences dialog or modify directly
1362 # the "preferences" file instead. Any setting in that file will
1363 # override the values given here.
1364
1365 Format %i
1366
1367 ''' % lyxrc_fileformat)
1368     # check latex
1369     LATEX = checkLatex(dtl_tools)
1370     # check java and perl before any checkProg that may require them
1371     java = checkProg('a java interpreter', ['java'])[1]
1372     perl = checkProg('a perl interpreter', ['perl'])[1]
1373     checkFormatEntries(dtl_tools)
1374     checkConverterEntries()
1375     (chk_docbook, bool_docbook, docbook_cmd) = checkDocBook()
1376     checkTeXAllowSpaces()
1377     windows_style_tex_paths = checkTeXPaths()
1378     if windows_style_tex_paths != '':
1379         addToRC(r'\tex_expects_windows_paths %s' % windows_style_tex_paths)
1380     checkOtherEntries()
1381     checkModulesConfig()
1382     # --without-latex-config can disable lyx_check_config
1383     ret = checkLatexConfig(lyx_check_config and LATEX != '', bool_docbook)
1384     removeTempFiles()
1385     # The return error code can be 256. Because most systems expect an error code
1386     # in the range 0-127, 256 can be interpretted as 'success'. Because we expect
1387     # a None for success, 'ret is not None' is used to exit.
1388     sys.exit(ret is not None)