Para abrir a janela de estilos, tecle F3 ou vá ao menu “Editar > Estilos”.

Acesso ao editor de estilos do Scribus

Clique no botão “Novo”.

Acesso à criação de novo estilo de parágrafo

Existem três categorias em que se podem criar estilos: caracteres, parágrafos e linhas. Escolha o tipo de estilo que você quer criar.

Escolha do tipo de estilo

Características do parágrafo

Se abrirá um painel com três abas. Na primeira, escolha as propriedades do estilo:

Painel de propriedades de estilo de parágrafo

1. Nome do estilo. Veja artigo neste site sobre os estilos mais usados. Evite acentos ou cedilha ou caracteres especiais neste nome, para facilitar seu uso em scripts, futuramente.
2. Entrelinha. Espaço entre as linhas de texto.
   1. Entrelinhamento automático. Define o valor para uma porcentagem fixa determinada em “Arquivo > Preferências > Tipografia > Espaçamento automático de linhas”. Por exemplo, se o corpo da letra é 10 pontos, e a porcentagem é de 20%, a entrelinha será de 12 pontos (10 pontos mais 20% de 10). Um título de 48 pontos terá entrelinha de 52,8 pontos.
   2. Entrelinhamento fixo. Você define um valor arbitrário.
   3. Alinhar à grelha da pauta. As linhas serão “atraídas” pelas linhas da pauta definida em “Arquivo > Preferências > Guias > Configurações de pauta”. Veja ou esconda a pauta em “Visualizar > Mostrar pauta”. É bom usar este recurso em jornais e revistas, para deixar as colunas de texto bem alinhadas no topo e na base. Mas toda a folha de estilos precisará ser muito bem ajustada em seus espaçamentos (entrelinhas, espaços acima e abaixo do parágrafo, deslocamento da linha-base).
3. Espaços acima e abaixo do parágrafo.
4. Alinhamentos. Jornais e revistas geralmente usam texto com alinhamento justificado, quarto ícone.
5. Capitulares. É conveniente que o primeiro parágrafo de um texto tenha seu próprio estilo com capitular, aquela letra grande que ajuda os olhos a encontrarem o início da matéria. Especifique quantas linhas terá a letrona, e qual a distância lateral dela até o texto.
6. Optical margins. Ajuste que faz as linhas ficarem um pouco para fora do alinhamento vertical para corrigir letras como “o” ou hífens, que parecem ficar para dentro se alinhados milimetricamente. É bom ligar em ambas as margens (both sides).
7. Advanced settings. Ajuste da largura dos espaços entre as palavras e da expansão horizontal das letras, para ajudar a justificação ficar bonita. Um truque que Gutemberg já usava: as letras ficam mais largas ou mais finas, mas o leitor não nota. No texto de corpo, pode ficar entre 85% e 105%. Não se usa em títulos ou outros paratextos, só em grandes quantidades de texto justificado.
8. Tabuladores e endentações. Coloque aqui a “entrada de parágrafo” (jamais use tabulação para fazer entrada de parágrafo) e espaços à direita e à esquerda dos parágrafos.
9. Based on. Baseado em. Recomendo que todos os estilos sejam baseados em um ou dois estilos básicos (eu costumo usar duas famílias de fontes básicas em meus projetos gráficos de publicações). Este recurso é muito útil quando você quer usar um projeto gráfico para outro cliente: basta mudar as famílias tipográficas dos estilos básicos, que todos os estilos baseados neles são modificados automaticamente. Por exemplo, o estilo “Titulo 7″ é baseado em “Titulo 6″, que é baseado em “Titulo 5″, que é baseado em “Titulo 4″, e assim por diante. Quando eu mudo a fonte do estilo “Título 1″, todos os estilos de títulos, entretítulos, legendas etc são modificados ao mesmo tempo.

Características das letras

A segunda aba define as características das letras do parágrafo.

ddos estil

Aba de estilos de caracteres do editor de estilos

1. Based on. Defina em que estilo de caracter o estilo de parágrafo é baseado.
2. Basic formating. Formatação básica: família tipográfica, estilo (negrito, itálico, claro etc), corpo (tamanho de letra), tracking (espaço entre as letras), espaço entre as palavras.
3. Advanced formating. Formatação avançada. largura e altura dos caracteres (condensado/expandido). Não mude a largura para não estragar o desenho das letras. Se mudar, prefira aumentar a largura do que diminuir, para não deixar as hastes verticais das letras mais estreitas do que as horizontais. Se estreitar as letras, não coloque menos de 80% da largura original (a Helvetica Narrow é assim: Helvetica condensada 80%). O terceiro ajuste é o deslocamento das letras em relação à imaginária linha base. Em Language, defina a língua do parágrafo, informação importante para a hifenização.
4. Cores. Defina as cores do preenchimento e do contorno das letras.

Tome um atalho

A terceira aba permite a definição da tecla de atalhos para o estilo. Sempre é uma boa ideia definir teclas de atalho para a formatação de grande quantidade de texto.

Definição de tecla de atalho para estilo de parágrafo

Definido tudo que interessa, clique em “Feito” para encerrar e edição do estilo.

Encerramento da edição de estilo

Como aplicar estilos

Para aplicar os estilos, use o editor de texto interno do Scribus (CTRL+Y ou ícone de bloco de notas):

Aplicação de estilo no Editor de História

Ou aplique estilos pela paleta de propriedades.

Aplicação de estilo pela paleta de propriedades

Pela paleta de propriedades, também é possível limpar o estilo dos parágrafos.

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

A autora é Mayra Maki Sassaki, graduada no Curso de Jornalismo da Universidade Presbiteriana Mackenzie, São Paulo, 2009.

Palavras-Chave:    Diagramação,  Jornais Nipo-Brasileiros, Sintaxe da Linguagem Visual, Leitura na Língua Japonesa, Gestalt.

Baixe SASSAKI, Mayra M. Análise da diagramação de jornais nipo-brasileiros.

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.

O scripter tem o comando scribus.selectObject(objeto) para selecionar objetos. O parâmetro é uma string com o nome do objeto.

Para criar grupos de objetos, existe o comando scribus.groupObjects(). O parâmetro pode ser vazio, para se agrupar os objetos atualmente selecionados. Ou pode ser uma lista de objetos: scribus.groupObject(['Text1','Text2','Text3']). O grupo criado recebe o nome “Group” colado a um número de ordem: ‘Group1′, ‘Group2′ etc.

O problema é que o comando scribus.groupObjects() não retorna uma string com o nome do grupo. Ele não é usado na forma:

nomeDoGrupo = scribus.groupObjects()

Mas, precisamos deste nome para manipular os grupos. Talvez este comportamento falho seja modificado em futuras versões do Scribus. Como fazer, então, para obter este nome?

Resolvi essa questão com uma gambiarra. Desseleciono qualquer objeto com o comando scribus.deselectAll(), seleciono os objetos que serão agrupados, agrupo-os. O resultado é um outro objeto grupo, que continua agrupado. Aí, pego o nome do objeto agrupado. Como neste exemplo:

scribus.deselectAll()
scribus.selectObject(box1)
scribus.selectObject(aspa1)
scribus.selectObject(aspa2)
scribus.selectObject(fio1)
scribus.groupObjects()
story = scribus.getSelectedObject(0)

Eu poderia ter usado o comando:

scribus.groupObjects([box1,aspa1,aspa2,fio1])

Mas, com isto, o grupo não restaria selecionado, ao final do agrupamento. Por alguma razão, o grupo só fica selecionado quando o comando de agrupamento é usado sem parâmetros. Agora, eu posso usar a string com o nome do grupo em outras funções de manipulação de objetos gráficos.

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.

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.

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.

Essa abordagem é muito antiquada. Ela imita a montagem manual de jornais nos anos 80: os pedacinhos de texto fotocomposto eram colados à mão numa folha de montagem em papel gessado. A metáfora deste tipo de montagem foi adotada pelo PageMaker em 1986, e levou anos para que os programas de editoração desistissem dessa mania.

Como NÃO fazer quadros de texto para notícias

Os problemas que essa abordagem causa são a falta de produtividade e a falta de precisão na montagem. Isto porque um diagramador, “a olho”, demora muito ou nem consegue ter precisão na colocação destes elementos. Os parágrafos, em programas de editoração, têm atributos de espaço em cima e embaixo que agilizam o posicionamentos dos textos. No entanto, isso só funciona se os elementos estiverem todos em um único quadro de texto.

Os melhores programas, como o Corel Ventura, exigem que se abra apenas um quadro de texto e se jogue todo o texto dentro. Os títulos, no Ventura já têm o atributo “ignorar as colunas do quadro”. Então, a cartola, o título e o subtítulo entram “de fora a fora”, ocupando toda a largura do quadro, enquanto que o texto da matéria corre pelas colunas, obedecendo às divisões. Pá, pum, foi!

Outros programas (PageMaker, InDesign, QuarkXpress, Scribus), inexplicável e burramente, ainda exigem que se abra um quadro para os títulos e outro quadro para as colunas de texto. Criei script noScribus que já faz a diagramação de matérias automaticamente , depois que o diagramador especifica tamanhos de títulos e quantidades de colunas. Estou estudando InDesign para fazer o mesmo com ele.

Maneira produtiva de fazer notícias com texto em blocos

Pior ainda é quando os diagramadores se dão ao trabalho de abrir coluna por coluna de texto. Essa abordagem “PageMaker” não deve mais ser usada, pelo perda de produtividade e falta de precisão. Por exemplo, se a foto aumenta ou diminui, o diagramador tem de ajustar todas as colunas manualmente. Se todo o espaço da matéria é modificado, então, todas as colunas têm de ser modificadas.

Hoje, o bom diagramador abre um quadro para o título, um quadro para o texto e divide este quadro em quantas colunas quiser. Já as fotos devem ter o aributo de afastar o texto automaticamente (text wrap, no InDesign).

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.

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.

Ganho de ponto – O ganho de ponto é o aumento na dimensão do ponto de retícula, inerente ao processo mecânico de impressão. A medição desse ganho determina como os pontos estão sendo reproduzidos, informação preciosa para a pré-impressão, que pode então compensar na geração dos filmes ou das chapas (CTP) o ganho de ponto da máquina impressora. Muitos fatores interferem no ganho de ponto, como carga de tinta excessiva, balanço de água/tinta, chapas, condições da impressora, tipo de tinta e de papel. O ganho de ponto deve ser medido em área de retículas e meios tons nos meios tons (retículas) e nos chapados. (ABGT).

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.

Um dos autores que difundiram as ideias de Arnold foi Rafael Sousa Silva em sua dissertação de mestrado “Diagramação: o planejamento visual gráfico na comunicação impressa”. Leia o capítulo Zonas de visualização da página impressa para ver o esquema proposto por Arnold, também apresentado na figura ao lado.

Mas, a partir dos anos 1980 e 1990, estudos mais acurados, que captavam os “caminhos” do olhar sobre uma superfície, demonstraram que idéia de zonas de visualização era mais uma aposta errada do que qualquer outra coisa.

Estudos do russo Alfred Yarbus sobre a maneira como observadores olham para uma obra visual (citado por Julio Plaza em “Videografia em Videotexto”) mostram que o olhar do ser humano segue caminhos variáveis mas fortemente determinados pelos elementos de maior interesse na composição visual. O estudo imprimiu em filme fotográfico o caminho seguido pelo olhar de observadores, por meio de um dispositivo “colado” ao olho por sucção. Um dos campos de provas foi o quadro “O retorno inesperado”, do ucraniano Ilya Repin.

A partir de fotos do estudo, eu montei uma imagem GIF animada (clique na miniatura ao lado para ver a animação) onde pode-se observar que o ser humano parece se interessar muito por rostos. Os riscos mostram o caminho do olhar durante quatro sessões de observação, com alguns dias de diferença entre elas. Nota-se que o olhar percorre a cena à procura de pontos de interesse e tende e se concentrar nestes pontos quando os encontra. Ou seja: quem determina para onde se olha numa composição visual é o artista que criou a composição.

Este fato foi comprovado na composição visual jornalística pelo estudo “Eyes on the news” (Olho na notícia), levado a cabo por Mario Garcia e Pegie Adams em 1990. Os pesquisadores usaram um artefato chamado Eyetrack, que pode-se ver nas ilustrações a seguir.

Ele era composto por duas câmeras de vídeo, uma dirigida a um vidro semi-espelhado em frente aos olhos do observador, e outra apontada diretamente para os olhos deste. As duas imagens eram tratadas e fundidas numa só, onde aparecia a página do jornal fixa com um “cursor” apontando aonde os olhos se fixavam.

Eyes on the news confirmou algumas crenças e desmentiu outras. Confirmou, por exemplo, que a primeira página vista por leitores ocidentais é a da direita. Mas desmentiu totalmente a crença nas zonas de visualização propostas por Arnold. Também descobriu que os anúncios em jornal, no estudo, não foram lidos primeiro nem se houvesse ofertas ou se fosse anúncio colorido.

Garcia e Adams descobriram que a leitura dos jornais foi feita em duas etapas: primeiro, os leitores faziam uma verredura na página (scanning), procurando pontos de interesse. Essa parte durou frações de segundos. Depois, os leitores se fixavam em “pontos de entrada”. Estes pontos — os locais onde os leitores faziam uma visualização mais demorada — eram determinados, entre outros fatores, pelo tamanho das fotos, pelo conteúdo destas, se a foto era coloria ou não.

Veja alguns dos resultados obtidos pela pesquisa Eyes on the news. Por exemplo, o índice de visualização da primeira página de um jornal preparado especialmente para o estudo. Estes números se referem ao “ponto de entrada” na página, ou seja, o ponto em que os leitores começaram a “ler” fotos ou texto.

Os “promo boxes”, chamadas de capa acima dos logotipos dos jornais, tiveram o maior índice de “entrada”.

Outros exemplos de pontos de entrada:

Na última imagem, um resumo do que deve fazer um diagramador:

O que nós exploramos nesta seção deve nos lembrar um simples princípio do design: crie hierarquia. O objeto do bom design de publicaçãoé primeiro atrair o leitor, então guiá-lo através da informação. Muitos jornais abandonam leitores por deixá-los livres para vagar através de campos e florestas do desconhecido. Não admira que tantos leitores fiquem perplexos e eventualmente perdidos. Criando uma hierarquia de movimento através de uma página ou de páginas espelhadas, nós podemos orientá-los e aconselhá-los gentilmente mas efetivamente, estabelecendo uma harmonia de movimento que resulta em compreensão. Para planejar esta viagem para os outros, nós primeiro necessitamos ver o que o leitor vê — neste caso, duas páginas por vez.

Bibliografia

1. GARCIA, Mario; STARK, Pegie. Eyes on the News. St. Petersbourg, Fld. : Poynter Institute for Media Studies, 1991.
2. PLAZA, Julio. Videografia em videotexto. São Paulo : Hucitec, 1986.
3. SILVA, Rafael Souza. Diagramação: o planejamento visual gráfico na comunicação impressa”. São Paulo : Summus Editorial, 1985.
4. YARBUS, Alfred. Eye movements and vision. New York: Plenum Press, 1967.

Nas variações com serifa, sem serifa e monoespaçada, elas podem ser usadas no lugar das “vagabundinhas” Times, Arial e Courier sem que a composição tipográfica fique prejudicada.

Os pontos tipográficos, ainda hoje, são usados para designar o tamanho das letras: quando se diz que uma letra está em corpo 12 significa que sua altura tem 12 pontos tipográficos.

Atualmente, pode-se usar sem problemas o sistema métrico decimal. Os programas modernos, como o PageMaker, InDesign, Scribus, QuarkXPress ou Corel Ventura, podem trabalhar com qualquer medida. Para mudar as medidas, clique com o outro botão do mouse nas réguas. As réguas podem ter medidas diferentes na horizontal e na vertical. Tradicionalmente, em jornais, a publicidade mede-se por sua altura em centímetros. Portanto, a régua vertical pode ficar sempre no padrão “milímetros”, enquanto a régua horizontal fica em paicas.

Além disso, o PageMaker, InDesign, Scribus, QuarkXPress ou Corel Ventura permitem ainda que se coloque em praticamente qualquer campo outra medida além da especificada. Por exemplo: se o campo diz “milímetros”, você pode colocar o valor “11p6″, que o programa entenderá que são onze paicas e meia (lembre-se de que a paica tem 12 pontos; portanto, meia paica são 6 pontos). Você também pode colocar a medida em pontos: “24pt” é igual a “2p” (2 paicas).

Melhor ainda: você pode colocar cálculos em vários campos do PageMaker, InDesign, Scribus, QuarkXPress ou Corel Ventura e de outros programas de editoração mais modernos: “(23p-1p)/2″ colocaria a medida de 11 paicas (23 paicas menos uma — da valeta –, divididas por 2).

Este é um bom truque para dividir precisamente blocos de texto, na criação de colunas falsas. Colunas falsas são colunas que fogem da colunagem básica do jornal. É conveniente usar colunas falsas em notícias pequenas, para quebrar a monotonia das páginas.

Em ambientes Linux, instalar novos módulos no Python do Scribus é fácil, pois o Scribus usa o Python normal do sistema. O que estiver instalado no Python, o Scribus usa. Em Windows, no entanto, a coisa se complica. O Scribus para Windows usa um Python próprio, bem enxuto. Para instalação de novos módulos, deve-se ter alguns cuidados.

Eu consegui instalar as bibliotecas seguindo estes passos:

1. Baixei e instalei o Python 2.4 para Windows.
2. Baixei e instalei as bibliotecas Qt para Windows, versão 4.2.3.
3. Baixei e instalei as bibliotecas PyQt para Windows, versão 4.2.3.

Depois disso, tenho que colocar o conteúdo da pasta \Python25\Lib\site-packages\ para dentro da pasta Scribus, para uso do Python interno deste. Em vez de copiar toda a pasta (coisa que teria de fazer sempre que instalasse novos módulos Python), preferi usar um recurso pouco conhecido do Windows: junções de pastas, ou “link simbólico” de pastas, como é conhecido este recurso em Unix. Isso cria uma pasta \Scribus\lib\site-packages\ que na verdade é a pasta \Python25\lib\site-packages\.

Mas aqui surge um problema típico da Microsoft: o sistema operacional suporta links simbólicos, mas não há ferramentas para fazer isso facilmente. Para criar uma junção (link simbólico) no Windows, tive que usar o utilitário junction, de Mark Russinovich. O download do junction está agora no site da MS, que contratou o genial programador.

A linha de comando para criar um link simbólico de pasta é o seguinte (“x:” é o seu drive, geralmente “C:”):

junction -s "x:\\Arquivos de programas\\Scribus 1.3.4\\libsite-packages" "x:\\Python25\\site-packages"

Assim, qualquer novo módulo que eu instalar no Python normal será instalado no Scripter Python do Scribus.

Para verificar se os módulos foram corretamente instalados, entre no console do Scribus Scripter e digite:

from PyQt4 import Qt

Use a tecla F9 para rodar o programa. Se tudo correr bem, não deverá aparecer nenhuma mensagem.

Na primeira vez que fiz isto, surgiu uma mensagem de erro avisando que o módulo QtDesigner não fora encontrado. Então, desativei este módulo para ver o que acontece. No arquivo \Python25\Lib\site-packages\PyQt4\Qt.py, desativei a linha com o caracter de comentário “#”:

# from PyQt4.QtDesigner import *

O erro sumiu e tudo correu bem. Tenho que investigar se este módulo é necessário, e por que ele não estava disponível.