Conteúdo
/opt/fop/{build,lib}
; Os componentes JAI
incluem libmlib_jai.so, jai_codec.jar, jai_core.jar e
mlibwrapper_jai.jar
O pacote FOP (Formatting Objects Processor) contém um formatador de impressão controlado por objetos de formatação XSL (XSL-FO). É uma aplicação Java que lê uma árvore de objetos de formatação e renderiza as páginas resultantes em uma saída especificada. Os formatos de saída atualmente suportados incluem PDF, PCL, PostScript, SVG, XML (representação de árvore de área), impressão, AWT, MIF e texto ASCII. O alvo de saída principal é PDF.
Esse pacote é conhecido por construir e funcionar corretamente usando uma plataforma LFS 12.2.
Transferência (HTTP): https://archive.apache.org/dist/xmlgraphics/fop/source/fop-2.9-src.tar.gz
Soma de verificação MD5 da transferência: f7537ca7f2e16971fa99c8bb0dad62c7
Tamanho da transferência: 20 MB
Espaço em disco estimado exigido: 333 MB (incluindo arquivos baixados para o diretório do(a) usuário(a))
Tempo de construção estimado: 0,9 UPC
Transferências Adicionais Exigidas:
Sistema de construção Maven:
https://archive.apache.org/dist/maven/maven-3/3.9.4/binaries/apache-maven-3.9.4-bin.tar.gz
0698a533397eda60cbebcc0fb68ae842
9,0 MB (adicionalmente, cerca de 90 MB são baixados para o
diretório de construção do(a) usuário(a))
Pacotes recomendados
Padrões de hifenização Objects for Formatting Objects
(OFFO):
https://downloads.sourceforge.net/offo/2.2/offo-hyphenation.zip
bf9c09bf05108ef9661b8f08d91c2336
862 KB
um ambiente gráfico (para executar testes), Ferramentas de E/S de Imagens JAI e JEuclid
Certifique-se de que $JAVA_HOME
esteja
configurada corretamente antes de iniciar a construção. Para
construir as classes de extensão JIMI
SDK e (ou) XMLUnit,
certifique-se de que os arquivos .jar
correspondentes possam ser encontrados por intermédio da variável
de ambiente CLASSPATH
.
Copie os padrões de hifenização XML para a árvore do fonte do fop executando os seguintes comandos:
unzip ../offo-hyphenation.zip && cp offo-hyphenation/hyph/* fop/hyph && rm -rf offo-hyphenation
A partir do fop-2.5, o sistema de construção Maven é exigido. Nós usamos o binário fornecido pelo Apache, que instalamos em um local temporário:
tar -xf ../apache-maven-3.9.4-bin.tar.gz -C /tmp
O comando javadoc fornecido com o OpenJDK 10 e posterior tornou-se muito mais rigoroso que as versões anteriores em relação à conformidade dos comentários Javadoc no código-fonte para HTML. A documentação do FOP não atende a esses padrões, de forma que as verificações de conformidade tem de ser desabilitadas. Isso pode ser feito com o seguinte comando:
sed -i '\@</javad@i\ <arg value="-Xdoclint:none"/>\ <arg value="--allow-script-in-comments"/>\ <arg value="--ignore-source-errors"/>' \ fop/build.xml
Compile o fop executando os seguintes comandos:
cd fop && LC_ALL=en_US.UTF-8 \ PATH=$PATH:/tmp/apache-maven-3.9.4/bin \ ant all javadocs && mv build/javadocs .
Esse pacote vem com uma suíte de teste, mas a infraestrutura java instalada neste livro não permite executá-la.
Agora, instale o Fop como o(a)
usuário(a) root
:
install -v -d -m755 -o root -g root /opt/fop-2.9 && cp -vR build conf examples fop* javadocs lib /opt/fop-2.9 && chmod a+x /opt/fop-2.9/fop && ln -v -sfn fop-2.9 /opt/fop
A última coisa a fazer é limpar o que fizemos:
rm -rf /tmp/apache-maven-3.9.4
sed -i ... build.xml: Isso adiciona três chaves ao comando javadoc, evitando que alguns erros ocorram durante a construção da documentação.
export LC_ALL=en_US.UTF-8: o compilador falha se usar uma localidade ASCII.
ant target
: Isso lê o arquivo
build.xml
e constrói o alvo:
compile
compila os fontes java;
jar-main
gera arquivos jar;
jar-hyphenation
gera os padrões de
hifenização para o FOP; junit
executa
os testes junit; e javadocs
constrói a documentação. O alvo
all
executa tudo do acima.
ln -v -sf fop-2.9
/opt/fop: Isso é opcional e cria um link simbólico
de conveniência, de forma que $FOP_HOME
não tenha que ser mudada cada vez que exista uma mudança na versão
do pacote.
Usar fop para processar alguns FOs grandes (incluindo o FO derivado dos fontes XML do BLFS) pode levar a erros de memória. A menos que você adicione um parâmetro ao comando java usado no conjunto de comandos sequenciais fop, você possivelmente receba mensagens semelhantes a esta mostrada abaixo:
Exception in thread "main"
java.lang.OutOfMemoryError: Java heap space
Para evitar erros como esse, você precisa passar um parâmetro
extra para o comando java usado no conjunto de
comandos sequenciais fop. Isso pode ser feito
criando-se um ~/.foprc
(que é
carregado pelo conjunto de comandos sequenciais fop) e adicionando-se o
parâmetro à variável de ambiente FOP_OPTS
.
O conjunto de comandos sequenciais fop procura por uma variável de
ambiente FOP_HOME
para localizar as
bibliotecas de classes do fop.
Você também pode criar essa variável usando o arquivo
~/.foprc
. Crie um arquivo
~/.foprc
usando os seguintes
comandos:
cat > ~/.foprc << "EOF"
FOP_OPTS="-Xmx<RAM_Instalada>
m"
FOP_HOME="/opt/fop"
EOF
Substitua <RAM_Instalada>
por um
número que represente a quantidade de RAM instalada em teu
computador (em megabytes). Um exemplo seria FOP_OPTS="-Xmx768m"
.
Para incluir o conjunto de comandos sequenciais fop em teu caminho, atualize o
perfil abrangente a todo o sistema com o seguinte comando como
o(a) usuário(a) root
:
cat > /etc/profile.d/fop.sh << "EOF"
# inicia /etc/profile.d/fop.sh
pathappend /opt/fop
# Termina /etc/profile.d/fop.sh
EOF
Executar fop pode
ser um tanto detalhado. O nível de registro padrão pode ser
mudado de INFO para FINEST, FINER, FINE, CONFIG, INFO, WARNING,
SEVERE, ALL ou OFF. Para fazer isso, edite o $JAVA_HOME/jre/lib/logging.properties
e mude
as entradas para .level
e
java.util.logging.ConsoleHandler.level
para o
valor desejado.
/opt/fop/{build,lib}
; Os componentes JAI
incluem libmlib_jai.so, jai_codec.jar, jai_core.jar e
mlibwrapper_jai.jar