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

"""
Build a newspaper box story. Ask a bunch of parameters.
By prof. MS. José Antonio Meira da Rocha
mailto:joseantoniomeira@gmail.com
http://meiradarocha.jor.br
License GPL 2.0
2009-06-30a

"""

######################
# Import Python system
######################
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)

from scribus import UNIT_POINTS, UNIT_MILLIMETERS, LINE_SOLID, JOIN_MITTER, BUTTON_OK, ICON_WARNING, mm, pt

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

################################################
# Usuário pode mudar estes parâmetros constantes
################################################
entrecolunasPadrao = 5 # 14.1732pt # 5mm
corpoDoDestaquePadrao = 18  # 18 points
proporcaoDeEntrelinha = 1.2 # Constante cosmogônica para arredondar altura do box do titulo
estiloDoDestaque = "Destaque texto"
estiloDoAutor = "Destaque autor"
espessuraDoFioDoBox = 0.2
corDoFioDoBox = "Vermelho"
percentCorDoFioDoBox = 100
corDoFundoDoBox = "Bege"
percentDoFundoDoBox = 100
aspaEsquerda = '“'
aspaDireita = '”'
corpoDaAspa = 96 #
larguraDaAspa = 15 # mm
alturaDaAspa = corpoDaAspa * mm * 1.3 # size plus interline
fonteDaAspa = "Georgia Regular"
corDaAspa = "Vermelho"
corDoFioDaAspa = "Vermelho"
espessuraDoFioDaAspa = 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 <b>um quadro de destaque</b>\n" \
	+"na área em que você quer montar o destaque."

# Textos para diálogo de pedir corpo do destaque
labelDecorpoDoDestaque = "Corpo do Destaque" #quadroDeAspa
mensagemDecorpoDoDestaque = "<h2>Corpo do destaque</h2><p>Qual o corpo do destaque?</p>" # What the quadroDeAspa size?
#
labelDeValetas = "Valetas"
mensagemDeValetas = "<h2>Valetas</h2><p>Qual o tamanho da valeta?\n(Espaço entrecolunas)"
#
labelDeMontarDestaque = "Montar Destaque"

defaultText = "Destaque de uma frase forte do texto, para chamar atenção e criar um ponto de interesse.\nAutor da frase"

statusMessage = "Rodando o script..."

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

#############################################
# Windows clipboard functions
# http://code.activestate.com/recipes/150115/
# Bugged: Freeze Scribus after script runs
#############################################

#	try:
#import win32clipboard as w
#except ImportError,err:
#	print "This Python script is written for the Windows extensions."
#	print "It should be installed in Scribus Python tree."
#	sys.exit(1)

#try:
#	import win32con,re
#except ImportError,err:
#	print "This Python script is written for the Windows extensions."
#	print "It should be installed in Scribus Python tree."
#	sys.exit(1)

##############################
# Windows clipboard functions
##############################

#def getText(): 
#	w.OpenClipboard() 
#	d=w.GetClipboardData(win32con.CF_TEXT) 
#	w.CloseClipboard() 
#	return d 

#def setText(aType,aString): 
#	w.OpenClipboard()
#	w.EmptyClipboard()
#	w.SetClipboardData(aType,aString) 
#	w.CloseClipboard() 

#def changeClipboardBy(aFunction):
#	result=aFunction(getText().replace('\r\n','\n'))
#	setText(win32con.CF_TEXT,result.replace('\n','\r\n'))

#def paragraph(aString):
#	aString=re.sub(r'(?m)^\s*$','',aString)
#	aString=re.sub(r'(?<!\n)\n(?!\n|$)',' ',aString)
#	return aString

##############################
# Pega tipo do objeto
# Entrada: objeto 
# Retorno:
# 0: nada selecionado
# 2: quadro de Imagem ou renderização
# 4: quadro de Texto
# 5: linha
# 6: grupo ou retângulo
# 7: polígono ou polilinha
# 8: texto em linha
##############################
def getObjectType(name):
	objtype = 0
	itens = scribus.getPageItems()
	for item in itens:
		if item[0] == name:
			objtype = item[1]
			break
	return objtype

#############################################
# Verifica se objeto é de um tipo determinado
#############################################
def isGroup(objeto):
	"""Verifica se o objeto passado como argumento é um grupo.
	Devolve zero se não é grupo ou 6 (tipo grupo)"""
	scribus.deselectAll()
	scribus.selectObject(objeto)
	name = scribus.getSelectedObject(0)
	type = getObjectType(name)
	name = scribus.getSelectedObject(0)[0:5]
	if (type == 6) and (scribus.selectionCount() > 1) and (name == "Group"):
		return type
	else:
		return 0

def isTextFrame(objeto):
	"""Verifica se o objeto passado como argumento é um grupo.
	Devolve zero se não é grupo ou 4 (tipo texto)"""
	scribus.deselectAll()
	scribus.selectObject(objeto)
	name = scribus.getSelectedObject(0)
	type = getObjectType(name)
	if (type == 4):
		return type
	else:
		return 0
		
def isGraphicFrame(objeto):
	"""Verifica se o objeto passado como argumento é um grupo.
	Devolve zero se não é grupo ou 4 (tipo texto)"""
	scribus.deselectAll()
	scribus.selectObject(objeto)
	name = scribus.getSelectedObject(0)
	type = getObjectType(name)
	if (type == 2):
		return type
	else:
		return 0
		

###############
# Aplica Estilo
###############
def aplicaEstilo(estilo,quadro):
	# Tenta aplicar estilo
	try:
		scribus.setStyle(estilo, quadro)
	except:
		scribus.createParagraphStyle(estilo)
		scribus.setStyle(estilo, quadro)
	return quadro

###########################
# Aplica cor de fundo
###########################
def aplicaCorDeFundo(cor,objeto):
	scribus.setFillColor(cor,objeto)
	x = scribus.getFillColor(objeto)
	if x == "None":
		try:
			scribus.defineColor(cor,0,0,0,50)
		except ValueError:
			scribus.messageBox("Criação de cor","Não pude usar este nome como cor: "+cor,ICON_WARNING,BUTTON_OK)
		scribus.setFillColor(cor,objeto)

###########################
# Aplica cor de contorno
###########################
def aplicaCorDeContorno(cor,objeto):
	scribus.setLineColor(cor,objeto)
	x = scribus.getLineColor(objeto)
	if x == "None":
		try:
			scribus.defineColor(cor,0,0,0,255)
		except ValueError:
			scribus.messageBox("Criação de cor","Não pude usar este nome como cor: "+cor,ICON_WARNING,BUTTON_OK)
		scribus.setLineColor(cor,objeto)

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

#######################
# Formata todo o texto
#######################
def formataTexto(quadro):
	"""Formata destaque e autor."""
	
	scribus.deselectAll()
	scribus.selectObject(quadro)
	# Pega todo o texto do quadro
	alltext = scribus.getAllText(quadro) # BUG: não está pegando texto se já tem grupo montado.
	if alltext == "":
		alltext = defaultText
		scribus.setText(defaultText, quadro)
		print alltext
	scribus.deselectAll()
	linhas = alltext.splitlines(1)  # Método Python para devolver lista com linhas do texto e fim-de-parágrafo
	if len(linhas) > 1:
		primeiro = len(unicode(linhas[0])) # unicode() para contar como 1 os caracteres acentuados com mais de 1 byte
		segundo  = len(unicode(linhas[1])) # O comprimento leva em conta o fim de parágrafo
		
		# Aplica estilo Destaque a todo o texto
		inicioDestaque = 0
		comprTexto = len(unicode(alltext))
		scribus.deselectAll()
		scribus.selectText(inicioDestaque, comprTexto-1, quadro)
		aplicaEstilo(estiloDoDestaque, quadro)
		scribus.dehyphenateText() # Tira a hifenização de tudo
		scribus.deselectAll()
		
		# Formata o autor do destaque
		scribus.deselectAll()
		scribus.selectText(primeiro, segundo-1, quadro)
		aplicaEstilo(estiloDoAutor, quadro)
		scribus.deselectAll()

#######################
# Pinta quadro do box
#######################
def pintaQuadroDeDestaque(quadro):
	# Define formatação gráfica do quadro de foto
	scribus.setLineWidth(espessuraDoFioDoBox, quadro)
	aplicaCorDeContorno(corDoFioDoBox, quadro)
	scribus.setLineShade(percentCorDoFioDoBox, quadro)
	scribus.setLineStyle(LINE_SOLID, quadro)
	scribus.setLineJoin(JOIN_MITTER, quadro)
	aplicaCorDeFundo(corDoFundoDoBox, quadro)
	scribus.setFillShade(percentDoFundoDoBox, quadro)

##################################
# Cria quadro de aspas da esquerda
##################################
def criaAspaEsquerda(quadro):
	# Pega as coordenadas X e Y
	esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(quadro)
	# Pega a largura e altura do quadro
	larguraDoQuadro, alturaDoQuadro = scribus.getSize(quadro)
	# Cria quadro de aspa esquerda
	quadroDeAspaEsquerda = scribus.createText(esquerdaDoQuadro, topoDoQuadro, larguraDaAspa, alturaDaAspa)
	# Insere aspa no quadro
	scribus.setText(aspaEsquerda,quadroDeAspaEsquerda)
	# Formata aspa
	scribus.setFontSize(corpoDaAspa,quadroDeAspaEsquerda)
	scribus.setFont(fonteDaAspa,quadroDeAspaEsquerda)
	# Transforma o texto em desenho (trace)
	# O texto traced fica com nome do bloco mais "+0", "+1" etc para cada caracter
	####################################### BUGGED
	# scribus.traceText(quadroDeAspaEsquerda) 
	# BUG SCRIPTER: não está traçando objeto criado por script, que some totalmente 
	# botar função pra conferir se criou objeto (se quadro é pequeno, não cria)
	# quadroDeAspaEsquerda = quadroDeAspaEsquerda+"+0"
	# Reposiciona aspas
	larguraDaAspaEsq, alturaDaAspaEsq = scribus.getSize(quadroDeAspaEsquerda)
	scribus.sizeObject(larguraDaAspaEsq, alturaDaAspaEsq, quadroDeAspaEsquerda)
	scribus.moveObjectAbs(
		esquerdaDoQuadro + entrecolunas, 
		topoDoQuadro + entrecolunas, 
		quadroDeAspaEsquerda)
	return quadroDeAspaEsquerda

#########################
# criaAspaEmLinhaEsquerda
#########################
def criaAspaEmLinhaEsquerda(aspa,quadro):
	# Pega as coordenadas X e Y do quadro de texto
	esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(quadro)
	# Pega a largura e altura do quadro
	larguraDoQuadro, alturaDoQuadro = scribus.getSize(quadro)
	# Transforma o texto das aspas em desenho (trace)
	# O texto traced fica com nome do bloco mais "+0", "+1" etc para cada caracter
	scribus.traceText(aspa) 
	quadroDeAspaEsquerda = aspa+"+0"
	# Reposiciona aspas
	larguraDaAspaEsq, alturaDaAspaEsq = scribus.getSize(quadroDeAspaEsquerda)
	scribus.moveObjectAbs(
		esquerdaDoQuadro + entrecolunas, 
		topoDoQuadro + entrecolunas, 
		quadroDeAspaEsquerda)
	return quadroDeAspaEsquerda

#################################
# Cria quadro de aspas da direita
#################################
def criaAspaDireita(quadro):
	# Pega as coordenadas X e Y
	esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(quadro)
	# Pega a largura e altura do quadro
	larguraDoQuadro, alturaDoQuadro = scribus.getSize(quadro)
	# Cria quadro de aspa esquerda
	quadroDeAspaDireita = scribus.createText(
		esquerdaDoQuadro + larguraDoQuadro - larguraDaAspa, 
		topoDoQuadro, larguraDaAspa, alturaDaAspa
	)
	# Insere aspa no quadro
	scribus.setText(aspaDireita,quadroDeAspaDireita)
	# Formata aspa
	scribus.setFontSize(corpoDaAspa,quadroDeAspaDireita)
	scribus.setFont(fonteDaAspa,quadroDeAspaDireita)
	larguraDaAspaDir, alturaDaAspaDir = scribus.getSize(quadroDeAspaDireita)
	scribus.sizeObject(larguraDaAspaDir, alturaDaAspaDir, quadroDeAspaDireita)
	scribus.moveObjectAbs(
		esquerdaDoQuadro + larguraDoQuadro - larguraDaAspaDir - entrecolunas,
		topoDoQuadro + entrecolunas, quadroDeAspaDireita)
	return quadroDeAspaDireita

#########################
# cria Aspa Em Linha Direita
#########################
def criaAspaEmLinhaDireita(aspa,quadro):
	# Pega as coordenadas X e Y do quadro de texto
	esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(quadro)
	# Pega a largura e altura do quadro
	larguraDoQuadro, alturaDoQuadro = scribus.getSize(quadro)
	# Transforma o texto das aspas em desenho (trace)
	# O texto traced fica com nome do bloco mais "+0", "+1" etc para cada caracter
	scribus.traceText(aspa) 
	quadroDeAspaDireita = aspa+"+0"
	# Reposiciona aspas
	larguraDaAspaDir, alturaDaAspaDir = scribus.getSize(quadroDeAspaDireita)
	scribus.moveObjectAbs(
		esquerdaDoQuadro + larguraDoQuadro - larguraDaAspaDir - entrecolunas,
		topoDoQuadro + entrecolunas, quadroDeAspaDireita)
	return quadroDeAspaDireita

############
# CRIA ASPAS
############
def criaAspas(quadro):
	"""Crias aspas, destruindo as aspas que já existirem."""
	
	scribus.deselectAll()
	scribus.selectObject(quadro)
	if scribus.selectionCount() < 2:  # Se só tem 1 objeto selecionado.
		testTextFrame(quadro) # Dá msg de erro e cai fora se não for texto.
		# quadroDeDestaque é global
		quadroDeDestaque = scribus.getSelectedObject(0)
		scribus.moveSelectionToFront()
		# Cria 2 novos quadros para aspas
		# quadroDeAspaEsquerda e quadroDeAspaDireita são globais
		quadroDeAspaEsquerda = criaAspaEsquerda(quadroDeDestaque)
		quadroDeAspaDireita = criaAspaDireita(quadroDeDestaque)
	else:  # Se não é único, é grupo; presume que já seja um box criado anteriormente.
		# quadroDeDestaque é global
		quadroDeDestaque = scribus.getSelectedObject(1)
		quadroDeAspaEsquerda = scribus.getSelectedObject(2)
		quadroDeAspaDireita = scribus.getSelectedObject(3)
		scribus.unGroupObject(quadro)
		scribus.deselectAll()
		testTextFrame(quadroDeDestaque) # Dá msg de erro e cai fora se não for texto.
		try:
			quadroDeAspaEsquerda = criaAspaEmLinhaEsquerda(quadroDeAspaEsquerda,quadroDeDestaque)
		except: 
			scribus.deleteObject(quadroDeAspaEsquerda)
			quadroDeAspaEsquerda = criaAspaEsquerda(quadroDeDestaque)
		try:
			quadroDeAspaDireita = criaAspaEmLinhaDireita(quadroDeAspaDireita,quadroDeDestaque)
		except:
			scribus.deleteObject(quadroDeAspaDireita)
			quadroDeAspaDireita = criaAspaDireita(quadroDeDestaque)
	return quadroDeAspaEsquerda, quadroDeAspaDireita, quadroDeDestaque

############################
# Testa se é quadro de texto
############################
def testTextFrame(objeto):
	if not isTextFrame(objeto):  # Se não for quadro de texto, avisa e termina
		scribus.messageBox(
			"Selecione quadros de texto",
			"<h2>Selecione quadros de <i>texto</i></h2><p>Selecione <b>quadros de texto</b> para fazer o box.</p>",
			ICON_WARNING,BUTTON_OK)
		scribus.setRedraw(True)
		sys.exit(1)

############################
# Formata quadro de destaque
############################
def formataQuadroDeDestaque(quadro):
	# Define o fluxo de texto como "afastar texto"
	scribus.textFlowMode(quadro, AROUND_FRAME)
	# Aplica formatos gráficos
	pintaQuadroDeDestaque(quadro)
	# Determina espaços entre quadro e texto
	left = entrecolunas
	right = entrecolunas
	top = entrecolunas
	bottom = entrecolunas-1
	scribus.setTextDistances(left, right, top, bottom, quadro)

#########################
# Formata aspas
#########################
def formataAspas(aspa):
	aplicaCorDeFundo(corDaAspa,aspa)
	scribus.textFlowMode(aspa, BOUNDING_BOX)
	scribus.setLineStyle(LINE_SOLID, aspa)
	scribus.setLineJoin(JOIN_MITTER, aspa)
	aplicaCorDeContorno(corDoFioDaAspa, aspa)
	scribus.setLineWidth(espessuraDoFioDaAspa, aspa)

################
# MONTA DESTAQUE
################
def montaDestaque(espacoDoDestaque):
	""" Manipula um bloco de box. 
	Entra com um quadro ou com um grupo de quadro e aspas selecionados.
	"""
	#################################
	# Pede entradas de usuário
	#################################
	global entrecolunas
	entrecolunas = pedeEntrecolunas()

	##########################################
	# Cria ou formata aspas direita e esquerda
	########################################## 
	quadroDeAspaEsquerda,quadroDeAspaDireita,quadroDeDestaque = criaAspas(espacoDoDestaque)
	
	###############
	# Formata aspas
	###############
	formataAspas(quadroDeAspaEsquerda)
	formataAspas(quadroDeAspaDireita)
	
	#######################
	# Formata quadro de box
	#######################
	formataQuadroDeDestaque(quadroDeDestaque)
	
	############################
	# Determina ordem Z 
	# (quadro de título por cima
	# do quadro de colunas)
	############################
	scribus.deselectAll()
	scribus.selectObject(quadroDeDestaque)
	scribus.moveSelectionToFront()
	scribus.deselectAll()
	scribus.selectObject(quadroDeAspaEsquerda)
	scribus.moveSelectionToFront()
	scribus.deselectAll()
	scribus.selectObject(quadroDeAspaDireita)
	scribus.moveSelectionToFront()
	
	#############################
	# Formata os parágrafos
	#############################
	formataTexto(quadroDeDestaque)
	
	# Agrupa titulo e texto
	scribus.deselectAll()
	scribus.selectObject(quadroDeDestaque)
	scribus.selectObject(quadroDeAspaEsquerda)
	scribus.selectObject(quadroDeAspaDireita)
	scribus.groupObjects()
	grupo = scribus.getSelectedObject()
	scribus.textFlowMode(grupo, BOUNDING_BOX)

######################
# MANIPULA SELEÇÃO
######################
def manipulaSelecao():
	""" Gerencia objetos selecionados """
	
	story = scribus.getSelectedObject()
	if not story:
		scribus.messageBox(labelDeMontarDestaque,pedirParaAbrirQuadro,ICON_WARNING,BUTTON_OK)
	else:
		if scribus.selectionCount() > 1:      # se existe algo selecionado
			box1 = scribus.getSelectedObject(0)  # Isto precisa ser pego antes do "if isGroup", senão dá errado
			aspa1 = scribus.getSelectedObject(1)
			aspa2 = scribus.getSelectedObject(2)
			if isGroup(story): # Se for grupo, (0) é o grupo; (1) é o quadro do destaque; (2) e (3), as aspas.
				box1 = scribus.getSelectedObject(1)
				aspa1 = scribus.getSelectedObject(2)
				aspa2 = scribus.getSelectedObject(3)
			else: 
				scribus.deselectAll()
				scribus.selectObject(box1)
				scribus.selectObject(aspa1)?
				scribus.selectObject(aspa2)
				scribus.groupObjects() # A ordem Z vai determinar o primeiro da lista do grupo
			story = scribus.getSelectedObject(0) # pega o 1º objeto: o texto.
		####################
		montaDestaque(story)
		####################
		scribus.docChanged(True)

######################
# MANIPULA DOCUMENTO
######################
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_MILLIMETERS)
		#############################
		# Manipula objeto selecionado
		#############################
		manipulaSelecao()
		
		#Recupera medidas do usuário
		scribus.setUnit(unit)
	else:  # Senão há documento aberto, avisa.
		scribus.messageBox(
		"Abra um documento",
		"<h2>Abra um documento</h2><p>Por favor, abra um documento e selecione um quadro antes de usar este script.</p>",
		ICON_WARNING,
		BUTTON_OK
		)

def main(argv):
	""" Main entry point """
	#########################
	#  USER CODE GOES HERE  #
	#########################
	# Gerencia documento (aberto, abre etc)
	manipulaDocumento()
	#########################
	#  USER CODE ENDS HERE  #
	#########################

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

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