#
# Copyright (C) 2008 Carlos III University of Madrid
# This file is part of the ADA: Agile Distributed Authoring Toolkit

# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor
# Boston, MA  02110-1301, USA.

#
# List of properties to include in the file Properties.txt
#
#
# The values that appear next to the equal sign are the default values. You 
# only need to include a new definition if it is different from the default 
# value.
#
# Whenever a list of files is required, unless otherswise noted, it is a comma
# or space separated of filenames (no paths).
#
# The value ${basedir} refers to the same location where the Properties.txt 
# file is.
#
# The variables ada.home and ada.course.home are defined respectively to the
# directory where ADA is installed, and the parent directory of the current
# one where the file AdaCourseParams.xml has been found (if any).

###########################################################################
# 
#  Global ADA properties.
#
###########################################################################
# Debug level to execute of ADA 
# Possible values are 'error', 'warning', 'info', 'verbose' and 'debug'
# ada.debug.level=info

# Date/time to be set when processing the resources. 
# Relevant only when profiling with the audience attribute and for 
# exportcontrol
# ada.current.datetime=

# Value to profile the revision attribute in XML
# ada.profile.revision=

###########################################################################
# 
#  Apply a XSL stylesheet to a set of XML files.
#
###########################################################################
# Name of the XSLT processor executable
# xsltproc.exec=xsltproc

# Debug level to apply to these rules (see ada.debug.level)
# xsltproc.debug.level=${ada.debug.level}

# Directory where the sources are taken
# xsltproc.src.dir=${basedir}

# Directory where the produced files are created
# xsltproc.dst.dir=${basedir}

# Full path to the stylesheet file
# xsltproc.style.file=${ada.home}/ADA_Styles/DocbookProfile.xsl

# Output file has the same name as the source but the extension is replaced 
# by this value
# xsltproc.output.format=.html

# Extra arguments to pass to the XSLT processor
# xsltproc.extra.args=

# Source file names (no path, it is xsltproc.src.dir)
# xsltproc.files=

# Source file names (no path) to process in multilingual mode
# xsltproc.multilingual.files=

# An additional stylesheet to combine with xsltproc.style.file
# mergestyles.master.style=

# Defaul language to consider when processing documents
# xsltproc.profile.lang=

###########################################################################
# 
#  Produce a figure from an Xfig file
#
###########################################################################
# Name of the executable to transform *.xfig files
# xfig.exec=fig2dev

# Debug level to apply to these rules (see ada.debug.level)
# xfig.debug.level=${ada.debug.level}

# Directory where the sources are taken
# xfig.src.dir=${basedir}

# Directory where the produced files are created
# xfig.dst.dir=${basedir}

# Format of the output file (see fig2dev for options)
# xfig.output.format=png

# Border to insert around image
# xfig.border=2

# Smooth factor when exporting to bitmat format
# xfig.smooth=4

# Extra arguments to pass to fig2dev
# xfig.extra.args=

# Source file names (no path, it is xfig.src.dir)
# xfig.files=

###########################################################################
# 
#  Translate Inkscape files to PNG, EPS, etc.
#
###########################################################################
# Name of the inkscape executable
# inkscape.exec=inkscape

# Debug level to apply to these rules (see ada.debug.level)
# inkscape.debug.level=${ada.debug.level}

# Directory where the sources are taken
# inkscape.src.dir=${basedir}

# Directory where the produced files are created
# inkscape.dst.dir=${basedir}

# Comma separated list of formats to produce (e.g.: png,eps,ps,pdf).
# No whitespaces should appear in the middle.
# inkscape.output.format=png

# Source file names (no path, it is inkscape.src.dir)
# inkscape.files=

###########################################################################
# 
#  Post-process images (resize, crop, etc.) with convert.
#
###########################################################################
# Name of the executable to manipulate images
# convert.exec=convert

# Debug level to apply to these rules (see ada.debug.level)
# convert.debug.level=${ada.debug.level}

# Directory where the sources are taken
# convert.src.dir=${basedir}

# Directory where the produced files are created
# convert.dst.dir=${convert.src.dir}

# Geometry to convert image (wxh)
# convert.geometry=

# Suffix to add to the produced file
# convert.suffix=${convert.geometry}

# Crop option -crop widthxheight+x+y
# convert.crop=

# Format to translate the image
# convert.format=png

# Source file names (no path, it is convert.src.dir)
# convert.files=

###########################################################################
# 
#  Process files using the Gimp translator.
#
###########################################################################
# Name of the Gimp executable
# gimp.exec=gimp

# Debug level to apply to these rules (see ada.debug.level)
# gimp.debug.level=${ada.debug.level}

# Directory where the sources are taken
# gimp.src.dir=${basedir}

# GIMP script file to use
# gimp.script.file=${ada.home}${file.separator}AntImports${file.separator}xcftopng.scm

# Source file names (no path, it is gimp.src.dir)
# gimp.files=

###########################################################################
# 
#  Produce PDF n-up files given a normal PDF file
#
###########################################################################
# Name of the executable to use
# pdfnup.exec=pdfnup

# Debug level to apply to these rules (see ada.debug.level)
# pdfnup.debug.level=${ada.debug.level}

# Directory where the sources are taken
# pdfnup.src.dir=${basedir}

# Directory where the produced files are created
# pdfnup.dst.dir=${pdfnup.src.dir}

# How to organize the pages in a sheet
# pdfnup.nup.option=1x2

# Source file names (no path, it is pdfnup.src.dir)
# pdfnup.files=

###########################################################################
# 
#  Translate Postscript files to PDF
#
###########################################################################
# Name of the executable used for the translation
# ps2pdf.exec=ps2pdf

# Debug level to apply to these rules (see ada.debug.level)
# ps2pdf.debug.level=${ada.debug.level}

# Directory where the sources are taken
# ps2pdf.src.dir=${basedir}

# Directory where the produced files are created
# ps2pdf.dst.dir=${ps2pdf.src.dir}

# Source file names (no path, it is ps2pdf.src.dir)
# ps2pdf.files=

###########################################################################
# 
#  Translate MSF files to PDF (Experimental!)
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# msf2pdf.debug.level=${ada.debug.level}

# Directory where the sources are taken
# msf2pdf.src.dir=${basedir}

# Source file names (no path, it is msf2pdf.src.dir)
# msf2pdf.files=

###########################################################################
# 
#  Export files produced in the current directory
#  
#  These variables control if certain files are copied to a different location.
#  
#  The copy is actually performed only if the exportcontrol.check variable is
#  true. If exportcontrol.check is not set or set to false, the export is not
#  executed. The value of this variable can be controled either directly, with
#  a date/time window or if a given value is contained in a previously given
#  profile (set of semi-colon separated strings)
#  
#  See the following section for a detailed description of the
#  exportcontrol.check mechanism.
#
###########################################################################
# Debug level for the export process (see ada.debug.level)
# export.debug.level=${ada.debug.level}

# Directory where the sources are taken
# export.src.dir=${basedir}

# Directory where the produced files are created
# export.dst.dir=${basedir}

# Source file names (no path, it is export.src.dir)
# export.files=

###########################################################################
# 
#  Given the following properties:
#  
#  exportcontrol.begin: Date/time when the window of validity begins
#  exportcontrol.end: Date/time when the window of validity ends
#  exportcontrol.now: Date/time to be considered as the actual one
#  exportcontrol.date.format: A SimpleDateFormat pattern to manipulate 
#                             previous vars 
#  exportcontrol.open: Second gate that is taken into account
#  exportcontrol.profile.revision: Revision string to enable the processing of
#                                  this dir.
#  exportcontrol.profile.revision.value: Value to check if present in the 
#                                        previous variable. 
#  exportcontrol.check: True if the Export is allowed to go.
#
#  The exportcontrol target computes the value of the exportcontrol.check
#  variable. This variable is set to true if the conjuntion of the following
#  conditions is satisfied:
#
#  * Current time is after exportcontrol.begin (if not empty)
#  * Current time is before exportcontrol.end (if not empty)
#  * exportcontrol.open is equal to "true" (its default value)
#  * exportcontrol.profile.revision is not empty and contains the 
#  * exportcontrol.profile.revision.value (which must be non empty as well)
#  
#  If all these conditions are true, then the variable exportcontrol.check is
#  true.
#
#  This functionality is conceived to offer a rich and flexible way to control
#  if the export rule needs to be executed. Several scenarios are possible.
#  
#  - By using simply the begin and end vars, the export is executed within a
#    certain time window
#
#  - By using the "open" var, a binary control is allowed (true/false)
#
#  - By using profile.revision and profile.revision.value, the export is done
#  when the value is contained in the revision. This allows for a revision
#  string to contain multiple values that enable different export rules at
#  different locations.
###########################################################################
# Debug level for the decission if export is allowed
# exportcontrol.debug.level=${ada.debug.level}

# Date/time when validity window opens
# exportcontrol.begin=

# Date/time when validity window closes
# exportcontrol.end=

# Time to consider as actual time
# exportcontrol.now=${ada.current.datetime}

# Date/time format enforced on variables
# exportcontrol.date.format=yyyy-MM-dd'T'HH:mm:ss

# Set the validity window directly open (true/false)
# exportcontrol.open=true

# List of semicolon separated values in revision to open the export
# exportcontrol.profile.revision=${ada.profile.revision}

# Given revision value to compare and decide if export is open
# exportcontrol.profile.revision.value=

###########################################################################
# 
#  Given the following properties:
#  
#  subrecursive.dirs:       List of directories to call recursively
#  subrecursive.dst.dir:    Dir to receive the exported material
#  subrecursive.dirs.nodst: Dirs to call recursively but with no dst dir
#  subrecursive.target:     Target to execute in those directories
#  
#  Execute target subrecursive.target in the directories given in the variables
#  subrecursive.dirs and subrecursive.dirs.nodst. For those dirs in
#  subrecursive.dirs, the files exported by the remote directory are copied in
#  the location specified by subrecursive.dst.dir. In those directories
#  included in subrecursive.dir.ndst, the files exported by the remote
#  directory are copied as specified by the variable export.dst.dir in that
#  directory.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# subrecursive.debug.level=${ada.debug.level}

# Dirs to execute and export resources to ${subrecursive.dst.dir}
# subrecursive.dirs=

# Location where the exported resources in ${subrecursive.dirs} are copied
# subrecursive.dst.dir=${basedir}

# Dirs to execute and export as specified in their Properties.txt file
# subrecursive.dirs.nodst=

# Production rule executed in the remote directories
# subrecursive.target=

###########################################################################
# 
#  Copy copyfiles.files in copy.src.dir to copyfiles.dst.dir. The copy is
#  performed only if the two dirs are non empty.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# copyfiles.debug.level=${ada.debug.level}

# Directory where the sources are taken
# copyfiles.src.dir=${basedir}

# Directory where the produced files are created
# copyfiles.dst.dir=${basedir}

# Source file names (no path, it is copyfiles.src.dir)
# copyfiles.files=

###########################################################################
# 
#  Invoke several times the Docbook to HTML functionality to generate a
#  regular HTML document, a document with the section/phrase/note with the
#  attribute condition=solution, a document with the section/phrase/note with
#  the attribute condition=professorguide, and a document with a form to 
#  submit the answers derived from the elements with the elements with
#  condition=submit.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# exercisesubmit.debug.level=${ada.debug.level}

# Directory where the sources are taken
# exercisesubmit.src.dir=${basedir}

# Directory where the produced files are created
# exercisesubmit.dst.dir=${basedir}

# Stylesheet to obtain hand-out, solutions and professor guide
# exercisesubmit.style.file=${ada.home}/ADA_Styles/ExerciseSubmit.xsl

# Stylesheet to apply to the submission page
# exercisesubmit.submit.style.file=${ada.home}/ADA_Styles/Submit.xsl

# Extra options to pass to the XSLT processor
# exercisesubmit.extra.args=

# Output file has the same name as the source but the extension is replaced 
# by this value
# exercisesubmit.output.format=.html

# Source file names (no path, it is exercisesubmit.src.dir)
# exercisesubmit.files=

# Source file names (no path) to process in  multilingual mode
# exercisesubmit.multilingual.files=

# An additional stylesheet to combine with exercisesubmit.style.file
# mergestyles.master.style=

###########################################################################
# 
#  Produce a pdf file directly from a latex file using pdflatex
#
###########################################################################
# Name of the LaTeX processor executable
# pdflatex.exec=pdflatex

# Debug level to apply to these rules (see ada.debug.level)
# pdflatex.debug.level=${ada.debug.level}

# Directory where the sources are taken
# pdflatex.src.dir=${basedir}

# Directory where the produced files are created
# pdflatex.dst.dir=${pdflatex.src.dir}

# Source file names (no path, it is pdflatex.src.dir)
# pdflatex.files=

# Extra arguments to pass to the LaTeX processor
# pdflatex.extra.args=

###########################################################################
# 
#  Execute the LaTeX processor over a set of files
#
###########################################################################
# Name of the LaTeX processor executable
# latex.exec=latex

# Debug level to apply to these rules (see ada.debug.level)
# latex.debug.level=${ada.debug.level}

# Directory where the sources are taken
# latex.src.dir=${basedir}

# Directory where the produced files are created
# latex.dst.dir=${latex.src.dir}

# Source file names (no path, it is latex.src.dir)
# latex.files=

# Extra arguments to pass to the LaTeX processor
# latex.extra.args=

###########################################################################
# 
#  Execute the dvips over a set of given DVI files
#
###########################################################################
# Name of the dvips executable
# dvips.exec=dvips

# Debug level to apply to these rules (see ada.debug.level)
# dvips.debug.level=${ada.debug.level}

# Directory where the sources are taken
# dvips.src.dir=${basedir}

# Directory where the produced files are created
# dvips.dst.dir=${basedir}

# Source file names (no path, it is dvips.src.dir)
# dvips.files=

###########################################################################
# 
#  Produce a pdf file directly from a Docbook file by translating it first to
#  LaTeX
#
###########################################################################
# Name of the Docbook to PDF processor executable
# dblatex.exec=dblatex

# Debug level to apply to these rules (see ada.debug.level)
# dblatex.debug.level=${ada.debug.level}

# Directory where the sources are taken
# dblatex.src.dir=${basedir}

# Directory where the produced files are created
# dblatex.dst.dir=${basedir}

# Source file names (no path, it is dblatex.src.dir)
# dblatex.files=

# Extra arguments to pass to the LaTeX processor
# dblatex.extra.args=

# If true, default dblatex behavior, 
# otherwise ada-flavored behavior (supress version page)
# dblatex.compliant.mode=

###########################################################################
# 
#  Given one single file either in exam.file or exam.multilingual.file, 
#  process it to obtain the HTML rendering of the file as an exam, with 
#  logos, name box, instructions, etc.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# exam.debug.level=${ada.debug.level}

# Directory where the sources are taken
# exam.src.dir=${basedir}

# Directory where the produced files are created
# exam.dst.dir=${exam.src.dir}

# Directory where equation image files are created
# exam.equation.dir=equations

# Output file has the same name as the source but the extension is replaced 
# by this value
# exam.output.format=.html

# Extra arguments to pass to the XSLT processor
# exam.extra.args=

# Source file name (no path, it is xsltproc.src.dir)
# exam.file=

# Source file name (no path) to process in multilingual mode
# exam.multilingual.file=

# Full path to the stylesheet file to apply
# exam.style.file=${ada.home}/ADA_Styles/Exam.xsl

###########################################################################
# 
#    Given one single Docbook file in a specific format either in testexam.file
#    or testexam.multilingual.file, process it to obtain two versions of the
#    true/false or Multiple choice questions with the shuffled questions. It
#    also produces multiple auxiliary files such as solutions, shuffle
#    solutions, version with stats, etc.
#
#    Warning: VERY specific functionality. The Docbook file must have a very
#    special structure based on qandaset, qandaentry, etc.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# testexam.debug.level=${ada.debug.level}

# Directory where the source is taken
# testexam.src.dir=${basedir}

# Directory where the produced files are created
# testexam.dst.dir=${testexam.src.dir}

# Directory where equation image files are created
# testexam.equation.dir=equations

# Output file has the same name as the source but the extension is replaced 
# by this value
# testexam.output.format=.html

# Extra arguments to pass to the XSLT processor
# testexam.extra.args=

# Source file name (no path, it is xsltproc.src.dir)
# testexam.file=

# Source file name (no path) to process in multilingual mode
# testexam.multilingual.file=

# Full path to the stylesheet file to apply
# testexam.style.file=${ada.home}/ADA_Styles/Exam.xsl

###########################################################################
# 
#  Apply the Rss stylefile to the Docbook files specified in rss.files. This
#  Docbook file needs to have a very specific structure to derive from that an
#  RSS channel suitable to be published. The rule also creates an HTML
#  rendering of the information contained in the RSS file to facilitate its
#  review with a browser to detect errors. The style is prepared to include
#  also the itunes set of labels. Therefore, the produced channel can be
#  processed by the itunes client application.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# rss.debug.level=${ada.debug.level}

# Directory where the sources are taken
# rss.src.dir=${basedir}

# Directory where the produced files are created
# rss.dst.dir=${rss.src.dir}

# Output file has the same name as the source but the extension is replaced 
# by this value
# rss.output.format=_rss.xml

# Extra arguments to pass to the XSLT processor
# rss.extra.args=

# Source file names (no path, it is rss.src.dir)
# rss.files=

# Source file names (no path) to process in multilingual mode
# rss.multilingual.files=

# Full path to the stylesheet file
# rss.style.file=${ada.home}/ADA_Styles/Rss.xsl

# Full path to the stylesheet file to produce the HTML
# rss.style.file.tohtml=${ada.home}/ADA_Styles/RssToHtml.xsl

###########################################################################
# 
#  Executes a target in an ANT build file. This is to provide the opportunity
#  to include any additional and arbitrary processing in a directory.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# extraant.debug.level=${ada.debug.level}

# Directory where the ANT file is taken
# extraant.src.dir=${basedir}

# Ant file containing the additional rules to apply
# extraant.file=build.xml

# The target to be executed BEFORE all ADA targets 
# except copyfiles and subrecursive.
# extraant.pretarget=

# The target to be executed AFTER all ADA targets 
# except export.
# extraant.posttarget=

# The cleaning target to be executed BEFORE all ADA targets 
# except export.clean.
# extraant.pretarget.clean=

# The target to be executed AFTER all ADA targets 
# except copyfiles.clean and subrecursive.clean.
# extraant.posttarget.clean=

###########################################################################
# 
#  Clean files that are produced and NOT removed by the cleaning facilities of
#  the other rules. The following variables should be used only when some extra
#  files or directories are not cleaned by any other means.
#
#  WARNING: The targets using these variables all DELETE files. Use with
#  caution.
#
###########################################################################
# Debug level to apply to these rules (see ada.debug.level)
# clean.debug.level=${ada.debug.level}

# Files to delete with respect to the current dir. Only       full names allowed. No * or ?.
# clean.files=