Automatizando diagramação de notícias com Scribus e Python

Que tal abrir um quadro de texto no Scribus, rodar um script e obter rapidamente uma matéria jornalística montada, com foto, legenda e crédito da foto? E que tal levar todo um sistema editorial num pen drive? (Editor de texto, editor de fotos, paginador, saída em PDF/X-3). E que tal tudo isto com ferramentas gratuitas e de código aberto?

Essa foi minha idéia ao aprender Python e Scribus Scripting. Levar um sistema editorial de categoria profissional num pen drive. Instalei o X-Scribus, um Scribus especial para pen drives. Ele já tem o Ghostscript, Python e tudo o que é necessário para rodar em qualquer computador com Windows. Existe mais uma versão, o Portable Scribus 1.3.3.12, mas ele me apresentou problemas na visualização de impressão: não permitia a seleção de chapas (plates) individuais — ciano, magenta, amarelo ou preto, coisa importante para o ensino de seleção de cores.

Imagens

Para automatizar o Scribus, uma das primeiras providências é permitir ao Python do Scribus a manipulação de imagens. Para isso, usei PIL (Python Image Library).

No Linux, o Scribus usa o Python normal do sistema. Instale as bibliotecas PIL da forma usual de seu sabor de Linux. No Windows, o instalador do Python Image Library precisa de certas chaves no registro do Windows para saber em que lugar está instalado o sistema Python. Eu defini estas chaves para a pasta do Scribus, que é onde roda o interpretador Python no Windows. Ao baixar o PIL, cuide as versões: no Scribus versão 1.3.3 estável,  o Python é versão 2.4. No Scribus 1.3.4 Beta, o Python é versão 2.5.

Para registrar o Python do Scribus, o meu arquivo reg tem o seguinte:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Python]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4\InstallPath]
@="c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\"
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4\PythonPath]
@="c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\Lib\\;c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\DLLs\\"

[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5\InstallPath]
@="c:\\SD\\Bin\\Scribus\\"
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5\PythonPath]
@="c:\\SD\\Bin\\Scribus\\Lib\\;c:\\SD\\Bin\\Scribus\\DLLs\\"

Se você precisar registrar, copie este código, mude os caminhos para as pastas para casarem com seu sistema (em vermelho) e grave como texto simples, com a terminação .reg. Dê dois clics no arquivo para registrar as chaves no registro do Windows.

Depois de instalado o PIL, se as bibliotecas de imagem forem corretamente reconhecidas, não haverá erros ao rodar o script de montagem de matérias.

Repare que instalei tudo usando o HD. Depois de tudo instalado, copiei a pasta inteira para o pen drive. No caso, copiei a pasta X-Scribus para a pasta PortableApps (que é o padrão de aplicações portáteis que uso) do pen drive.

A seguir coloquei o script na pasta de scripts do Scribus, que no meu caso coloquei em c:\SD\PortableApps\X-Scribus\Bin\Scribus\Scripts.

No início do script existem algumas variáveis que podem ser modificadas pelo usuário, como a largura da valeta (gutter, espaço entre as colunas).

O script funciona assim: desenhe um retângulo ou selecione um. Vá ao menu Scripts, procure e rode este script. Aparecem diversas janelinhas de diálogo perguntando:

• Em quantas colunas será dividida a área de colunas da matéria? Escolha 2 ou mais.
• Qual a largura do espaço entrecolunas (gutter ou valeta)?
• Qual o corpo (tamanho) do sobretítulo?
• Qual o corpo do subtítulo?
• Quantas fotos tem a matéria? Por enquanto, o script só aceita uma.
• Quantas colunas ocupa a foto (de largura)? A foto é posicionada ao lado da primeira coluna de texto e agrupada com quadros para legenda e para crédito. As bibliotecas PIL são usadas para isto. As funções PIL medem a foto escolhida e o script calcula a altura do quadro de foto. Mais tarde, uso a tecla CTRL + Y para abrir o editor de texto interno do Scribus para editar os dois elementos (como se faz no Adobe inDesign). Na primeira linha vai a legenda e na linha de baixo vai o crédito.

Falta fazer as rotinas para manipular fotos no caso de uma matéria em apenas uma coluna. Se você escolher uma coluna, a foto será montada ao lado da matéria.

A seguinte seqüência de quadros mostra como funciona o script.

O quadro para título vai agrupado com o quadro para as colunas. Para editar o texto, uso a tecla CTRL + Y. Para importar texto, seleciono o grupo e uso CTRL + D (como no PageMaker e InDesign).

#!/usr/bin/env python2.4
# -*- coding: utf-8 -*-

"""
Build a newspaper story
By prof. MS. José Antonio Meira da Rocha
mailto:joseantoniorocha@gmail.com
http://meiradarocha.jor.br
Licença GPL
"""

import sys

###########################
# Assegura que está rodando
# dentro do Scribus
###########################
try:
 import scribus
except ImportError,err:
 print "This Python script is written for the Scribus scripting interface."
 print "It can only be run from within Scribus."
 sys.exit(1)

# Carrega algumas constantes Scribus usadas neste script
from scribus import UNIT_POINTS, LINE_SOLID, JOIN_MITTER, BUTTON_OK, ICON_WARNING

#########################
# USER IMPORTS GO HERE  #
#########################

#####################################
# Usuário pode mudar estes parâmetros
#####################################
numeroDeColunasPadrao = "3"
entrecolunasPadrao = "14.1732"  # 5mm
corpoDeTituloPadrao = "48"
corpoPadraoDoSobretitulo = "18"
proporcaoDeEntrelinha = 1.0

##########################################
# Constantes que NÃO devem ser modificadas
AROUND_FRAME = 1
BOUNDING_BOX = 2
CONTOUR_LINE = 3 

######################
# Locale strings
# Textos para tradução
######################
pedirParaAbrirDoc = "<h2>Abra um documento</h2>" \
 +"Ops! Abra um documento antes \nde rodar este comando."
pedirParaAbrirQuadro = "<h2>Desenhe um quadro</h2>\n" \
 +"Ops! Desenhe ou selecione um <b>quadro</b>\n" \
 +"na área em que você quer montar a matéria."
#
labelDeColunas = 'Colunas' #Number of columns
mensagemDeColunas = '<h2>Colunas</h2><p>Quantas colunas?</p>'  #How many columns?
#
labelDeCorpoDeTitulo = "Corpo do título" #quadroDeTitulo
mensagemDeCorpoDeTitulo = "<h2>Corpo do título</h2><p>Qual&nbsp;o&nbsp;corpo&nbsp;do&nbsp;título?</p>" #What the quadroDeTitulo size?
#
labelDeValetas = "Valetas"
mensagemDeValetas = "<h2>Valetas</h2><p>Qual&nbsp;o&nbsp;tamanho&nbsp;da&nbsp;valeta?\n(Espaço&nbsp;entrecolunas)"
#
labelDeSobretitulo = "Corpo do sobretítulo"
mensagemDeSobretitulo = "<h2>Corpo do sobretítulo</h2>\n<p><b>Qual&nbsp;o&nbsp;corpo&nbsp;do&nbsp;sobretítulo?</b>\n" \
 + "(coloque&nbsp;zero&nbsp;se&nbsp;não&nbsp;houver&nbsp;sobretítulo)"
#
textFlowsAroundFrame = 'Abra a imagem'
filtroDeImagens = 'Arquivos de imagens (*.jpg *.png *.tiff *.tif)'
#
labelDeImportarTexto = "Abra o texto"
filtroDeArquivosTexto = "Arquivos de texto (*.txt *.html)"
#
labelDeLarguraDeImagem = "Largura da imagem"
mensagemDeLarguraDeImagem = "<h2>Largura&nbsp;da&nbsp;Imagem</h2>\nQuantas&nbsp;colunas&nbsp;a&nbsp;imagem&nbsp;ocupará?"
larguraDeColunasPadrao = "1"
#
labelDeImagem = "Quantas fotos"
mensagemDeImagem = "<h2>Quantas fotos?</h2>\n<p>Quantas&nbsp;fotos&nbsp;a&nbsp;matéria&nbsp;tem?"
numeroDeImagemPadrao = "1"

labelDeQuadroDeTitulo = "Montar matéria"

labelErroDeImportacao = "Não importei o arquivo"
msgDeErroDeImportacao = "<h2>Não importei o arquivo</h2><p>Desculpe-me, não importei o arquivo por algum detalhe de formato incompatível ou arquivo não encontrado. <b>Sem problema</b>, tente de novo manualmente nais tarde.</p>"

labelAbreDoc = "Abra um documento"
dizAbreDoc = "<h2>Abra um documento</h2><p>Por favor, este comando exige que você abra um documento.</p>"

####################
# End Locale strings
####################

try:
 import Image
except ImportError,err:
 print "This Python script is written for the PIL graphic interface."
 print "It should be instaled in Scribus Python tree."
 sys.exit(1)

def pedeNumeroDeColunas():
 """Pede número de colunas de texto que terá a matéria"""

 numeroDeColunas = scribus.valueDialog(
  labelDeColunas,
  mensagemDeColunas,
  numeroDeColunasPadrao
 )
 if not numeroDeColunas:
  sys.exit()
 try:
  return int(numeroDeColunas)
 except:
  return numeroDeColunasPadrao

def pedeCorpoDoTitulo():
 """Pede tamanho das letras (corpo) do título, em pontos tipográficos."""
 corpoDeTitulo = scribus.valueDialog(labelDeCorpoDeTitulo, mensagemDeCorpoDeTitulo, corpoDeTituloPadrao)
 if not corpoDeTitulo:
  sys.exit()
 try:
  return float(eval(corpoDeTitulo))
 except:
  return float(corpoDeTituloPadrao)

def pedeEntrecolunas():
 """Pede o espaço entre as colunas de texto (gitter, valeta), em pontos tipográficos"""
 entrecolunas = scribus.valueDialog(labelDeValetas, mensagemDeValetas, entrecolunasPadrao)
 if not entrecolunas:
  sys.exit()
 try:
  return float(entrecolunas)
 except:
  return entrecolunasPadrao

def pedeCorpoDoSobretitulo():
 """Pede tamanho das letras (corpo) do sobretítulo, em pontos tipográfico"""
 corpoDoSobretitulo = scribus.valueDialog(labelDeSobretitulo, mensagemDeSobretitulo, corpoPadraoDoSobretitulo)
 if not corpoDoSobretitulo:
  sys.exit()
 try:
  return float(eval(corpoDoSobretitulo))
 except:
  return float(corpoPadraoDoSobretitulo)

def pedeImagem():
 """Pergunta por fotos na matéria"""
 temImagem = scribus.valueDialog(labelDeImagem, mensagemDeImagem, numeroDeImagemPadrao)
 if not temImagem:
  sys.exit()
 try:
  return temImagem
 except:
  return temImagem

def pedeTexto(quadroDeTitulo):
 """Load text file"""

 sourceCharcode = 'iso-8859-15' # change it to ur language
 # Diálogo de procurar arquivo
 textFile = scribus.fileDialog(labelDeImportarTexto,filtroDeArquivosTexto,"", haspreview=1, issave=True) # issave=False shows "Save" button
 if textFile:
  try:
   t = open(textFile).read()
   t = unicode(t, sourceCharcode)
  except:
   scribus.messageBox(
    labelErroDeImportacao,
    msgDeErroDeImportacao,
    ICON_WARNING,
    BUTTON_OK
   )
   t=""
   return t
 else:
  t=""

 return t

def flow(frame,mode):
 """Compatibiliza Scribus 1.3.3 e 1.3.4"""
 try:
  scribus.textFlowsAroundFrame(frame, mode) # Scribus 1.3.3
 except:
  scribus.textFlowMode(frame, mode)   # Scribus 1.3.4

def pedeColunasDeImagem():
 """Solicita a quantidade de colunas que a foto vai ocupar."""
 colunasDaFoto = scribus.valueDialog(
 labelDeLarguraDeImagem,
 mensagemDeLarguraDeImagem,
 larguraDeColunasPadrao
 )
 if not colunasDaFoto:
  sys.exit()
 try:
  return float(eval(colunasDaFoto))
 except:
  return float(larguraDeColunasPadrao)

def pedeFoto():
 """ Escolhe arquivo de foto
 scribus.fileDialog('caption', ['filter', 'defaultname',haspreview, issave])"""

 # Abre diálogo para escolha de arquivo
 arquivoDaFoto = scribus.fileDialog(
  textFlowsAroundFrame,
  filtroDeImagens,
  "",  # Nome default do arquivo
  haspreview=1,
  issave=True
 )

 # Tenta abrir arquivo fornecido
 try:
  foto = Image.open(arquivoDaFoto)  # uso da biblioteca PIL
 except:
  scribus.messageBox(
   labelErroDeImportacao,
   msgDeErroDeImportacao,
   ICON_WARNING,
   BUTTON_OK
  )
  foto = ""
 return foto,arquivoDaFoto

def montaQuadroDaFoto(quadroDeColunas):
 """Build a image frame with credit and legenda
 based in text frame number of columns"""

 #
 foto,arquivoDaFoto = pedeFoto()
 try:
  larguraDaFoto,alturaDaFoto = foto.size  # para pegar o tamanho da imagem em pixels
 except:
  larguraDaFoto,alturaDaFoto = 4,3  # Se não conseguir, define proporção 4 por 3

 # Escolhe quantas colunas a foto vai "abrir"
 colunasDaFoto = pedeColunasDeImagem()

 # Calcula largura da foto
 entrecoluna = scribus.getColumnGap(quadroDeColunas)
 colunasDeTexto = scribus.getColumns(quadroDeColunas)

 # Define o tamanho da foto
 larguraDoQuadroDeColunas,alturaDoQuadroDeColunas = scribus.getSize(quadroDeColunas)

 larguraDaColuna = (larguraDoQuadroDeColunas - (entrecoluna*(colunasDeTexto-1))) / colunasDeTexto

 # calcula posição da imagem
 quadroDeColunasEsquerda, quadroDeColunasTopo = scribus.getPosition(quadroDeColunas)

 # Posiciona foto a partir da segunda coluna de texto
 quadroDaFotoEsquerda = quadroDeColunasEsquerda + larguraDaColuna + entrecoluna
 quadroDaFotoTopo = quadroDeColunasTopo

 # Calcula largura e altura da imagem
 larguraDoQuadroDaFoto = colunasDaFoto * larguraDaColuna + (entrecoluna * (colunasDaFoto - 1))
 alturaDoQuadroDaFoto = larguraDoQuadroDaFoto * alturaDaFoto / larguraDaFoto

 # Cria quadro de imagem com a foto
 quadroDaFoto = scribus.createImage(quadroDaFotoEsquerda, quadroDaFotoTopo, larguraDoQuadroDaFoto, alturaDoQuadroDaFoto)

 # Define fluxo para "Afastar texto"
 flow(quadroDaFoto, AROUND_FRAME) 

 # Define formatação gráfica do quadro de foto
 scribus.setLineWidth(    0.8, quadroDaFoto)
 scribus.setLineColor(   "Black", quadroDaFoto)
 scribus.setLineShade(    100, quadroDaFoto)
 scribus.setLineStyle(LINE_SOLID, quadroDaFoto)
 scribus.setLineJoin(JOIN_MITTER, quadroDaFoto)
 try:
  scribus.loadImage(arquivoDaFoto, quadroDaFoto)
 except:
  print "Não pude carregar a imagem."

 # Calcula escala da imagem para caber no quadro
 escalaDaFoto = larguraDoQuadroDaFoto / larguraDaFoto

 # Resescalona quadro de imagem
 scribus.scaleImage(escalaDaFoto, escalaDaFoto, quadroDaFoto)

 ########################################
 # LEGENDA
 ########################################
 # Calcula dimensões do quadro de legenda
 quadroDaLegendaTopo = quadroDaFotoTopo + alturaDoQuadroDaFoto
 alturaDoQuadroDaLegenda = entrecoluna * 2
 # Cria quadro de legenda
 quadroDaLegenda = scribus.createText(quadroDaFotoEsquerda, quadroDaLegendaTopo, larguraDoQuadroDaFoto, alturaDoQuadroDaLegenda)
 #
 # Melhoria: Colocar leitor de input para escrever legenda

 # Liga "afastador de texto"
 flow(quadroDaLegenda, AROUND_FRAME)

 ##########################################
 # CREDITO
 ##########################################
 # Define medidas do quadro para crédito de foto
 quadroDaFotoDireita = quadroDaFotoEsquerda + larguraDoQuadroDaFoto
 quadroDaFotoBaixo = quadroDaFotoTopo + alturaDoQuadroDaFoto
 # Cria quadro de crédito
 quadroDoCredito = scribus.createText(quadroDaFotoDireita, quadroDaFotoBaixo, alturaDoQuadroDaFoto, entrecoluna)
 #
 # Melhoria: Colocar input de crédito para escrever credito
 #   if not finalizado
 #   processaNaoFinalizado()

 # Liga "afastador de texto"
 flow(quadroDoCredito, AROUND_FRAME)

 # Agrupa os elementos foto, legenda e crédito
 scribus.groupObjects([quadroDaFoto, quadroDaLegenda, quadroDoCredito])

 # Se tiver a legenda e crédito no mesmo arquivo que o texto da matéria
 #scribus.linkTextFrames(quadroDeTitulo, quadroDaLegenda)

 # Liga os textos da legenda e dos créditos
 scribus.linkTextFrames(quadroDaLegenda, quadroDoCredito)

 # Se tiver a legenda e crédito no mesmo arquivo que o texto da matéria
 #scribus.linkTextFrames(credit, quadroDeColunas)

 # Deixa o quadro de legenda "em pé"
 scribus.rotateObject(90, quadroDoCredito)

def montaMateria(espacoDaMateria):
 """ Manipula um bloco de notícia """

 # Pega as coordenadas X e Y do objeto selecionado
 esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(espacoDaMateria)
 # Pega a largura e altura do quadro
 larguraDoQuadro, alturaDoQuadro = scribus.getSize(espacoDaMateria)
 # Apaga objeto original, que era usado só pra marcar o espaço.
 scribus.deleteObject(espacoDaMateria)

 # Cria um bloco de texto com as medidas extremas do objeto
 # E deleta o objeto (que pode ser até uma linha)
 quadroDeTitulo = scribus.createText(esquerdaDoQuadro, topoDoQuadro, larguraDoQuadro, alturaDoQuadro)

 # Pergunta pelo número de colunas
 numeroDeColunas = pedeNumeroDeColunas()

 # Pergunta pelo espaço entre-colunas
 entrecolunas = pedeEntrecolunas()

 # Pergunta pelo tamanho do título em pontos
 corpoDeTitulo = pedeCorpoDoTitulo()

 # Pergunta pelo tamanho do antetítulo
 corpoDoSobretitulo = pedeCorpoDoSobretitulo()

 #######################################
 # TÍTULO
 #######################################
 # Calcula o tamanho total dos títulos
 alturaDoQuadroDeTitulo = (corpoDeTitulo + corpoDoSobretitulo) * proporcaoDeEntrelinha
 direitaDoQuadro = esquerdaDoQuadro + larguraDoQuadro
 # Redimensiona quadro de título
 scribus.sizeObject(larguraDoQuadro, alturaDoQuadroDeTitulo, quadroDeTitulo)
 # Define o tipo de fluxo de texto: "afastar texto"
 flow(quadroDeTitulo, AROUND_FRAME)

 #######################################
 # COLUNAS DE TEXTO
 #######################################
 # Define medidas do quadro de textos
 topoDasColunas = topoDoQuadro + alturaDoQuadroDeTitulo
 alturaDasColunas = alturaDoQuadro - alturaDoQuadroDeTitulo
 # Cria quadro de texto
 quadroDeColunas = scribus.createText(esquerdaDoQuadro, topoDasColunas, larguraDoQuadro, alturaDasColunas)
 # Define o fluxo de texto como "afastar texto"
 flow(quadroDeColunas, AROUND_FRAME)
 # Determina colunagem
 scribus.setColumnGap(entrecolunas, quadroDeColunas)
 scribus.setColumns(numeroDeColunas, quadroDeColunas)

 #######################################
 # LINCA TEXTOS
 # Linca quadros de título e de texto
 #######################################
 scribus.linkTextFrames(quadroDeTitulo,quadroDeColunas)
 storyGroup = scribus.groupObjects([quadroDeTitulo, quadroDeColunas])

 #######################################
 # PEGA TEXTO
 #######################################
 # Quadro de escolha de arquivo
 text = pedeTexto(quadroDeTitulo)

 try:
  #scribus.insertText(text,-1,quadroDeTitulo)  # para ANEXAR ao final em vez de substituir
  scribus.setText(text,quadroDeTitulo)
 except:
  text="SobretítulonTítulonAutor da matérianComplemento ao autornPrimeiro ParágrafonOutros parágrafosOutros parágrafos..."
  scribus.setText(text,quadroDeTitulo)

 #######################################
 # PEGA FOTO
 #######################################
 # Ask image
 temImagem = pedeImagem()
 if temImagem:
  montaQuadroDaFoto(quadroDeColunas)

def manipulaSelecao():
 """ Gerencia objetos selecionados """

 # Pega o objeto selecionado
 story = scribus.getSelectedObject(0)
 # Se há apenas um objeto selecionado
 if story and scribus.selectionCount() == 1 :
 # if story:
  montaMateria(story)
  scribus.docChanged(True)
 else:
  #Melhoria pra o futuro:
  #por default, abrir uma matéria do tamanho da página
  # De momento, só avisa
  scribus.messageBox(
   labelDeQuadroDeTitulo,
   pedirParaAbrirQuadro,
   ICON_WARNING,
   BUTTON_OK
  )

def manipulaDocumento():
 """Manipula documentos """
 # Se há documento aberto
 if scribus.haveDoc():
  #Desliga redraw
  scribus.setRedraw(False)
  #Guarda unidades do usuário # Save unit
  unit = scribus.getUnit()
  #Define novas unidades como "pontos tipográfico"
  scribus.setUnit(UNIT_POINTS)

  #############################
  # Manipula objeto selecionado
  #############################
  manipulaSelecao()

  #Recupera medidas do usuário
  scribus.setUnit(unit)
 else:  # Senão há documento aberto, avisa.
  scribus.messageBox(
   labelAbreDoc,
   dizAbreDoc,
   ICON_WARNING,
   BUTTON_OK
  )

def myCode():
 """ User code """
 #########################
 #  USER CODE GOES HERE  #
 #########################

 # Gerencia documento
 manipulaDocumento()

 #########################
 #  USER CODE ENDS HERE  #
 #########################

def main(argv):
 """Default main entry point"""
 myCode()

def main_wrapper(argv):
 try:
  scribus.statusMessage("Rodando o script...")
  scribus.progressReset()
  main(argv)
 finally:
  if scribus.haveDoc():
   scribus.setRedraw(True)
  scribus.statusMessage("")
  scribus.progressReset()

if __name__ == '__main__':
 main_wrapper(sys.argv)

Bibliografia

1. ROSSUM, Guido Van. Python Tutorial. Capítulo 4, More control flow tools, FOR statements. Site web disponível em: <http://www.python.org/doc/2.4.4/tut/node6.html#SECTION006200000000000000000>. Acesso em 25. jul. 2008.
2. SCRIBUS. Arquivo de ajuda. Versão 1.3.3.12. Capítulo For Developers, seção Scripter API, página Page Comands. Disponível no programa através da tecla F1.