Contenu
/opt/fop/{build,lib} ; Les composants
              JAI contiennent libmlib_jai.so, jai_codec.jar, jai_core.jar et
              mlibwrapper_jai.jar
            Le paquet FOP (Formatting Objects Processor) contient un formateur d'impression guidé par les objets de formatage XSL (XSL-FO). C'est une application Java qui lit une arborescence d'objets de formatage et qui produit les pages qui en résultent vers une sortie spécifique. Les formats de sortie actuellement supportés comprennent le PDF, PCL, PostScript, SVG, XML (représentation en arborescence de zone), print, AWT, MIF et le texte ASCII. La cible de sortie principale est le PDF.
Ce paquet est connu pour se construire correctement sur une plateforme LFS-9.1.
Téléchargement (HTTP) : https://archive.apache.org/dist/xmlgraphics/fop/source/fop-2.4-src.tar.gz
Somme de contrôle MD5 du téléchargement : e379d5916bc705b6fd3808a77f5d8478
Taille du téléchargement : 26 Mo
Estimation de l'espace disque requis : 252 Mo
Estimation du temps de construction : 0.4 SBU
Téléchargements supplémentaires requis :
                PDFBox :
                
                http://mirror.reverse.net/pub/apache/pdfbox/2.0.18/pdfbox-2.0.18.jar
                d4b837bba123ee8a4279da65c096c311
                2.6 Mo
              
                Polices PDFBox :
                
                http://mirror.reverse.net/pub/apache/pdfbox/2.0.18/fontbox-2.0.18.jar
                f7f35e37225dcb3248c199f1d603a5b0
                1.5 Mo
              
Paquets recommandés
                Les patrons de césure OFFO (Objets pour formater des
                objets) :
                
                https://downloads.sourceforge.net/offo/2.2/offo-hyphenation.zip
                bf9c09bf05108ef9661b8f08d91c2336
                862 Ko
              
Système X Window (pour lancer les tests), JAI Image I/O Tools et JEuclid
Notes utilisateur : http://wiki.linuxfromscratch.org/blfs/wiki/fop
          Assurez-vous que $JAVA_HOME est
          correctement paramétré avant de commencer la construction. Pour
          construire les classes d'extension JIMI
          SDK et XMLUnit,
          assurez-vous que les fichiers .jar
          correspondants peuvent être trouvés par la variable d'environnement
          CLASSPATH.
        
Copiez les patrons de césure XML dans l'arborescence des sources de fop en lançant les commandes suivantes :
unzip ../offo-hyphenation.zip && cp offo-hyphenation/hyph/* fop/hyph && rm -rf offo-hyphenation
La commande javadoc venant avec OpenJDK 10 et suivants est devenue plus stricte qu'avant à propos de la conformité des commentaires javadoc dans le code source vers l'HTML. La documentation de FOP ne respecte pas ces standards, aussi les tests de conformité ont été désactivés. Cela peut être fait avec la commande suivante :
sed -i '\@</javad@i\
<arg value="-Xdoclint:none"/>\
<arg value="--allow-script-in-comments"/>\
<arg value="--ignore-source-errors"/>' \
    fop/build.xml
          
            La taille de la pile indiquée dans build.xml pour construire les patrons de césure
            n'est pas suffisante. Modifiez-la en lançant :
          
sed -e '/hyph\.stack/s/512k/1M/' \
    -i fop/build.xml
          Avec OpenJDK-12.0.2, la version minimum des sources est 1.7, tandis que le système de construction de FOP spécifie la 1.6. Changez cela :
sed -e 's/1\.6/1.7/' \
    -i fop/build.xml
          
            Le fichier build.xml appelle une
            ancienne version des composants PDFBox qui ne sont plus disponibles. Copiez
            les composants PDFBox récents dans l'arborescence des
            sources :
          
cp ../{pdf,font}box-2.0.18.jar fop/lib
          Compilez fop en lançant les commandes suivantes :
cd fop && export LC_ALL=en_US.UTF-8 && ant all javadocs && mv build/javadocs .
La suite de tests junit a été lancée avec les commandes précédentes.
            Maintenant, installez Fop en
            tant qu'utilisateur root :
          
install -v -d -m755 -o root -g root /opt/fop-2.4 && cp -vR build conf examples fop* javadocs lib /opt/fop-2.4 && chmod a+x /opt/fop-2.4/fop && ln -v -sfn fop-2.4 /opt/fop
sed -i ... build.xml : Cela ajoute deux paramètres à la commande javadoc, empêchant certaines erreurs de se produire en construisant la documentation.
export LC_ALL=en_US.UTF-8 : le compilateur échoue si vous utilisez une locale ASCII.
          ant target : Ceci lit le fichier
          build.xml et construit la
          cible : compile compile les
          sources java, jar-main génère les
          archives jar, jar-hyphenation génère
          les patrons de césure pour FOP, junit
          lance les tests junit et
          javadocs construit la documentation. La
          cible all lance toutes les cibles
          précédentes.
        
          ln -v -sf fop-2.4
          /opt/fop : Ceci est facultatif et crée un lien
          symbolique pratique pour que $FOP_HOME
          n'ait pas besoin d'être changé à chaque changement de version du
          paquet.
        
Utiliser fop pour traiter de gros FO (dont les FO dérivés des sources XML de LFS) peut conduire à des erreurs de mémoire. À moins d'ajouter un paramètre à la commande java utilisée dans le script fop vous pouvez obtenir des messages similaires à ceci :
            Exception in thread "main"
            java.lang.OutOfMemoryError: Java heap space
          
            Pour éviter de telles erreurs, vous devez passer un argument
            supplémentaire à la commande java utilisée dans le script
            fop. Ceci peut se
            faire en créant un fichier ~/.foprc
            (qui est sourcé par le script fop) et en ajoutant le
            paramètre à la variable d'environnement FOP_OPTS.
          
            Le script fop
            cherche une variable d'environnement FOP_HOME pour localiser les bibliothèques de
            classe fop. Vous pouvez créer
            cette variable en utilisant le fichier ~/.foprc aussi. Créez un fichier ~/.foprc avec les commandes suivantes :
          
cat > ~/.foprc << "EOF"
FOP_OPTS="-Xmx<RAM_Installed>m"
FOP_HOME="/opt/fop"
EOF
          
            Remplacez <RAM_Installed> avec un
            nombre représentant la quantité de RAM installée dans votre
            ordinateur (en mégaoctets). Par exemple, FOP_OPTS="-Xmx768m".
          
            Pour inclure le script fop dans votre path, mettez à
            jour le profil système avec la commande suivante en tant
            qu'utilisateur root :
          
cat > /etc/profile.d/fop.sh << "EOF"
# Begin /etc/profile.d/fop.sh
pathappend /opt/fop
# End /etc/profile.d/fop.sh
EOF
          
            
              L'exécution de fop peut être assez verbeuse.
              Par défaut le niveau de journalisation est INFO et peut être
              changé en FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE,
              ALL ou OFF. Pour ce faire, éditez $JAVA_HOME/jre/lib/logging.properties et
              changez les entrées pour .leval et
              java.util.logging.ConsoleHandler.level à la
              valeur désirée.
            
/opt/fop/{build,lib} ; Les composants
              JAI contiennent libmlib_jai.so, jai_codec.jar, jai_core.jar et
              mlibwrapper_jai.jar
            Last updated on 2020-02-18 21:45:12 +0100