# vim: set filetype=python :

# arch-tag: general-purpose SCons build file for sgml-common

from glob import glob

import os, re

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

# Setup

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

SConsignFile('.sconsign-master')

#Import('env')

d = env.Dictionary()

if not 'JADE' in d:

    d['JADE'] = 'jade'

if not 'INDEXNODE' in d:

    d['INDEXNODE'] = 'ch.index'

if not 'GTKIMGPATH' in d:

    d['GTKIMGPATH'] = '/usr/share/gtk-doc/data'

if not 'PS2EPSI' in d:

    d['PS2EPSI'] = '../sgml-common/ps2epsi'

def removeindex(l):

    while 'index/index.sgml' in l:

        l.remove('index/index.sgml')

master = d['MASTERBASE'] 

mastersgml = master + '.sgml'

sources = [mastersgml] + glob('*/*.sgml') + glob('*/*/*.sgml')

removeindex(sources)

db2htmlcmd = 'docbook-2-html -D $JADE ${HTMLARGS}  ${SOURCE}'

db2htmlindexcmd = 'docbook-2-html -D $JADE -O -V -O html-index ${HTMLARGS} ${SOURCE}'

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

# SCANNERS

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

def recursescan(scanner, node, env):

    result = scanner(node, env) 

    retval = []

    for item in result:

        retval.append(item)

        retval.extend(recursescan(scanner, item, env))

    return retval

SGML_includes_re = re.compile(r'<!ENTITY[^>]+SYSTEM[^>]+"(.+)"', re.M)

def SGML_includes_scan(node, env, path):

    ret = SGML_includes_re.findall(node.get_contents())

    removeindex(ret)

    return ret

SGML_includes_scanner = Scanner(name = 'SGML_includes',

    function = SGML_includes_scan, recursive = 1, skeys = ['.sgml', '.ent'])

SGML_image_pdf_re = re.compile(r'<(graphic|imagedata).+?fileref="([^"]+\.pdf)"', re.S)

SGML_image_png_re = re.compile(r'<(graphic|imagedata).+?fileref="([^"]+\.png)"', re.S)

def SGML_image_scanner(node, env, path, arg):

    root, ext = os.path.splitext(str(node))

    contents = node.get_contents()

    return SGML_includes_scan(node, env, path) + \

            [os.getcwd() + '/' + x[1] for x in arg.findall(contents)]

SGML_pdf_scanner = Scanner(name = 'SGML_pdf',

         function = SGML_image_scanner, argument = SGML_image_pdf_re,

         recursive = 1)

SGML_png_scanner = Scanner(name = 'SGML_png',

        function = SGML_image_scanner, argument = SGML_image_png_re,

        recursive = 1)

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

# BUILDERS

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

#### PLAIN TEXT

Btxt = Builder(action="docbook2txt $SOURCE", src_suffix='.sgml', suffix='.txt')

#### PDF / POSTSCRIPT

Bpdf = Builder(action="docbook-2-pdf -D ${JADE} -q -O -V -O paper-size=Letter ${PDFARGS} ${SOURCE}",

        src_suffix='.sgml', suffix='.pdf')

Bpdf2ps = Builder(action="pdftops ${SOURCE}", src_suffix='.pdf', suffix='.ps')

#### MAN PAGES

# FIXME: test this

Bman = Builder(action="docbook2man $SOURCE", src_suffix='.sgml', suffix='.1')

#### HTML

Bhtml = Builder(action = [ \

        'if test -d ${TARGET.dir} ; then rm -r ${TARGET.dir} ; fi',

        'mkdir ${TARGET.dir}',

        db2htmlcmd,

        'mv ${MASTERBASE}-html/* ${TARGET.dir}/',

        'rmdir ${MASTERBASE}-html',

        'ln -s ${TOPNODE}.html ${TARGET.dir}/index.html',

        'cp ${GTKIMGPATH}/*.png ${TARGET.dir}/'])

#### PNG

Bepip2png = Builder(action = 'gs -q -dTextAlphaBits=4 -dGraphicsAlphaBits=4 ' +\

        '-r90 -dBATCH -dNOPAUSE -dSAFER -sOutputFile=$TARGET ' + \

        '-sDEVICE=png16m $SOURCE -c showpage', suffix='.png', src_suffix='.pngepi')

#### EPI from PS

def getpagenumfromname(target, source, env, for_signature):

    return re.search('^.*_(\d+)\.(png){0,1}epi$', str(target[0])).group(1)

d['GETPAGE'] = getpagenumfromname

Aps2epi = Action(['psselect -q ${GETPAGE} $SOURCE temp.ps',

        'psresize -w ${WIDTH} -h ${HEIGHT} temp.ps temp2.ps',

        '$PS2EPSI temp2.ps $TARGET',

        'rm temp.ps temp2.ps'])

Bps2epi = Builder(action=Aps2epi, src_suffix='.ps', suffix='.epi')

Bps2epip = Builder(action=Aps2epi, src_suffix='.ps', suffix='.pngepi')

Bepi2pdf = Builder(action="epstopdf -o=${TARGET} ${SOURCE}", suffix='.pdf',

        src_suffix='.epi')

#### PLUCKER

Bplucker = Builder(action = 'plucker-build --bpp=4 --compression=zlib ' + \

        '--doc-name="${MASTERBASE}" -H file:${SOURCE.abspath} -M 5 ' + \

        '--maxheight=320 --maxwidth=310 --staybelow=file:`pwd`/${SOURCE.dir} ' + \

        '--title="${MASTERBASE}" -p . -f ${MASTERBASE}')

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

# General setup

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

env.Append(BUILDERS = {'Text': Btxt, 'PDF2PS': Bpdf2ps, 'PDF': Bpdf, 'HTML': Bhtml,

        'Plucker': Bplucker, 'PS2EPI': Bps2epi, 'PS2EPIP': Bps2epip,

        'EPI2PDF': Bepi2pdf, 'EPIP2PNG': Bepip2png, 'MAN': Bman})

#### INDEX GENERATION

if 'DOINDEX' in d:

    Bindex = Builder(action = ['if test -d ${TARGET.dir}  ; then rm -r ${TARGET.dir} ; fi',

        "mkdir ${TARGET.dir}",

        "collateindex.pl -i $INDEXNODE -N -o $TARGET",

        db2htmlindexcmd,

        "mv ${MASTERBASE}-html/HTML.index ${TARGET.dir}/",

        "rm -r ${MASTERBASE}-html",

        "collateindex.pl -i $INDEXNODE -g -o $TARGET ${TARGET.dir}/HTML.index"])

    env['BUILDERS']['Index'] = Bindex

    index = env.Index('index/index.sgml', mastersgml)

    env.Depends(index, sources)

    env.Clean(index, 'index')

    deps = sources + [index]

else:

    deps = sources

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

# BUILD RULES

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

# Text

text = env.Text(mastersgml)

env.Depends(text, deps)

env.Alias('text', text)

# PDF

pdfsgml = File(mastersgml)

pdf = env.PDF(pdfsgml)

figsindoc = [x for x in recursescan(SGML_pdf_scanner, pdfsgml, env) if str(x).endswith('.pdf')]

epipdf = []

for file in figsindoc:

    pdfname = re.sub('_\d+\.pdf$', '.pdf', str(file))

    if pdfname == str(file):

        # This is not a filename that fits our pattern; add unmodified.

        epipdf.append(file)

        continue

    psfile = env.PDF2PS(source = pdfname)

    epifile = env.PS2EPI(str(file).replace(".pdf", ".epi"), psfile,

            WIDTH='6.375in', HEIGHT='8.25in')

    epipdf.append(env.EPI2PDF(source = epifile))

env.Depends(pdf, deps)

env.Depends(pdf, epipdf)

env.Alias('pdf', pdf)

env.Clean(pdf, ['jadetex.cfg', '${MASTERBASE}.aux', '${MASTERBASE}.dvi',

        '${MASTERBASE}.jtex', '${MASTERBASE}.log', '${MASTERBASE}.out',

        'jade-out.fot'])

# PS

ps = env.PDF2PS(source = pdf)

env.Alias('ps', ps)

# HTML

htmlsgml = File(mastersgml)

buildhtml = env.HTML('html/index.html', htmlsgml)

figsindoc = [x for x in recursescan(SGML_png_scanner, htmlsgml, env) if str(x).endswith('.png')]

epipng = []

for file in figsindoc:

    pdfname = re.sub('_\d+\.png$', '.pdf', str(file))

    if pdfname == str(file):

        # This is not a filename that fits our pattern; add unmodified. 

        epipng.append(file)

        continue

    psfile = env.PDF2PS(source = pdfname)

    epifile = env.PS2EPIP(str(file).replace(".png", ".pngepi"), psfile,

            WIDTH='8.5in', HEIGHT='11in')

    epipng.append(env.EPIP2PNG(source = epifile))

env.Depends(buildhtml, epipng)

env.Depends(buildhtml, deps)

pnginstalls = env.InstallAs(['html/' + str(x) for x in epipng], epipng)

env.Depends(pnginstalls, buildhtml)

html = env.Alias('html', buildhtml)

html = env.Alias('html', pnginstalls)

env.Clean(buildhtml, 'html')

# Plucker

plucker = env.Plucker(master + '.pdb', 'html/index.html')

env.Alias('plucker', plucker)

env.Default(html)