1. Seus atributos de página (suas definições no dicionário da linguagem) e
2. Regras de combinação e relacionamento dos atributos (a gramática da linguagem).

Neste artigo, mostro como trabalhar com esta linguagem: como criar um documento Scribus e dividir as páginas com grade de modulação comercial e editorial.

Entre os atributos das páginas, estão suas dimensões (tamanho do papel), suas margens, sua área imprimível (chamada de “mancha”, pois é onde o papel é manchado de tinta), suas colunas. Também pode possuir posição na sequência — esquerda ou direita — elementos repetidos em todas as páginas semelhantes, como cabeçalhos, fios, números de página etc.

Para abrir um documento no Scribus, vá ao menu “Arquivo > Novo” ou tecle CTRL+N. Aparecerá o seguinte quadro de diálogo:

Abrir Novo documento no Scribus

Os procedimentos são estes:

1. Escolha o layout do documento. Jornais e revistas usam páginas duplas.
2. Escolha as dimensões. Jornais podem ser A3 ou A4 (jornaizinhos de empresa, por exemplo). Revistas podem ser A4. Ou você pode escolher o tamanho que quiser, inclusive o horrível formato broadsheet ou standard. O tamanho, em geral, depende da gráfica onde será impressa a publicação. Consulte seu fornecedor de serviços gráficos.
3. Escolha as margens. Existem algumas margens pré-definidas tradicionais.
4. Escolha o número de páginas inicialmente. Mais tarde você pode inserir ou eliminar páginas.
5. Escolha a unidade de medidas. Hoje em dia, usa-se milímetros, em geral.

Depois de criadas as páginas, pode-se criar a grade que vai auxiliar a diagramação (leia mais sobre modulação comercial neste site). Vá ao menu “Página > Gerir guias”:

Menu guias do Scribus

No quadro de diálogo que aparece, coloque os seguintes valores:

Gerenciador de Guias do Scribus

1. Escolha as linhas (coloque 5 guias para ter 6 linhas de módulos. Escolha um número par de módulos para ter uma divisão bem no meio da página) e as colunas (escolha duas guias para ter 3 colunas). As colunas não devem ser muito estreitas nem muito largas. Devem caber uns 40 ou 50 caracteres por linha.
2. Determine a valeta ou espaço entre as linhas e colunas. Use 4 ou 5 mm para uma boa valeta.
3. Diga que quer as guias a partir das margens, não da borda do papel.
4. Aplique em todas as páginas.

Pronto! Você terá grade em todas as páginas:

Página Scribus com grade

Essas grades servem apenas para uma base de diagramação. Não é obrigatório que seja obedecida.Para fazer os objetos gráficos aderirem às guias, vá ao menu “Página > Atrair às guias”:

Aderir às guias no Scribus

As colunas de texto serão definidas dentro de cada quadro de texto. Ou seja: cada quadro de texto deverá ser dividido em colunas. Não se usa mais a abordagem do PageMaker de abrir um quadro para cada coluna. Abre-se um único quadro e divide-se este em quantas colunas se quiser, teclando-se F2 e escolhendo-se “Texto > Columns & text distances” :

Propriedades de texto no Scribus

Criei tutoriais em Flash que mostram estes passos. Baixe os pacotes zipados, descomprima e abra os arquivos HTM no seu navegador.

1. Tutorial Scribus: criando páginas
2. Tutorial Scribus: criando guias

Há tempos estou pensando sobre um sistema editorial que auxilie a produção de jornais pequenos, usando um CMS para gerar conteúdo a ser editado e diagramado. Mas eu estava pensando em soluções muito complicadas, imaginando uma interface com banco de dados e outras misturas exotéricas. Na verdade, tudo pode ser relativamente fácil graças aos padrões. Especificamente, graças ao padrão XML-RPC. E à API implementada em blogs, como a do WordPress.

Com estes padrões, basta usar o módulo Python xmlrpclib para recuperar as informações de um post a partir de seu número ID. Como no trecho de código abaixo, que busca num blog WordPress o título de um post, o nome do autor, o sumário e o restante do post, e insere tudo num quadro de texto previamente selecionado:

import xmlrpclib
loginname = 'seuloginWP'
password = 'suasenhaWP'
postID = 746   # 746 é o ID de um post WP qualquer
server = xmlrpclib.ServerProxy( "http://meiradarocha.jor.br/news/xmlrpc.php" )
post = server.metaWeblog.getPost( postID , loginname,password )
scribus.setText( ', '.join( post['categories'] )+'\n' )
scribus.insertText( post[ 'title' ]+'\n',-1)
scribus.insertText( post[ 'wp_author_display_name' ]+'\n',-1)
scribus.insertText( post[ 'description' ],-1)
scribus.insertText( post[ 'mt_text_more' ],-1)

Agora, o trabalho de criar um sistema editorial fica muito mais fácil. Para facilitar ainda mais, escrevi o script abaixo que importa não só o texto de um post, formatando negritos e itálicos (graças à dica de Aurélio A. Heckert para usar o módulo Python HTMLParser), mas também importa todas as imagens com legenda que encontrar, dentro da marcação “caption” do WordPress. A legenda da imagem fica como legenda, mesmo, e o título da imagem é importado como crédito da foto.

Depois de importar o texto e as imagens (que ficam empilhadas no canto inferior direito da página), pode-se diagramar a matéria com ajuda dos scripts que montam matérias e fotos, encontrados em outros artigos neste site.

To do

Falta fazer uma melhor interpretação de tags HTML, como criação de listas numeradas e com bolinhas, citações etc. Mas o Scripter do Scribus vai mudar na próxima versão 1.5. Então, não vale a pena investir nesta versão do script.

Download

Baixe o script, tire a terminação “.txt” e coloque “.py” (o WordPress não permite upload de programas como scripts Python, por segurança). Edite a variável wp_site para apontar ao seu site antes de usar: Revista Diagrama Post (2010-01-25a)

Caveats

Embora o conteúdo textual seja importado, pode haver problemas de formatação de itálicos e negritos e aplicação de estilos de parágrafos. Por deficiências do próprio Scribus (que é um programa jovem e ainda tem deficiência de design) e de meu próprio  algoritmo, os estilos de parágrafos são aplicados apenas nos títulos mas estes trechos não são formatados conforme o estilo aplicado. Bug do Scribus. Já o corpo do texto fica no formato de parágrafo default mas sem estilo aplicado. O usuário deve aplicar os estilos de parágrafo pelo editor de texto interno do Scribus (pela barra de ferramentas, não pela coluna de estilos à esquerda do texto, para não apagar os itálicos e negritos). Também deve, provavelmente, limpar a formatação dos títulos pela aba “Text” da paleta de controle do programa (tecla F2).

As fotos importadas devem ser desagrupadas e resselecionadas pela ordem foto-legenda-crédito antes de se aplicar o script de redimensionar fotos. Outro bug do Scribus.

Acabamento Profissional

Para quem quer uma ferramenta mais “profissional”, pode tentar o Blurb Booksmart, software que cria um livro inteiro a partir de um blog.

Bibliografia

1. WordPress API support
2. MovebleType API
3. Google Data Protocol Refeference
4. MetaBlog API

Como criar um botão “Próxima página” e “Página anterior”:

1. Insira um botão PDF (ícone com “OK”, na barra de ferramentas).
2. Edite as propriedades do campo clicando com a seta duas vezes em cima do botão
3. Em “Tool tip” escreva a “dica de ferramenta” para o botão, o textinho que aparece quando se deixa o cursor em cima do botão.
4. Na aba “Action”, escolha “Type:” como “JavaScript“.
5. Em “Event:”, escolha “Mouse Up“.
6. Clique no botão “Edit” e escreva “this.pageNum++;” (sem as aspas) no editor de código.
7. Feche o editor de código pelo menu “File > Save and Exit”
8. Se quiser, na aba “Options”, defina ícones de imagens para o botão e defina textos para quando o cursor passa por cima do botão e quando aperta o botão.
9. Termine clicando no botão “OK”.
10. Agora, copie e cole em todas as páginas em que quer o botão.
11. Para a página anterior, use o código JavaScript “this.pageNum–;” (com dois sinais de “menos”, que não aparecem aqui porque o WordPress troca por travessão).

Para inserir um botão que volte à capa:

1. Insira um botão PDF (ícone com “OK”, na barra de ferramentas).
2. Edite as propriedades do campo clicando com a seta duas vezes em cima do botão
3. Em “Tool tip” escreva a “dica de ferramenta” para o botão, o textinho que aparece quando se deixa o cursor em cima do botão.
4. Na aba “Action”, escolha “Type:” como “Go To“.
5. Em “Destination”, coloque 1 em “Page” (ou qualquer outro número de página).
6. Se quiser, na aba “Options”, defina ícones de imagens para o botão e defina textos para quando o cursor passa por cima do botão e quando aperta o botão.
7. Termine clicando no botão “OK”.
8. Agora, copie e cole em todas as páginas em que quer o botão.

Fazer um destaque é tarefa que requer muitos passos e pode levar tempo, se feita manualmente. Para automatizar o processo, desenvolvi este script, em Python para o Scribus.

Ele pode ser usado num único quadro, novo, ou pode ser aplicado a um destaque já criado, constituído de vários objetos agrupados. Para criar um destaque novo, desenhe um quadro de texto e rode o script.

Devido a um bug da função traceText() do Scribus, você deve rodar o script duas vezes, para que aspas em texto sejam transformadas em desenho por linhas (o bug está em que a função traceText() não transforma em linhas um texto recém-criado pelo script. Apenas textos já existentes).

Se o quadro de destaque está vazio, será colocado um texto “copy fit”. O script também cria dois estilos, “Destaque texto” e “Destaque autor” e os aplica ao texto, além de criar duas cores, “Bege” e “Vermelho”. Tanto os estilos quanto as cores são criados mas não formatados. Você deverá formatá-los conforme seu projeto gráfico. Para o “Destaque texto”, sugiro corpo 18, fonte estreita ou condensada 80%, itálica. Para “Destaque autor”, fonte corpo 12 negrita. Ambos centralizados.

No início do script, coloco variáveis que permitem a fácil personalização. Baixe aqui o Script para criar quadro de destaque

Na sequência abaixo estão screenshots da criação de um quadro de destaque.

O novo Scribus já está com recursos de folha de estilo bastantes avançados e evoluindo num ritmo lento mas constante. E com a programação em Pyhton presente no Scribus, a facilidade da folha de estilos é ampliada para um novo patamar, aumentando os ganhos de produtividade em diagramação.

O comando Scribus-Python scribus.setStyle() aplica um estilo a um quadro selecionado, ou a um texto selecionado dentro de um quadro:

scribus.setStyle(estilo, quadro)

Para ajudar a aplicar este comando dentro de um script de uso geral, criei a função aplicaEstilo() para criar um nome de estilo, se não existir na folha de estilos.

def aplicaEstilo(estilo,quadro):
 # Tenta aplicar estilo
 try:
    scribus.setStyle(estilo, quadro)
 except: # Se dá erro (o estilo não existe), cria um estilo.
    scribus.createParagraphStyle(estilo)
    scribus.setStyle(estilo, quadro)
  return quadro

Dentro de um quadro de texto, deve-se selecionar o texto para aplicar o estilo. No caso de estilos de parágrafo, basta qualquer parte do parágrafo estar selecionada para o parágrafo inteiro se formatar. Isto funciona em todos os programas.

No Scribus, existe o comando scribus.selectText() para selecionar texto em quadros.

scribus.selectText(inicio, comprimento, quadro)

Mas como se saber qual parágrafo do texto iniciar e qual o comprimento do parágrafo para selecionar? Eu usei um método Python para strings de texto, .splitlines(), que devolve uma lista com as linhas do texto. Cada linha ou parágrafo termina com marca de fim-de-parágrafo. Com argumento zero, .splitlines(0) devolve a lista sem incluir a marca de fim-de-parágrafo. Com argumento 1, .splitlines(1) devolve as linhas com a marca incluída.

Agora eu uso o comando scribus.getAllText() do Scribus para pegar todo o texto e separar em uma lista de linhas. Depois, uso comandos Python len () para calcular o tamanho de cada linha (junto com a marca de fim-de-parágrafo) e assim obter a posição inicial de cada parágrafo, somando os comprimentos de cada parágrafo anterior.

No trecho de código abaixo, eu pego os tamanhos dos parágrafos até o quarto: o título de uma matéria, o subtítulo, o autor da matéria e o primeiro parágrafo. Ao manipular as atrings de texto, é necessário usar a função Python unicode() para contar como um caracter todos os caracteres acentuados, que ocupam mais de um byte.

alltext = scribus.getAllText(quadroDeTexto)
linhas = alltext.splitlines(1)
tit = len(unicode(linhas[0]))
subtit = len(unicode(linhas[1]))
aut = len(unicode(linhas[2]))
prim = len(unicode(linhas[3]))

Agora eu já posso formatar os parágrafos com estilos apropriados. Primeiro, seleciono todo o texto de um quadro ou sequência de quadro e aplico o estilo “Normal”. Aproveito para hifenizar todo o texto.

inicioTitulo = 0
comprTexto = len(unicode(alltext))
scribus.deselectAll()
scribus.selectText(inicioTitulo, comprTexto-1, quadroDeTexto)
aplicaEstilo(estiloNormal, quadroDeTexto)
scribus.hyphenateText()
scribus.deselectAll()

Repare que antes de selecionar o texto eu precisei desselecionar tudo. É uma idiossincrasia do Scribus. Se eu não fizer isto, a função scribus.selectText() não funciona corretamente.

Para calcular o próximo ponto de início da seleção, somo os valores de comprimento de cada parágrafo. Na operação, aproveito para des-hifenizar os textos que não precisam de hífen.

# Formata o título
 inicioTitulo = 0
 scribus.deselectAll()
 scribus.selectText(inicioTitulo, tit-1, quadroDeTexto)
 aplicaEstilo(estiloDoTitulo, quadroDeTexto)
 scribus.dehyphenateText()

 # Formata o subtítulo
 inicioSubTitulo = tit
 scribus.deselectAll()
 scribus.selectText(inicioSubTitulo, subtit-1, quadroDeTexto)
 aplicaEstilo(estiloDoSubtitulo, quadroDeTexto)
 scribus.dehyphenateText()

 # Formata a assinatura
 inicioAutor = tit + subtit
 scribus.deselectAll()
 scribus.selectText(inicioAutor, aut-1, quadroDeTexto)
 aplicaEstilo(estiloDoAutor, quadroDeTexto)
 scribus.dehyphenateText()

 # Formata o primeiro parágrafo
 inicioTexto = tit + subtit + aut
 scribus.deselectAll()
 scribus.selectText(inicioTexto, prim-1, quadroDeTexto)
 aplicaEstilo(estiloDoPrimeiroParagrafo, quadroDeTexto)
 scribus.deselectAll()

Com este script, posso carregar um texto em quadros e aplicar todos os estilos que me interessam em poucos segundos. Observe que título, subtítulo, autor e primeiro parágrafo já devem estar na ordem. O texto também é “limpo” de parágrafos vazios e de dois ou mais espaços entre os caracteres, no início e no final das linhas.

Baixe o script Aplica estilos 1 (2009-06-14a) para aplicar estilos. Modifique-o conforme suas necessidades, mudando o nomes dos estilos ou as medidas gráficas no início do código.

Na sequência abaixo, veja a script em ação. Observe que a formatação dos estilos já deve estar feita antecipadamente conforme o projeto gráfico do veículo. O script não faz isto.

A nova edição 1.3.5 já está apta a ser usada em produção gráfica profissional ou em jornais-laboratório. É o que estamos fazendo no CESNORS/UFSM.

Entre as suas vantagens, está o fato de que pode ser programado em linguagem Python (muito usada no mundo, bastante pelo Google).
Por exemplo, fiz um script para montar fotos, legendas e crédito, uma das coisas mais usadas em jornais, e das mais chatas de se fazer.

Foto montada pelo script do Scribus

Com ele, basta desenhar um quadro, aplicar o script e a foto resultará montada com legenda e crédito ao lado.

Se você está desenhando uma foto nova, e abriu um quadro para foto, o script mantém o tamanho do quadro da foto e só coloca a legenda abaixo e o crédito ao lado. Termina deixando tudo agrupado.

Mas se você mexeu no tamanho de uma foto-legenda-crédito já agrupados (quando sobra ou falta espaço na página, por exemplo), o script mantém o tamanho do grupo e mexe levemente no tamanho da foto para caberem a legenda e o crédito.

O script pede para você escolher a foto e escrever o crédito e a legenda. Se já existirem fotos, créditos e legendas, eles são preservados e podem ser reeditados. São aplicados os estilos “Legenda” e “Credito da foto” (sem acento), para automatizar a formatação. Se os estilos não existirem, são criados, mas sem formatação, apenas os nomes dos estilos, que podem ser formatados posteriormente.

Para rodar o script, vá ao menu “Script > Executar script…“. Depois de rodar uma vez ele fica em “Script > Mais recentes…“. Ou coloque-o na pasta ./share/scripts (dentro da pasta do Scribus), para deixar sempre no menu “Scribus > Scribus Script“.

Baixe o script Monta foto (2010-01-13a).7z.

Abaixo, a sequência de imagens mostra a aplicação do script.

Estou à disposição para troca de experiências em jornais-laboratório usando softwares livres e gratuitos.

Para testar os comandos desta página, você deve usar o console Python embutido no Scribus. Chame-o pelo menu Script > Show console. O console mostra dois painéis. Os comandos digitados no painel de cima são executados com a tecla F9 e o resultado aparece no painel de baixo.

Existe um comando Python-Scribus para pegar o nome de um objeto:

x = scribus.getSelectedObject()

A variável x conterá uma string com o nome do objeto.

Existem comandos para listar todos os elementos de uma página. Tem o comando que lista só o nome dos objetos:

x = scribus.getAllObjects()

A variável x conterá uma lista com os nomes de todos os objetos na página.

Mas ainda não é isto que nos interessa. Precisamos saber os tipos dos elementos. Para isto, existe o comando:

itens = scribus.getPageItems()

Ele retorna uma lista com tuplas (grupos de parâmetros) com todos os itens da página atual. A tupla é  (nome, tipo, ordem).

Para listarmos os elementos, usamos a estrutura Python “for”:

for item in itens:
    print item

Podemos listar também individualmente cada elemento da tupla:

for item in itens:
    for elemento in item:
        print elemento

Ou então podemos listar só os nomes:

for item in itens:
    print item[0]

Ou os nomes e os tipos:

for item in itens:
    print item[0], item[1]

O resultado, dependendo que tenha a página,  pode ser algo como:

Group10 6
Image14 2
Text15 4
Text16 4
Render17 2
Polygon1827 7
Line19 5

Assim, por tentativa e erro, fico sabendo que os tipos são:

0: nada
1: nada
2: quadro de imagem ou renderização
3: nada
4: quadro de texto
5: linha reta
6: grupo ou retângulo ou polígono regular
7: polígono, curvas ou polilinha

Segundo o Help do Scribus, seção For Developers > Scribus Documento Format, os tipos são:

2 = Image
4 = Text
5 = Line
6 = Polygon
7 = Polyline
8 = Text on a path

Com estes comandos do Python e do Scribus já podemos criar uma função para pegar o tipo de um objeto. Basta descobrirmos o nome de um objeto selecionado, procurarmos a tupla do objeto na lista de objetos da página, e pegarmos o tipo do objeto dentro da tupla. Poderíamos chamar esta nova função de Astolfo Robledo, mas vamos chamá-la apenas de getObjectType, para preservar sua identidade. A função ficaria assim:

def getObjectType():
    objtype = 0
    obj = scribus.getSelectedObject()
    itens = scribus.getPageItems()
    for item in itens:
        if item[0] == obj:
            objtype = item[1]
            break
    return objtype

Esta função retorna zero se não houver objeto selecionado, e o número que designa o tipo do objeto, se houver algum selecionado.

Bilbiografia

1. Arquivo Help do Scribus, For Developer, Scripter API. Acessível pela tecla F1 no Scribus.
2. BORGES, Luiz Eduardo. Python para desenvolvedores. Rio de Janeiro: edição do autor, 2009.

E lembre-se de que o MS Office não é dos usuários, é da Microsoft. Quem usa o MS Office e não pagou pela licença de uso está cometendo crime. A Microsoft aciona na justiça quando descobre alguém usando propriedade dela e exige 3.000 vezes (três mil vezes) o preço do programa. É sério!

Portanto, não seja um criminoso: proteja e difunda a propriedade privada baixando o Openoffice.org para Linux, para Macintosh ou para Windows. Quem deu o furo (ôpa!) jornalístico do lançamento foi o site tuga Peopleware.

Mas tem uma coisa que profissionais que trabalham com mídias impressas não podem deixar de lado: a necessidade de calibrar os monitores para aumentar a semelhança entre as cores de tela e as cores impressas. E é quase impossível se calibrar monitores LCD. As cores mudam até conforme o ângulo de visão. Portanto, que trabalha com mídias impressas sempre vai precisar de pelo menos um monitor CRT para conferir as cores e ter menos surpresas com impressos ou até mesmo com sites Web.

1. Preparação de Texto: técnicas, etapas e níveis de intervenção.
2. Tipologia. Legibilidade e Leiturabilidade.
3. Objetos impressos e Design: (livros, catálogos, folders, manuais, convites etc..).
4. Editoração Eletrônica: (Softer Indesign, Page Maker e Photoshop).
5. Diagramação e Paginação de texto e imagem.
6. Matérias – primas para impressão: características e adequações.
7. O papel e a imagem: natureza, história e procedimentos.
8. Processos de pré-impressão, impressão e acabamento.
9. O Livro – suporte de muitas artes.
10. O desenvolvimento da Linguagem gráfica na história da Arte.

E esta, a bibliografia em Editoração:

1. ARAÚJO, Emanuel. A Construção do Livro. Rio de Janeiro/Brasília, Nova Fronteira/INL. 1986
2. ARHEIM, Rudolf. Arte e Percepção Visual: Psicologia da Visão Criadora. São Paulo, Pioneira, 1994.
3. BAER, Lorenzo. Produção gráfica. São Paulo, Senac, 1995.
4. BRINGHURST, Robert. Elementos do Estilo Tipográfico. São Paulo, CosacNaif, 2004.
5. CRAIG, James. Produção Gráfica. 2.ed., São Paulo, Mosaico/EDUSP, 1980.
6. HANDEL, Richard. O Design de Livro. São Paulo Ateliê, 2007
7. MARTINS, Nelson. A Imagem Digital na Editoriação: Manipulação, Conversão e Fechamento de Arquivos. São Paulo, Senac, 2003
8. SALOMON, Martin. The Art Typography. New York, Watson-Guptill Publications. 1986. 240p.
9. SWANN, Alan. How to Design Grids and Use them Effectively. Oxsford, Phaidon. 1989. 144p.

Matéria montada automaticamente pelo script.

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.

Programa de editoração Scribus e o console Python.

Para conhecer e manipular os elementos de uma página, no Scribus, uso o comando Python “getPageItems”. Abro o terminal Python (menu Script > Mostrar console), apago as linhas iniciais e digito:

t = getPageItems()

Depois, rodo o comando com a tecla F9. Este comando getPageItems atribui à variável “t” uma lista com os objetos da página. Cada elemento da página do Scribus tem um conjunto (“tuple“) de três elementos. O comando “print t” imprime a lista de elementos:

print t

O resultado, na janela de baixo do terminal Python, seria este:

[('Texto8', 4, 0), ('Texto9', 4, 1), ('Imagem10', 2, 2), ('Texto11', 4, 3), ('Texto12', 4, 4), ('Polxedgono13', 6, 5), ('Linha14', 5, 6), ('Linha poligonal15', 7, 7), ('Imagem16', 2, 8), ('Polxedgono17', 6, 9), ('Polxedgono18', 6, 10), ('Polxedgono19', 6, 11), ('Linha poligonal20', 7, 12)]

• O primeiro elemento da tuple é o nome do objeto
• O segundo elemento da tuple é o tipo de objeto (4 = texto, 2 = imagem)
• O terceiro elemento da tuple é a ordem na página.

Veja na imagem o console Scribus/Python com o comando e o resultado. A lista obtida com o comando getPageItems pode ser manipulada em um laço “for“, por exemplo:

it = getPageItems()
for nome,tipo,ordem in it:
	print nome,"==>",tipo,"-->",ordem

O resultado do código acima seria como isto:

Texto8 ==> 4 --> 0
Texto9 ==> 4 --> 1
Imagem10 ==> 2 --> 2
Texto11 ==> 4 --> 3
Texto12 ==> 4 --> 4
Polígono13 ==> 6 --> 5
Linha14 ==> 5 --> 6
Linha poligonal15 ==> 7 --> 7
Imagem16 ==> 2 --> 8
Polígono17 ==> 6 --> 9
Polígono18 ==> 6 --> 10
Polígono19 ==> 6 --> 11
Linha poligonal20 ==> 7 --> 12

Com estes elementos, torna-se possível se descobrir o tipo de objeto, seu nome, e sua ordem na página. O código-exemplo a seguir lista os objetos de texto com seus nomes:

itensDaPagina=getPageItems()
for nome,tipo,ordem in itensDaPagina:
	if tipo == 4:
		print nome + " é texto."

O resultado seria:

Texto1 é texto.
Texto2 é texto.
Texto3 é texto.
Texto4 é texto.
Texto5 é texto.

De posse de seu tipo e seu nome, outros comandos podem descobrir quais os outros atributos dos objetos. E criar, modificar e destruir objetos como textos, fotos, botões PDF.

Bilbiografia

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.

Lembre-se de que se um jornal aparece com erro de diagramação, vai parecer que ele erra também na apuração, na redação, na distribuição. Enfim, se há algo desalinhado nas páginas de seu jornal, há algo desalinhado em toda a empresa ou instituição.

Para ajudar os alunos e os funcionários do Jornalismo do IPA envolvidos nas publicações Universo IPA (jornal mural, jornal broadsheet (standard), jornal tablóide, revista, site), resolvi aprender JavaScript para programar o Adobe inDesign, como já faço com o Python e Scribus. Assim surgiu este script para alinhar foto, legenda e crédito da foto.

InDesign pode ser controlado com as chamadas “linguagem script”. São linguagens para se escrever programas, supostamente com rapidez, destinadas a resolver necessidades de outros aplicativos. Por exemplo, todos os navegadores usam JavaScript para controlar as páginas Web. Além dos navegadores, outros programas usam JavaScrip, notadamente o Adobe Acrobat e o Adobe InDesign.

O Adobe InDesign executa programas em três linguagens: Applescript, VBScript e JavaScript. As duas primeiras são exclusivas dos computadores Macintosh e Windows, respectivamente. Então, programar e aprender uma destas linguagens significaria desenvolver programas e comandos para um número mais limitado de pessoas. Resolvi adotar JavaScript, que também é a base da Web atualmente. Assim, os programas que eu desenvolver serão compatíveis com Mac e com Windows.

Como ponto negativo, descobri que JavaScript, por questões de segurança, não tem drivers para bases de dados. Ou seja, não posso consultar textos em bancos de dados e diagramar uma página automaticamente como faço no Scribus. É uma grande falta, porque não posso editar diretamente registros de blogs e CMS para usar como sistema editorial.

Mas, de resto, JavaScript é uma linguagem razoável para uso geral. Scripts InDesign feitos em JavaScript podem rodar sem problema em Windows, Macintosh e talvez até mesmo em Wine no Linux (tenho que testar isso em breve).

O que esse meu script (para download mais abaixo) faz :

1. Pega dois ou três quadros selecionados.
2. Considera o primeiro quadro como foto
3. Monta a legenda
4. Monta o crédito da foto

Coloquei o script na pasta c:\Arquivos de programas\Adobe\Adobe InDesign CS2\Presets\Scripts\ do Adobe InDesign para que ele apareça na paleta de Scripts (Windows > Automation > Scripts):

Menu para a paleta de scripts do InDesign

Seleciono a foto e um quadro qualquer para legenda, e mais um quadro opcional para crédito da foto (ou seja: seleciono dois ou três objetos).

Dois ou três quadros são selecionados

No script, usei comandos “prompt” e “confirm” do JavaScript, que oferecem uma interface com usuário simples mas fácil de ser implementada. Abaixo, resultado obtido com “confirm” e “prompt”:

Diálogo de "Confirm"

InDesign usando o comando "dialog"

O script deixará:

1. Primeiro quadro intacto, mas transformado em quadro de imagem e com o estilo de objeto “Foto“;
2. O segundo quadro vira legenda, formatado com o estilo de objeto “Legenda“;
3. O terceiro quadro, se houver, vira crédito da foto, formatado com o estilo “Crédito da Foto“.

Quadros de diálogo da montagem de fotolegenda e credito

Acima, o resultado final do script: o quadro da foto com um quadro de legenda embaixo e um quadro de crédito na direita, “em pé”. Se os quadros já contiverem texto, o script dará opção de não editá-los, só modificar o tamanho e posição dos quadros.

Se os estilos não existirem ainda, serão criados com as definições default do meu InDesign.

Eu posso mudar as medidas conforme meu projeto gráfico. As variáveis que valem a pena serem modificadas estão no início do script. Mudo conforme a necessidade e dou um nome diferente para os arquivos.

Se os quadros tiverem conteúdo, serão preservados. A foto não será agrupada com a legenda e com o crédito, para que eu possa redimensioná-la se necessário. Só agrupo depois de escolhidas as dimensões finais da foto.

A foto tem text wrap de zero em cima, para ser colocada próximo aos títulos. Nos lados, o text wrap é de 5 mm, e em baixo, de 10 mm para dar espaço à legenda. Estas medidas podem ser modificadas no início do script.

O quadro de legenda e crédito ignoram o text wrap, para que o texto apareça. Eles também têm o text wrap de zero, apenas o suficiente pra não ficarem em cima de texto nenhum.

Para completar a automação, atribuí este script às teclas SHIFT+CTRL+ALT+F. E manualmente setei os estilos de frames determinando o estilo de parágrafo. Por exemplo, o frame de estilo “Legenda” formata o texto que contém com o estilo de parágrafo de estilo “Legenda”. Tenho que descobrir como fazer isto pelo próprio script.

O alinhamento de fotos é simples:

1. Redimensiono a foto;
2. Seleciono os quadros da legenda e do crédito, com shift+clic;
3. Teclo o atalho.

Aqui está o script para montar foto, legenda e crédito no InDesign, versão 008.

Bibliografia

1. FLANAGAN, David.  Javascript – The Definitive Guide. 4Th Edition. O’Reilly. Arquivo CHM (html help do Windows).
2. KAHREL, Peter. Scripting InDesign with JavaScript. O’Reilly Media, 2006. ISBN: 0-596-52817-5. Comprado pela O’Reilly em formato PDF.
3. Adobe InDesign CS2 Scripting Guide. Adobe Systems Incorporated, 2006. Documento PDF.
4. JavaScript Tutorial. Site web disponível em: <http://www.w3schools.com/js/default.asp>. Acesso em 10 jul. 2008.

E porque nós, que usamos a internet como meio de expressão, temos que pagar impostos de telecomunicações?

A imprensa, desde que foi criada por Gutemberg, é um negócio para ganhar dinheiro, não para defender liberdades individuais. Na prática, a imunidade tributária ao papel de imprensa é  um benefício que só favorece aos empresários da imprensa. Justamente os primeiros a reclamar do mito “altos gastos públicos”. Que tal começarem a ajudar as contas públicas pagando impostos, como todos nós?

Saiba mais:

• Quando o papel não paga imposto
• Por que a imprensa tem reserva de mercado e não paga imposto?

Mesmo o Tétum não é a língua mais falada, mas foi adotada na liturgia pela igreja católica, já que o português havia sido proibido pela ditadura militar indonésia. Assim, transformou-se em língua franca, principalmente o tetum-prasa (tétum-praça), dialeto falado na capital Díli com tantas palavras em português que é quase um crioulo.

Como me interesso pela comunidade lusófona, passei a acompanhar mais de perto a situação do Timor-Leste depois de um embroglio que resultou no presidente Ramos-Horta baleado, dois militares rebeldes mortos e um segurança presidencial seriamente ferido. Para entender melhor a situação, às vezes expressa em tétum, baixei um dicionário Tétum-Português-Indonésio em formato PDF, compilado por Ken Westmoreland.

Mas consultar um dicionário de papel é chato, mesmo em PDF. Melhor seria usar um programa como o Babylon Translator, um dos poucos programas comerciais que valem a pena ser comprados. Ainda mais agora, com o dólar “derretendo” no Brasil. O Babylon Translator traduz rapidamente uma palavra quando você control-clica em cima dela. Isso funciona mesmo em palavras em imagens, porque o programa faz um OCR (reconhecimento de caracteres) antes de traduzir. Também fornece a pronúncia robotizada de palavras em inglês.

Dica: se você tiver cartão de crédito internacional, no Brasil compre em dólar, não em real, que deixa o produto mais caro. Pra mim, com a Brittanica resumida, saiu por 71 dólares. Mas você também pode baixar o Babylon para testes durante 30 dias.

Baixado o Babylon Translator, me dediquei a construir um dicionário tétum para ele, o que exigiu pesado processamento de texto. Transformei o PDF em texto. Editei o texto no BROffice e no Notepad++ inserindo tabulações entre as palavras tétum, portuguesas e indonésias. Também inseri o gênero feminino nas palavras de origem portuguesa do tétum, além de mudar a ordem das designações de classes das palavras. Tudo isto graças ao recurso de procura-e-troca com expressões regulares, um recurso informático meio complicado mas poderosíssimo.

Preparado o texto, gravei como “texto-separado-por-tabulação” e importei numa planilha eletrônica do BROffice, que gravei como formato MS Excel. Aí, pude criar o dicionário com o Babylon Builder, programa gratuito distribuído pela empresa para que os usuários criem vocabulários e dicionários.

Para colocar uma cereja no bolo, criei com o IrfanView um ícone com a bandeira do Timor-Leste a partir da bandeira do país na Wikipedia e usei no Builder.

Se você precisar urgentemente de um dicionário Tétum-Português-Indonésio para o Babylon Translator, baixe aqui. E se você quiser ajudar colocando mais palavras neste dicionário, use a versão Google Planilha que coloquei na rede. Basta pedir permissão para editar. O copyright do dicionário é de Ken Westmoreland (sob o pseudônimo Buka Hatene, que significa “aprender”, em tétum).

• Baixe o Dicionário Tétum-Português-Indonésio para Babylon Translator
• Baixe o dicionário Tétum-Português-Indonésio de Ken Westmoreland (Buka Hatene) em PDF

(O título deste post é uma citação ao conto “O Homem que falava Javanês“, do escritor brasileiro mestiço Lima Barreto).

Folha de estilos é o conjunto de formatos pré-programados em um software de editoração. No início da editoração eletrônica, você tinha que marcar texto por texto e aplicar a formatação a cada vez: mudar família tipográfica, mudar tamanho da letra (corpo), mudar estilo (negrito, itálico), mudar o alinhamento (justificado, alinhado à esquerda). Com a folha de estilos, você clica no texto e clica no estilo. Pronto, o texto se formata conforme as especificações do estilo.

A folha de estilos foi uma invenção do Ventura (um dos melhores programas de editoração já feitos, concorrente do PageMaker). Depois, foi incorporado no MS Word e todos os editores de texto e programas de editoração.

Basicamente, a folha de estilos aparece ao usuário como uma lista de nomes como “Título” “Subtítulo”, “Primeiro parágrafo”, “Lista” etc. Ao se clicar num texto e se clicar num nome da lista, o texto se formata conforme as características do estilo.

No velho e obsoleto PageMaker, você podia aplicar estilos apenas a parágrafos. Nos programas modernos, como Corel Ventura, Adobe InDesign, Quark Xpress e Scribus, você pode aplicar estilos a caracteres, a parágrafos e a objetos gráficos.

Entre as vantagens da folha de estilos estão:

1. Rapidez na diagramação. É MUITO mais rápido clicar em um estilo do que mexer em dezenas de especificações em lugares diferentes do programa de editoração.
2. Padronização de formatos conforme o projeto gráfico. O projeto gráfico será respeitado porque já está todo programado na folha de estilos.
3. Possibilidade de reaproveitamento de um projeto gráfico em outra publicação, mudando apenas alguns detalhes como família tipográfica.
4. Maior rapidez na criação de projetos gráficos, porque quando você muda um estilo, todo o texto que está marcado com aquele estilo será modificado. Fica mais fácil fazer estudos gráficos.

Procure aprender mais sobre como criar estilos em seu programa de editoração preferido lendo no “help” (tecla F1). Você economizará muito tempo de formatação.

E da próxima vez que alguém disser que o MS Word é melhor que o BROffice, pergunte o que a pessoa acha do mecanismo de folha de estilos do MS Word. Ela nem vai saber o que é isto, quanto mais saber que o MS Word tem o pior e mais complicado sistema de formatação de estilos do mundo. Pior a cada nova edição deste software fechado.

Leia também o artigo sobre folha de estilos no BROffice.

Powered by ScribeFire.

Por esta técnica, inventada no século 19, imagens em tons de cinza são decompostas em pequenos pontos. Através de uma lupa apropriada (que os gráficos chamam de “conta-fio”), podemos ver de perto estes pequenos pontos. Ao lado vemos um conta-fio posicionado sobre a foto.

O diâmetro destes pontos varia conforme a área da fotografia seja mais escura ou mais clara. O efeito pode ser visto na imagem ao lado (Clique na foto para ver a imagem grande). Assim, vista de longe, a fotografia impressa parece ser constituída de tons de cinza, não de preto-e-branco. A reticulagem é feita nas gráficas pelos equipamentos gráficos digitais, hoje em dia.

No entanto, temos que ter cuidado na preparação de fotos para impressão em jornal. Qualquer tipo de impressão vai modificar o diâmetro dos pontos porque o papel absorve um pouco da tinta (e o papel jornal tem de absorver bastante tinta porque ela não seca por evaporação, seca por absorção, devido à velocidade de impressão).

Os pontos grandes, em áreas escuras, vão ficar um pouco mais espalhados, escurecendo ainda mais a área. Por outro lado, os pontos pequenos podem ficar menores, na preparação da chapa de alumínio da impressora offset, ou a chapa pode gastar um pouco com o tempo de impressão. Assim, pontos pequenos em áreas claras podem ficar menores, clareando ainda mais a área. Isso se chama “ganho de ponto“, em artes gráficas.

As fotos impressas precisam ter um mínimo de pontos pretos em áreas claras (branco total) e um mínimo de pontos brancos em áreas totalmente pretas. Para conseguir este efeito, temos de corrigir o ganho de ponto nas fotos para impressão alterando a chamada “curva de tom”. Caso contrário, teremos áreas “chapadas”, totalmente brancas ou totalmente pretas. Perderíamos detalhes da fotos, caso isto acontecesse.

Para fazermos o tratamento de fotos para impressão em preto e branco, primeiro temos que converter as fotos para tons de cinza. Qualquer programa de edição de foto tem este recurso em algum lugar bem acessível. Em geral, esta opção está no menu “Imagem > Modo > Tons de cinza” ou algo do gênero. As imagens de computador têm 256 tons de cinza (profundidade de cor de 8 bits), o que é mais do que suficiente para o olho humano enxergar belas fotos.

Depois de transformada em tons de cinza, as fotos precisam ter suas áreas claras escurecidas e suas áreas escuras clareadas, o que se faz alterando a “curva de tom”, em geral também no menu “Imagem” dos programas de tratamento de foto.

Cada tipo de papel e cada tipo de impressora tem um ganho de ponto diferente. As gráficas fornecem tabelas que descrevem este ganho. Grosso modo, para fotos a serem impressas em papel jornal, podemos clarear 25% as áreas escuras e escurecer 25% as áreas claras de uma foto em tons de cinza. Com isso, a foto vai ficar com pouco contraste na tela do computador, mas o resultado final, impresso, ficará perfeito.

A seguir, temos de corrigir a faixa média de tons. Isto é particularmente importante no caso de rostos de pessoas, para que os tons criem a sensação de volume no rosto, não deixem a pessoa com a “cara chapada”. Esse ajuste varia de foto para foto. Se a foto tem muitos tons escuros, a curva deve ser mais clareada, e vice-versa. Apenas a prática leva a um ajuste perfeito, depois de se ver as fotos originais, o ajuste e a impressão.

Confira as fórmulas usada na planilha.

Conclusões:

1. A impressão mais barata é em impressora laser.
2. A impressora laser colorida só custa 2,5 vezes mais caro que a impressão em preto-e-branco.
3. A impressão a jato-de-tinta é a mais cara, o dobro do preço da impressão a laser, que tem muito mais qualidade.