def main(argv):
"""A simple scripts to set baseline grid and matching guides."""
CurrentUnit = scribus.getUnit()
scribus.setUnit(0)
H_Guides = []
GuideHeight = float(scribus.valueDialog('Set BaseLine Grid & Guides', 'Enter value for Grid and Guide Height (pt).', '14.40') )
GuideOffset = float(scribus.valueDialog('Set Grid & Guide Offsets', 'Enter value for Grid and Guide Offset (pt).', '0.0') )
PageWidth, PageHeight = scribus.getPageSize()
NumLoops = math.floor(1 + (PageHeight - GuideOffset) / GuideHeight)
for i in range(int(NumLoops)):
if i > 0:
H_Guides.append(GuideOffset + i * GuideHeight)
scribus.setBaseLine(GuideHeight, GuideOffset)
scribus.setHGuides(scribus.getHGuides() + H_Guides)
scribus.setUnit(CurrentUnit)
scribus.messageBox('Script', '<h3>Script by ugajin</h3><p>Thanks a bunch for using setBaselineGuides and Scribus!</p><p>[email protected]</p>', scribus.ICON_INFORMATION, scribus.BUTTON_OK, scribus.BUTTON_CANCEL)
def draw(self, tolevel):
contents = []
for (label,level,page) in self.sections:
if level <= tolevel:
text = label + chr(TAB) + str(page)
style = "Contents" + str(level)
contents.append((text,style))
page = self.contentspage
scribus.gotoPage(page)
(width,height) = scribus.getPageSize()
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width-right-left, TITLESIZE)
insertTextWithStyle("Contents","Title",frame)
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
for (text,style) in contents:
insertTextWithStyle(text,style,frame)
if scribus.textOverflows(frame):
oldframe = frame
page = page + 1
scribus.gotoPage(page)
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
scribus.linkTextFrames(oldframe,frame)
def copyPlayer(sourceName, destinationName):
if scribus.objectExists(sourceName):
doc = scribus.getDocName()
unit = scribus.getUnit()
(PageWidth, PageHeight) = scribus.getPageSize()
(iT, iI, iO, iB) = scribus.getPageMargins()
NewPagepoint = PageHeight - iT - iB
player = scribus.selectObject(sourceName)
#Duplicate the object...
scribus.duplicateObject(sourceName)
x = scribus.getSelectedObject()
newObjectName = str(x)
size = scribus.getSize(newObjectName)
scribus.moveObject(0, size[1], newObjectName)
(x, y) = scribus.getPosition(newObjectName)
scribus.setRedraw(1)
scribus.docChanged(1)
if (y + size[1] > NewPagepoint):
currentPage = scribus.currentPage()
scribus.newPage(-1)
newPage = currentPage + 1
scribus.copyObject(newObjectName)
scribus.deleteObject(newObjectName)
scribus.gotoPage(newPage)
scribus.pasteObject(newObjectName)
scribus.moveObjectAbs(iO, iT, newObjectName)
scribus.setNewName(destinationName, sourceName)
scribus.setNewName(sourceName, newObjectName)
def resizeFrame(self, frame):
'''Resize a frame in place so that it fits the text inside it.
Code for this was take from:
http://wiki.scribus.net/canvas/Adjust_a_text_frame_to_fit_its_content'''
# Now adjust the frame to fit the text
# get some page and frame measure
(x, ph) = scribus.getPageSize()
(x, x, x, pm) = scribus.getPageMargins()
# warning: gets the margins from document setup not for the current page
(x, y) = scribus.getPosition(frame)
bottom = (ph - pm) - y
(w, h) = scribus.getSize(frame)
# if the frame doesn't overflow, shorten it to make it overflow
while (((scribus.textOverflows(frame) == 0) or (h > bottom))
and (h > 0)):
h -= 10
scribus.sizeObject(w, h, frame)
# resize the frame in 10pt steps
while ((scribus.textOverflows(frame) > 0) and (h < bottom)):
h += 10
scribus.sizeObject(w, h, frame)
# undo the latest 10pt step and fine adjust in 1pt steps
h -= 10
scribus.sizeObject(w, h, frame)
while ((scribus.textOverflows(frame) > 0) and (h < bottom)):
h += 1
scribus.sizeObject(w, h, frame)
# For vertical sizing operations return the frame height
return int(scribus.getSize(frame)[1])
def addWatermark(self):
'''Create a Draft watermark layer. This was taken from:
http://wiki.scribus.net/canvas/Adding_%27DRAFT%27_to_a_document'''
L = len(self.watermark) # The length of the word
# will determine the font size
scribus.defineColor("gray", 11, 11, 11, 11) # Set your own color here
u = scribus.getUnit() # Get the units of the document
al = scribus.getActiveLayer() # Identify the working layer
scribus.setUnit(
scribus.UNIT_MILLIMETERS) # Set the document units to mm,
(w, h) = scribus.getPageSize() # needed to set the text box size
scribus.createLayer("c")
scribus.setActiveLayer("c")
T = scribus.createText(w / 6, 6 * h / 10, h,
w / 2) # Create the text box
scribus.setText(self.watermark, T) # Insert the text
scribus.setTextColor("gray", T) # Set the color of the text
scribus.setFontSize(
(w / 210) * (180 - 10 * L),
T) # Set the font size according to length and width
scribus.rotateObject(45, T) # Turn it round antclockwise 45 degrees
scribus.setUnit(u) # return to original document units
# FIXME: It would be nice if we could move the watermark box down to the lowest layer so
# that it is under all the page text. Have not found a method to do this. For now we just
# plop the watermark on top of everything else.
scribus.setActiveLayer(al) # return to the original active layer
def drawHeaderFooter(pagetitle):
"""draw some info on the pages"""
# get page size
pageSize=scribus.getPageSize()
pageWidth=pageSize[0]
pageHeight=pageSize[1]
#pageMargins
pageMargins=scribus.getPageMargins()
topMargin=pageMargins[0]
leftMargin=pageMargins[1]
rightMargin=pageMargins[2]
bottomMargin=pageMargins[3]
#create textbox and insert text for header
textbox=scribus.createText(leftMargin, topMargin, pageWidth-leftMargin-rightMargin, HEADERSIZE)
#set proper font size and alignment
scribus.setFontSize(18, textbox)
scribus.setTextAlignment(scribus.ALIGN_CENTERED, textbox)
#load the string into the textbox
headerstring=pagetitle
scribus.insertText(headerstring, 0, textbox)
scribus.setTextColor("Black", textbox)
#create textbox and insert text for footer
textbox=scribus.createText(leftMargin, pageHeight-bottomMargin-FOOTERSIZE, pageWidth-leftMargin-rightMargin, FOOTERSIZE)
#set proper font size and alignment
scribus.setFontSize(9, textbox)
scribus.setTextAlignment(scribus.ALIGN_LEFT, textbox)
#load the string into the textbox
footerstring="Created using ColorChart.py V %s script for Scribus by Sebastian Stetter - http://www.sebastianstetter.de" % str(__version__)
scribus.insertText(footerstring, 0, textbox)
scribus.setTextColor("Black", textbox)
def drawIndexByName(self):
contents = {}
climbnames = []
for (route, grade, stars, crag, page) in self.climbs:
text = route + chr(TAB) + str(page)
contents[route] = (text, "Index")
climbnames.append(route)
climbnames.sort()
(width, height) = scribus.getPageSize()
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width - right - left, TITLESIZE)
insertTextWithStyle("Index by Route Name", "Title", frame)
frame = scribus.createText(left, top + TITLESIZE, width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
for route in climbnames:
(text, style) = contents[route]
insertTextWithStyle(text, style, frame)
if scribus.textOverflows(frame):
oldframe = frame
scribus.newPage(-1)
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top + TITLESIZE,
width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
scribus.linkTextFrames(oldframe, frame)
def resizeFrame (self, frame) :
'''Resize a frame in place so that it fits the text inside it.
Code for this was take from:
http://wiki.scribus.net/canvas/Adjust_a_text_frame_to_fit_its_content'''
# Now adjust the frame to fit the text
# get some page and frame measure
(x, ph) = scribus.getPageSize();
(x, x, x, pm) = scribus.getPageMargins(); # warning: gets the margins from document setup not for the current page
(x, y) = scribus.getPosition(frame)
bottom = (ph - pm) - y
(w, h) = scribus.getSize(frame)
# if the frame doesn't overflow, shorten it to make it overflow
while (((scribus.textOverflows(frame) == 0) or (h > bottom)) and (h > 0)) :
h -= 10
scribus.sizeObject(w, h, frame)
# resize the frame in 10pt steps
while ((scribus.textOverflows(frame) > 0) and (h < bottom)) :
h += 10
scribus.sizeObject(w, h, frame)
# undo the latest 10pt step and fine adjust in 1pt steps
h -= 10
scribus.sizeObject(w, h, frame)
while ((scribus.textOverflows(frame) > 0) and (h < bottom)) :
h += 1
scribus.sizeObject(w, h, frame)
# For vertical sizing operations return the frame height
return int(scribus.getSize(frame)[1])
def addWatermark (self) :
'''Create a Draft watermark layer. This was taken from:
http://wiki.scribus.net/canvas/Adding_%27DRAFT%27_to_a_document'''
L = len(self.watermark) # The length of the word
# will determine the font size
scribus.defineColor("gray", 11, 11, 11, 11) # Set your own color here
u = scribus.getUnit() # Get the units of the document
al = scribus.getActiveLayer() # Identify the working layer
scribus.setUnit(scribus.UNIT_MILLIMETERS) # Set the document units to mm,
(w,h) = scribus.getPageSize() # needed to set the text box size
scribus.createLayer("c")
scribus.setActiveLayer("c")
T = scribus.createText(w/6, 6*h/10 , h, w/2) # Create the text box
scribus.setText(self.watermark, T) # Insert the text
scribus.setTextColor("gray", T) # Set the color of the text
scribus.setFontSize((w/210)*(180 - 10*L), T) # Set the font size according to length and width
scribus.rotateObject(45, T) # Turn it round antclockwise 45 degrees
scribus.setUnit(u) # return to original document units
# FIXME: It would be nice if we could move the watermark box down to the lowest layer so
# that it is under all the page text. Have not found a method to do this. For now we just
# plop the watermark on top of everything else.
scribus.setActiveLayer(al) # return to the original active layer
def main(argv):
"""A simple scripts to set baseline grid and matching guides."""
CurrentUnit = scribus.getUnit()
scribus.setUnit(0)
H_Guides = []
GuideHeight = float(
scribus.valueDialog('Set BaseLine Grid & Guides',
'Enter value for Grid and Guide Height (pt).',
'14.40'))
GuideOffset = float(
scribus.valueDialog('Set Grid & Guide Offsets',
'Enter value for Grid and Guide Offset (pt).',
'0.0'))
PageWidth, PageHeight = scribus.getPageSize()
NumLoops = math.floor(1 + (PageHeight - GuideOffset) / GuideHeight)
for i in range(int(NumLoops)):
if i > 0:
H_Guides.append(GuideOffset + i * GuideHeight)
scribus.setBaseLine(GuideHeight, GuideOffset)
scribus.setHGuides(scribus.getHGuides() + H_Guides)
scribus.setUnit(CurrentUnit)
scribus.messageBox(
'Script',
'<h3>Script by ugajin</h3><p>Thanks a bunch for using setBaselineGuides and Scribus!</p><p>[email protected]</p>',
scribus.ICON_INFORMATION, scribus.BUTTON_OK, scribus.BUTTON_CANCEL)
def drawIndexByName(self):
contents = {}
climbnames = []
for (route, grade, stars, crag, page) in self.climbs:
text = route + chr(TAB) + str(page)
contents[route] = (text,"Index")
climbnames.append(route)
climbnames.sort()
(width,height) = scribus.getPageSize()
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width-right-left, TITLESIZE)
insertTextWithStyle("Index by Route Name","Title",frame)
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
for route in climbnames:
(text,style) = contents[route]
insertTextWithStyle(text,style,frame)
if scribus.textOverflows(frame):
oldframe = frame
scribus.newPage(-1)
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
scribus.linkTextFrames(oldframe,frame)
def draw(self, tolevel):
contents = []
for (label, level, page) in self.sections:
if level <= tolevel:
text = label + chr(TAB) + str(page)
style = "Contents" + str(level)
contents.append((text, style))
page = self.contentspage
scribus.gotoPage(page)
(width, height) = scribus.getPageSize()
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width - right - left, TITLESIZE)
insertTextWithStyle("Contents", "Title", frame)
frame = scribus.createText(left, top + TITLESIZE, width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
for (text, style) in contents:
insertTextWithStyle(text, style, frame)
if scribus.textOverflows(frame):
oldframe = frame
page = page + 1
scribus.gotoPage(page)
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top + TITLESIZE,
width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
scribus.linkTextFrames(oldframe, frame)
def setText(self, txt):
if self.txt != txt:
self.y = self.y + 10
(pagewidth, pageheight) = scribus.getPageSize()
self.txt = txt
self.height = len(self.txt) * 2 + 10
if self.y + self.height > pageheight:
self.y = 10
def setText(self,txt):
if self.txt != txt:
self.y = self.y + 10
(pagewidth,pageheight) = scribus.getPageSize()
self.txt = txt
self.height = len(self.txt) * 2 + 10
if self.y + self.height > pageheight:
self.y = 10
def __init__(self):
(self.pagewidth, self.pageheight) = scribus.getPageSize()
(self.topmargin, self.leftmargin, self.rightmargin, self.bottommargin) = getCurrentPageMargins()
self.frame = None
self.textframes = []
self.imageframes = []
self.sidebar = SideBar()
self.imagebuffer = []
self.columns = 1
def __init__(self):
(self.pagewidth, self.pageheight) = scribus.getPageSize()
(self.topmargin, self.leftmargin, self.rightmargin,
self.bottommargin) = getCurrentPageMargins()
self.frame = None
self.textframes = []
self.imageframes = []
self.sidebar = SideBar()
self.imagebuffer = []
self.columns = 1
def main(argv):
rectColor = "Black"
topMargin, leftMargin, rightMargin, bottomMargin = scribus.getPageMargins()
pageWidth, pageHeight = scribus.getPageSize()
printAreaWidth = pageWidth - leftMargin - rightMargin
printAreaHeight = pageHeight - topMargin - bottomMargin
vertRectW = random.randrange(2,4)
vertRectH = random.randrange(48,50)
horRectW = random.randrange(47,49)
horRectH = random.randrange(2,5)
startx = leftMargin
endx = pageWidth - leftMargin - horRectW
starty = topMargin
endy = pageHeight - topMargin - vertRectH
numberRectVert = random.randrange(400,600)
numberRectHor = random.randrange(400,600)
opacity = 0
scribus.progressTotal(numberRectVert+numberRectHor)
scribus.setRedraw(False)
for i in range(1, numberRectVert):
opacity = opacity + 0.002
xpos = random.randrange(int(startx),int(endx))
ypos = random.randrange(int(starty),int(endy))
rect = scribus.createRect(xpos, ypos, vertRectW, vertRectH)
scribus.setFillColor(rectColor, rect)
scribus.setLineColor("None", rect)
if opacity < 1:
scribus.setFillTransparency(opacity, rect)
scribus.progressSet(i*2)
for i in range(1, numberRectVert):
opacity = opacity + 0.002
xpos = random.randrange(int(startx),int(endx))
ypos = random.randrange(int(starty),int(endy))
recthor = scribus.createRect(xpos, ypos, horRectW, horRectH)
scribus.setFillColor(rectColor, recthor)
scribus.setLineColor("None", recthor)
if opacity < 1:
scribus.setFillTransparency(opacity, recthor)
scribus.progressReset()
scribus.docChanged(True)
scribus.statusMessage("Done")
scribus.setRedraw(True)
def get_settings_from_document(ignore_margins=True):
scribus.setUnit(scribus.UNIT_MILLIMETERS)
global page_size, page_margins_right, page_margins_left
page_size = scribus.getPageSize()
if ignore_margins:
page_margins_right = (0, 0, 0, 0)
else:
page_margins_right = scribus.getPageMargins()
page_margins_left = (page_margins_right[0], page_margins_right[2], page_margins_right[1], page_margins_right[3])
calc_max()
def get_settings_from_document(ignore_margins=True):
scribus.setUnit(scribus.UNIT_MILLIMETERS)
global page_size, page_margins_right, page_margins_left
page_size = scribus.getPageSize()
if ignore_margins:
page_margins_right = (0, 0, 0, 0)
else:
page_margins_right = scribus.getPageMargins()
page_margins_left = (page_margins_right[0], page_margins_right[2],
page_margins_right[1], page_margins_right[3])
calc_max()
def drawPlaceholders():
page = scribus.getPageSize()
margin = scribus.getPageMargins()
# add the page margins
rectangle = scribus.createRect(margin[1], margin[0],
(page[0] - margin[1] - margin[2]),
(page[1] - margin[0] - margin[3]))
scribus.setFillColor('none', rectangle)
scribus.setLineColor('Blue', rectangle)
scribus.setLineWidth(0.4, rectangle)
# add horizontal and vertical guides
for item in scribus.getHGuides():
line = scribus.createLine(0, item, page[0], item)
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.6, line)
scribus.setLineStyle(scribus.LINE_DASHDOT, line)
for item in scribus.getVGuides():
line = scribus.createLine(item, 0, item, page[0])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.6, line)
scribus.setLineStyle(scribus.LINE_DASHDOT, line)
# add a "crossed frame" for missing images
for item in scribus.getAllObjects():
if scribus.getObjectType(item) == 'ImageFrame':
image = scribus.getImageFile(item)
if image == '':
pos = scribus.getPosition(item)
size = scribus.getSize(item)
rectangle = scribus.createRect(pos[0], pos[1], size[0],
size[1])
scribus.setFillColor('none', rectangle)
scribus.setLineColor('Black', rectangle)
scribus.setLineWidth(0.4, rectangle)
line = scribus.createLine(pos[0], pos[1], pos[0] + size[0],
pos[1] + size[1])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.4, line)
line = scribus.createLine(pos[0], pos[1] + size[1],
pos[0] + size[0], pos[1])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.4, line)
def drawIndexByGrade(self):
grades = []
climbsatgrade = {}
for (route, gradestr, stars, crag, page) in self.climbs:
grade = (" " + gradestr.replace("?", "")).center(3, " ")
if grade != " " and route[-5:] != ", The":
if not grade in grades: grades.append(grade)
routename = route + " " + stars
if not grade in climbsatgrade:
climbsatgrade[grade] = [(routename, page)]
else:
climbsatgrade[grade] = climbsatgrade[grade] + [
(routename, page)
]
grades.sort()
(width, height) = scribus.getPageSize()
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width - right - left, TITLESIZE)
insertTextWithStyle("Index by Grade", "Title", frame)
frame = scribus.createText(left, top + TITLESIZE, width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
for grade in grades:
insertTextWithStyle("Grade " + grade, "IndexGrade", frame)
for climb in climbsatgrade[grade]:
(route, page) = climb
text = route + chr(TAB) + str(page)
insertTextWithStyle(text, "Index", frame)
if scribus.textOverflows(frame):
oldframe = frame
scribus.newPage(-1)
(top, left, right, bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top + TITLESIZE,
width - right - left,
height - top - bottom - TITLESIZE)
scribus.setColumns(2, frame)
scribus.setColumnGap(COLUMNGAP, frame)
scribus.linkTextFrames(oldframe, frame)
def insert_text_frame():
page_size = scribus.getPageSize()
page_margins_right = scribus.getPageMargins()
page_margins_left = (page_margins_right[0], page_margins_right[2], page_margins_right[1], page_margins_right[3])
if (scribus.currentPage() % 2) == 1:
page_margins = page_margins_right
else:
page_margins = page_margins_left
name = 'test%d' % random.randint(100, 999)
# x, y, width, height
scribus.createText(page_margins[0],
page_margins[1],
page_size[0] - (page_margins[0] + page_margins[2]),
page_size[1] - (page_margins[1] + page_margins[3]),
name)
scribus.setText("test", name)
def draw(self):
if self.txt != "":
if scribus.currentPage() % 2 == 0:
r = scribus.createRect(-1,self.y,8,self.height)
t = scribus.createText(2,self.y + self.height,self.height,6)
else:
(pagewidth, pageheight) = scribus.getPageSize()
r = scribus.createRect(pagewidth-7,self.y,8,self.height)
t = scribus.createText(pagewidth-5,self.y + self.height,self.height,6)
scribus.setFillColor("Black",r)
scribus.setFillShade(20,r)
scribus.setLineColor("None",r)
scribus.setCornerRadius(ROUNDS,r)
scribus.insertText(self.txt, -1, t)
scribus.deselectAll()
scribus.selectObject(t)
scribus.selectText(0, len(self.txt), t)
scribus.setStyle("Sidebar", t)
scribus.rotateObject(90,t)
self.frames.append(r)
self.frames.append(t)
def drawPlaceholders():
page = scribus.getPageSize()
margin = scribus.getPageMargins()
# add the page margins
rectangle = scribus.createRect(margin[1], margin[0], (page[0] - margin[1] - margin[2]), (page[1] - margin[0] - margin[3]))
scribus.setFillColor('none', rectangle)
scribus.setLineColor('Blue', rectangle)
scribus.setLineWidth(0.4, rectangle)
# add horizontal and vertical guides
for item in scribus.getHGuides():
line = scribus.createLine(0, item , page[0], item)
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.6, line)
scribus.setLineStyle(scribus.LINE_DASHDOT, line)
for item in scribus.getVGuides():
line = scribus.createLine(item, 0 , item, page[0])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.6, line)
scribus.setLineStyle(scribus.LINE_DASHDOT, line)
# add a "crossed frame" for missing images
for item in scribus.getAllObjects():
if scribus.getObjectType(item) == 'ImageFrame':
image = scribus.getImageFile(item)
if image == '':
pos = scribus.getPosition(item)
size = scribus.getSize(item)
rectangle = scribus.createRect(pos[0], pos[1], size[0], size[1])
scribus.setFillColor('none', rectangle)
scribus.setLineColor('Black', rectangle)
scribus.setLineWidth(0.4, rectangle)
line = scribus.createLine(pos[0], pos[1] , pos[0] + size[0], pos[1] + size[1])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.4, line)
line = scribus.createLine(pos[0], pos[1] + size[1], pos[0] + size[0], pos[1])
scribus.setLineColor('Black', line)
scribus.setLineWidth(0.4, line)
def draw(self):
if self.txt != "":
if scribus.currentPage() % 2 == 0:
r = scribus.createRect(-1, self.y, 8, self.height)
t = scribus.createText(2, self.y + self.height, self.height, 6)
else:
(pagewidth, pageheight) = scribus.getPageSize()
r = scribus.createRect(pagewidth - 7, self.y, 8, self.height)
t = scribus.createText(pagewidth - 5, self.y + self.height,
self.height, 6)
scribus.setFillColor("Black", r)
scribus.setFillShade(20, r)
scribus.setLineColor("None", r)
scribus.setCornerRadius(ROUNDS, r)
scribus.insertText(self.txt, -1, t)
scribus.deselectAll()
scribus.selectObject(t)
scribus.selectText(0, len(self.txt), t)
scribus.setStyle("Sidebar", t)
scribus.rotateObject(90, t)
self.frames.append(r)
self.frames.append(t)
def drawIndexByGrade(self):
grades = []
climbsatgrade = {}
for (route, gradestr, stars, crag, page) in self.climbs:
grade = (" " + gradestr.replace("?","")).center(3," ")
if grade != " " and route[-5:] != ", The":
if not grade in grades: grades.append(grade)
routename = route + " " + stars
if not grade in climbsatgrade:
climbsatgrade[grade] = [(routename,page)]
else:
climbsatgrade[grade] = climbsatgrade[grade] + [(routename,page)]
grades.sort()
(width,height) = scribus.getPageSize()
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top, width-right-left, TITLESIZE)
insertTextWithStyle("Index by Grade","Title",frame)
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
for grade in grades:
insertTextWithStyle("Grade " + grade,"IndexGrade",frame)
for climb in climbsatgrade[grade]:
(route,page) = climb
text = route + chr(TAB) + str(page)
insertTextWithStyle(text,"Index",frame)
if scribus.textOverflows(frame):
oldframe = frame
scribus.newPage(-1)
(top,left,right,bottom) = getCurrentPageMargins()
frame = scribus.createText(left, top+TITLESIZE, width-right-left, height-top-bottom-TITLESIZE)
scribus.setColumns(2,frame)
scribus.setColumnGap(COLUMNGAP,frame)
scribus.linkTextFrames(oldframe,frame)
def main(argv):
###########################################
scribus.newDocDialog()
if scribus.haveDoc:
scribus.setUnit(scribus.UNIT_MILLIMETERS)
(w, h) = scribus.getPageSize()
###################
# ask for workdir
workdir = scribus.fileDialog("Open directory with images",
"",
haspreview=False,
issave=False,
isdir=True)
#workdir = "/media/sda7/StudioSession3/PDFTools/pics"
#workdir = "/media/sda7/ISG/Itex/PhotoVisit/Boilerroom"
# file filter
filefilter = scribus.valueDialog(
"File filter",
"File filter examples: \n\n* or *.* = add all files\n*.jpg = add .jpg files only\nIMG_*.* = add all files starting with IMG_\n\nThis filter is case sensitive!",
"*.*")
# get image paths
filelist = sorted(glob.glob(os.path.join(workdir, filefilter)))
#scribus.messageBox("Help", str(filelist))
# count files
filesinworkdir = len(filelist)
#scribus.messageBox("Help", str(filesinworkdir))
#messagebar text
scribus.messagebarText("Importing images...")
#error
if filesinworkdir == 0:
scribus.messageBox("Error", "This directory is empty.")
sys.exit()
# add filename text?
addfilenames = scribus.messageBox("Import images",
"Files found in workdir : " +
str(filesinworkdir) +
"\n\nAdd file names to images?",
button1=scribus.BUTTON_YES,
button2=scribus.BUTTON_NO)
#create text layer
if addfilenames == 16384:
activelayer = scribus.getActiveLayer()
scribus.createLayer("Filenames")
scribus.setActiveLayer(activelayer)
#progressbar max
scribus.progressTotal(filesinworkdir)
page = 1
#create page, add and load image
for i in filelist:
scribus.progressSet(page)
scribus.gotoPage(page)
scribus.createImage(0, 0, w, h, "imagename" + str(page))
scribus.loadImage(filelist[page - 1], "imagename" + str(page))
scribus.setScaleImageToFrame(True,
proportional=True,
name="imagename" + str(page))
#scribus.setImageOffset(0, 0, "imagename"+str(page))
#scribus.setScaleFrameToImage(name="imagename"+str(page))
# add filename on page?
if addfilenames == 16384:
scribus.setActiveLayer("Filenames")
filename = scribus.createText(2, 2, 50, 10, filelist[page - 1])
scribus.setText(os.path.basename(filelist[page - 1]), filename)
scribus.setTextColor("White", filename)
scribus.setActiveLayer(activelayer)
scribus.newPage(-1)
page += 1
#delete last blank page
scribus.deletePage(filesinworkdir + 1)
def main(argv):
unit = scribus.getUnit()
units = ['pts','mm','inches','picas','cm','ciceros']
unitlabel = units[unit]
# get page size
pagesize = scribus.getPageSize()
# ask for layout style
layout_style = scribus.valueDialog("Select Mirror", layout_text, "v")
if layout_style == "":
sys.exit()
# v = vertical mirror
if layout_style == "v":
# warn and exit if no selection
if scribus.selectionCount() == 0:
scribus.messageBox("Error", "Select an object first!", icon=scribus.ICON_WARNING)
sys.exit()
#create mirror guides
scribus.setVGuides(scribus.getHGuides() + [pagesize[0]/2])
#get selected object
selection_name = scribus.getSelectedObject(0)
objectpos = scribus.getPosition(selection_name)
objectsize = scribus.getSize(selection_name)
#duplicate object
scribus.duplicateObject(selection_name)
#move object
newobjectpos = (pagesize[0] - (objectpos[0] + objectsize[0]) , objectpos[1])
scribus.moveObjectAbs(newobjectpos[0], objectpos[1], selection_name)
#flip object
scribus.flipObject(1,0,selection_name)
# h = horizontal mirror
if layout_style == "h":
# warn and exit if no selection
if scribus.selectionCount() == 0:
scribus.messageBox("Error", "Select an object first!", icon=scribus.ICON_WARNING)
sys.exit()
#create mirror guides
scribus.setHGuides(scribus.getHGuides() + [pagesize[1]/2])
#get selected object
selection_name = scribus.getSelectedObject(0)
objectpos = scribus.getPosition(selection_name)
objectsize = scribus.getSize(selection_name)
#duplicate object
scribus.duplicateObject(selection_name)
#move object
newobjectpos = (objectpos[0] , pagesize[1] - (objectpos[1] + objectsize[1]))
scribus.moveObjectAbs(objectpos[0], newobjectpos[1], selection_name)
#flip object
scribus.flipObject(0,1,selection_name)
if not hasLeftTopMark or not hasRightTopMark:
scribus.messageBox('Error', "Document should have left_top_mark and right_top_mark or starts with left_top_mark_offset_ and right_top_mark_offset_ with suffix in mm to measure current spine width. Read more at https://litvinovg.pro/scribus-spine-width.html", scribus.ICON_WARNING, scribus.BUTTON_OK)
sys.exit(1)
newSpineWidth = scribus.valueDialog('Spine width','Set spine width in mm.')
if newSpineWidth == "0":
scribus.messageBox('Error', "Spine width could not be zero.", scribus.ICON_WARNING, scribus.BUTTON_OK)
sys.exit(1)
newWidth = float(newSpineWidth.replace(',','.'))
if newWidth < 0:
scribus.messageBox('Error', "Spine width could not be negative", scribus.ICON_WARNING, scribus.BUTTON_OK)
sys.exit(1)
#set units to mm
scribus.setUnit(1)
PageX,PageY = scribus.getPageSize()
leftX, leftY = scribus.getPosition(leftSpineMarker)
rightX, rightY = scribus.getPosition(rightSpineMarker)
curSpineWidth = rightX - leftX - leftOffset - rightOffset
spineWidthDiff = newWidth - curSpineWidth
halfWidthDiff = spineWidthDiff / 2
vGuides = [(PageX/2), (PageX/2 + newWidth/2), (PageX/2 - newWidth/2)]
hGuides = []
for item in pageItems:
if item[0].startswith('spine_background'):
X,Y = scribus.getPosition(item[0])
hasSpineBackground = True
Xsize,Ysize = scribus.getSize(item[0])
def main(argv):
unit = scribus.getUnit()
units = ['pts', 'mm', 'inches', 'picas', 'cm', 'ciceros']
unitlabel = units[unit]
#layout_style = ""
#frame = 3
#border = 3
# layout style
layout_style = scribus.valueDialog("Layout Style", layout_text, mylayout)
if layout_style == "h":
scribus.messageBox("Help", help_text)
sys.exit()
if layout_style == "v":
createDefaultVal()
sys.exit()
if layout_style == "":
sys.exit()
# frame
frame_str = scribus.valueDialog(
"Set Page Frame", "Set page frame size (" + unitlabel +
") :\n(positive for page margin,\nnegative for page bleed)\n", myframe)
if frame_str != "":
frame = float(frame_str)
else:
sys.exit()
# border
if int(layout_style) > 1:
border_str = scribus.valueDialog(
"Add Image Border",
"Add border around images (" + unitlabel + ") :\n", myborder)
if border_str != "":
border = float(border_str)
else:
sys.exit()
else:
border = 0
bleed = -frame
# get page size
xysize = scribus.getPageSize()
size = (xysize[0] + 2 * bleed, xysize[1] + 2 * bleed)
#scribus.createImage(0, 0, size[0]/2, size[1]/2)
# layouts
# one image on two pages (put it on the left page)
if layout_style == "0":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
(size[0] * 2) - border - bleed * 2,
size[1] - border)
# one image on one full page
if layout_style == "1":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] - border * 2, size[1] - border * 2)
# two vertical images
if layout_style == "2":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] - border * 2)
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
#scribus.setHGuides([size[1]/2-border-bleed, size[1]/2+border-bleed])
# two horizontal images
if layout_style == "22":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] - border * 2, size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] - border * 2, size[1] / 2 - border * 2)
#guides
#scribus.setVGuides([size[0]/2-border-bleed, size[0]/2+border-bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# one vertical image left, two horizontal images right
if layout_style == "3":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] - border * 2)
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed,
size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# one vertical image left, two horizontal images right
if layout_style == "33":
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] - border * 2)
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# one image on top, two images on bottom
if layout_style == "333":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] - border * 2, size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed,
size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# one image on top, two images on bottom
if layout_style == "3333":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# four horizontal images
if layout_style == "4":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed,
size[1] / 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# six images 3 + 3
if layout_style == "6":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 3 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 3 + border - bleed, 0 + border - bleed,
size[0] / 3 - border * 2, size[1] / 2 - border * 2)
scribus.createImage((size[0] / 3) * 2 + border - bleed,
0 + border - bleed, size[0] / 3 - border * 2,
size[1] / 2 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 2 - border * 2)
scribus.createImage(size[0] / 3 + border - bleed,
size[1] / 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 2 - border * 2)
scribus.createImage((size[0] / 3) * 2 + border - bleed,
size[1] / 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 2 - border * 2)
#guides
scribus.setVGuides([
size[0] / 3 - border - bleed, size[0] / 3 - bleed + border,
(size[0] / 3) * 2 - border - bleed,
(size[0] / 3) * 2 + border - bleed
])
scribus.setHGuides(
[size[1] / 2 - border - bleed, size[1] / 2 + border - bleed])
# six images 2 +2 + 2
if layout_style == "66":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed, 0 + border - bleed,
size[0] / 2 - border * 2,
(size[1] / 3) - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 3 + border - bleed,
size[0] / 2 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed,
size[1] / 3 + border - bleed,
size[0] / 2 - border * 2,
(size[1] / 3) - border * 2)
scribus.createImage(0 + border - bleed,
(size[1] / 3) * 2 + border - bleed,
size[0] / 2 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 2 + border - bleed,
(size[1] / 3) * 2 + border - bleed,
size[0] / 2 - border * 2,
(size[1] / 3) - border * 2)
#guides
scribus.setVGuides(
[size[0] / 2 - border - bleed, size[0] / 2 + border - bleed])
scribus.setHGuides([
size[1] / 3 - border - bleed, size[1] / 3 + border - bleed,
(size[1] / 3) * 2 - border - bleed,
(size[1] / 3) * 2 + border - bleed
])
# nine images
if layout_style == "9":
scribus.createImage(0 + border - bleed, 0 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 3 + border - bleed, 0 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage((size[0] / 3) * 2 + border - bleed,
0 + border - bleed, size[0] / 3 - border * 2,
size[1] / 3 - border * 2)
scribus.createImage(0 + border - bleed, size[1] / 3 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 3 + border - bleed,
size[1] / 3 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage((size[0] / 3) * 2 + border - bleed,
size[1] / 3 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(0 + border - bleed,
(size[1] / 3) * 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage(size[0] / 3 + border - bleed,
(size[1] / 3) * 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
scribus.createImage((size[0] / 3) * 2 + border - bleed,
(size[1] / 3) * 2 + border - bleed,
size[0] / 3 - border * 2, size[1] / 3 - border * 2)
#guides
scribus.setVGuides([
size[0] / 3 - border - bleed, size[0] / 3 - bleed + border,
(size[0] / 3) * 2 - border - bleed,
(size[0] / 3) * 2 + border - bleed
])
scribus.setHGuides([
size[1] / 3 - border - bleed, size[1] / 3 + border - bleed,
(size[1] / 3) * 2 - border - bleed,
(size[1] / 3) * 2 + border - bleed
])
def main(argv):
if not scribus.haveDoc():
sys.exit(1)
os.chdir(os.path.expanduser("~"))
####
#### If you have a different location of your laidout program change it here:
####
laidoutexecutable = "/usr/bin/laidout"
if os.path.exists(laidoutexecutable) == False:
laidoutexecutable = "/usr/local/bin/laidout"
if os.path.exists(laidoutexecutable) == False:
print "Could not find Laidout!"
print "Please change scribus-call-laidout-to-impose-gui.py to have a correct path!"
#scribus.messageBox("Could not find Laidout!",
# "Please change line 37 in scribus-call-laidout-to-impose-gui.py to have a correct path!")
#laidoutexecutable=scribus.valueDialog("Laidout path","You do not appear to have Laidout installed! Please enter a valid path for running Laidout","/usr/bin/laidout")
laidoutexecutable = scribus.fileDialog(
'Please locate Laidout executable!!',
defaultname='/usr/bin/laidout',
issave=False)
print "New laidout executable path: " + laidoutexecutable
#fail if still not found
if os.path.exists(laidoutexecutable) == False:
scribus.messageBox(
"Could not find Laidout!",
"Please either change line for \'laidoutexecutable=\"/usr/bin/laidout\"\' in scribus-call-laidout-to-impose-gui.py"
" to have a correct path, or enter a valid path.")
sys.exit(1)
thecommand = ""
infile = os.getcwd(
) + "/this-is-a-temporary-file.sla" #note this saves to a very random area usually!!
reimposed = os.getcwd(
) + "/this-is-reimposed-from-laidout.sla" # seems like directory of the plugin
#infile =tempfile.NamedTemporaryFile() <-- maybe this can be used instead?? how to create, get filename, then let laidout open??
#outfile=tempfile.NamedTemporaryFile() <-- maybe this can be used instead??
size = scribus.getPageSize()
units = scribus.getUnit()
width = 0
height = 0
print "size " + str(size[0]) + "," + str(size[1])
print "units " + str(units)
if (units == scribus.UNIT_MILLIMETERS):
width = size[0] / 10 / 2.54
height = size[1] / 10 / 2.54
elif (units == scribus.UNIT_PICAS):
width = size[0] / 6
height = size[1] / 6
elif (units == scribus.UNIT_POINTS):
width = size[0] / 72
height = size[1] / 72
elif (units == scribus.UNIT_INCHES):
width = size[0]
height = size[1]
else:
print "unknown units!!!"
scribus.messageBox(
"Unknown units!",
"For some reason, scribus.getUnit() did not return units known to this script!"
"This is probably a bug with the script.")
#thecommand="/bin/ls"
thecommand=laidoutexecutable+" --impose-only " \
+"'in=\""+infile+"\" " \
+" out=\""+reimposed+"\" " \
+" prefer=\"booklet\"" \
+" width=\""+str(width)+"\"" \
+" height=\""+str(height)+"\"" \
+"'"
#print "command:\n", thecommand
try:
print "Creating temporary file ", infile, "..."
scribus.saveDocAs(infile)
except:
print "Could not save as ", infile
sys.exit(1)
try:
print "Trying: " + thecommand
os.system(thecommand)
except:
print "An error occured trying to run the system command:\n", thecommand
sys.exit(1)
if os.path.exists(reimposed) == False:
print "Reimposed file was not generated!"
sys.exit(1)
#scribus.closeDoc() #closes the "original" document, which has been rename to infile upon saveDocAs()
scribus.openDoc(reimposed) #open the brand spanking new reimposed document
#if (os.path.isfile(reimposed)): os.remove(reimposed) <-- might cause problems, but keep around for research
print "Removing temporary file ", infile, "..."
os.remove(infile)
print "All done!"
def main(argv):
if not scribus.haveDoc():
sys.exit(1)
os.chdir(os.path.expanduser("~"))
####
#### If you have a different location of your laidout program change it here:
####
laidoutexecutable="/usr/bin/laidout"
if os.path.exists(laidoutexecutable)==False:
laidoutexecutable="/usr/local/bin/laidout"
if os.path.exists(laidoutexecutable)==False:
print "Could not find Laidout!"
print "Please change scribus-call-laidout-to-impose-gui.py to have a correct path!"
#scribus.messageBox("Could not find Laidout!",
# "Please change line 37 in scribus-call-laidout-to-impose-gui.py to have a correct path!")
#laidoutexecutable=scribus.valueDialog("Laidout path","You do not appear to have Laidout installed! Please enter a valid path for running Laidout","/usr/bin/laidout")
laidoutexecutable=scribus.fileDialog('Please locate Laidout executable!!', defaultname='/usr/bin/laidout', issave=False)
print "New laidout executable path: "+laidoutexecutable
#fail if still not found
if os.path.exists(laidoutexecutable)==False:
scribus.messageBox("Could not find Laidout!",
"Please either change line for \'laidoutexecutable=\"/usr/bin/laidout\"\' in scribus-call-laidout-to-impose-gui.py"
" to have a correct path, or enter a valid path.")
sys.exit(1)
thecommand=""
infile=os.getcwd()+"/this-is-a-temporary-file.sla" #note this saves to a very random area usually!!
reimposed=os.getcwd()+"/this-is-reimposed-from-laidout.sla" # seems like directory of the plugin
#infile =tempfile.NamedTemporaryFile() <-- maybe this can be used instead?? how to create, get filename, then let laidout open??
#outfile=tempfile.NamedTemporaryFile() <-- maybe this can be used instead??
size=scribus.getPageSize()
units=scribus.getUnit()
width=0
height=0
print "size "+str(size[0])+","+str(size[1])
print "units "+str(units)
if (units==scribus.UNIT_MILLIMETERS):
width=size[0]/10/2.54
height=size[1]/10/2.54
elif (units==scribus.UNIT_PICAS):
width=size[0]/6
height=size[1]/6
elif (units==scribus.UNIT_POINTS):
width=size[0]/72
height=size[1]/72
elif (units==scribus.UNIT_INCHES):
width=size[0]
height=size[1]
else:
print "unknown units!!!"
scribus.messageBox("Unknown units!","For some reason, scribus.getUnit() did not return units known to this script!"
"This is probably a bug with the script.")
#thecommand="/bin/ls"
thecommand=laidoutexecutable+" --impose-only " \
+"'in=\""+infile+"\" " \
+" out=\""+reimposed+"\" " \
+" prefer=\"booklet\"" \
+" width=\""+str(width)+"\"" \
+" height=\""+str(height)+"\"" \
+"'"
#print "command:\n", thecommand
try:
print "Creating temporary file ",infile,"..."
scribus.saveDocAs(infile)
except:
print "Could not save as ",infile
sys.exit(1)
try:
print "Trying: "+thecommand
os.system(thecommand)
except:
print "An error occured trying to run the system command:\n",thecommand
sys.exit(1)
if os.path.exists(reimposed)==False:
print "Reimposed file was not generated!"
sys.exit(1)
#scribus.closeDoc() #closes the "original" document, which has been rename to infile upon saveDocAs()
scribus.openDoc(reimposed) #open the brand spanking new reimposed document
#if (os.path.isfile(reimposed)): os.remove(reimposed) <-- might cause problems, but keep around for research
print "Removing temporary file ",infile,"..."
os.remove(infile)
print "All done!"
def createChart():
"""actually handles the whole chart creation process"""
prepareDocument()
# get page size
pageSize=scribus.getPageSize()
pageWidth=pageSize[0]
pageHeight=pageSize[1]
#pageMargins
pageMargins=scribus.getPageMargins()
topMargin=pageMargins[0]
leftMargin=pageMargins[1]
rightMargin=pageMargins[2]
bottomMargin=pageMargins[3]
#color field dimensions
colorFieldWidth= pageWidth - leftMargin - rightMargin - (TEXT_BOX_WIDTH+HSPACE) #50+5 is the with of the textbox plus the space between textbox and colorfield
#how much space does one field use?
vSpaceUsedByField = COLOR_FIELD_HEIGHT+VSPACE
#how much space is available per row?
vSpaceAvailable=pageHeight-topMargin-bottomMargin-HEADERSIZE-FOOTERSIZE
#counts the colorFields created for a page. reset this variable after creation of new page
colorFieldCounter=0
#get list of all colors in document
colorList = scribus.getColorNames()
#prepare the progressbar
colorNumber=len(colorList)
scribus.progressTotal(colorNumber)
#@TODO: implement possibility to abort script (button2=scribus.BUTTON_CANCEL) buttons should return int 1 or 2
#scribus.messageBox("ColorChart Script by Sebastian Stetter", "...going to create a chart of "+str(colorNumber)+" colors.\n This may take a while.", button1 = scribus.BUTTON_OK)
scribus.statusMessage("Drawing color fields...")
stepCompleted=0
#disable redrawing for better performance
scribus.setRedraw(False)
for color in colorList:
if (vSpaceUsedByField * (colorFieldCounter+1)) <= vSpaceAvailable:
# when there is enought space left draw a color field...
#calculate Position for new colorField
h=leftMargin
v=topMargin + (vSpaceUsedByField * colorFieldCounter)+HEADERSIZE
#draw the colorField
drawColor(color, h, v, colorFieldWidth, COLOR_FIELD_HEIGHT)
colorFieldCounter = colorFieldCounter+1
#update progressbar
stepCompleted = stepCompleted+1
scribus.progressSet(stepCompleted)
else:
#not enough space? create a new page!
createPage()
#reset the colorFieldCounter to '0' since we created a new page
colorFieldCounter = 0
h=leftMargin
v=topMargin + (vSpaceUsedByField * colorFieldCounter)+HEADERSIZE
drawColor(color, h, v, colorFieldWidth, COLOR_FIELD_HEIGHT)
colorFieldCounter = colorFieldCounter+1
#update progressbar
stepCompleted = stepCompleted+1
scribus.progressSet(stepCompleted)
#make shure pages are redrawn
scribus.setRedraw(True)
def main(argv):
scribus.setUnit(scribus.UNIT_MILLIMETERS)
# get page size
pagesize = scribus.getPageSize()
###########################################
# size and position of the exit buttons
linksize = pagesize[0] / 30
linkpos = pagesize[0] - linksize - 2
# set up exit to page
pagenum = scribus.pageCount()
exittopage = scribus.valueDialog(
"Exit to page",
"Exit buttons should go to page (1-" + str(pagenum) + ") :", "1")
#error
#if exittopage > pagenum:
# scribus.messageBox("Error", "This page doesn't exist.")
# sys.exit()
# get active layer, create new layer for exit buttons, set it as active
activelayer = scribus.getActiveLayer()
scribus.createLayer("Exitbuttons")
scribus.setActiveLayer("Exitbuttons")
#progressbar max
scribus.progressTotal(pagenum)
# iterate through all the pages
page = 1
while (page <= pagenum):
#messagebar text
scribus.messagebarText("Create exit buttons...")
scribus.progressSet(page)
scribus.gotoPage(page)
# create rectangle
exitrect = scribus.createRect(linkpos, 2, linksize, linksize,
"exitrect" + str(page))
scribus.setFillColor("White", exitrect)
# create text in rectangle
exittext = scribus.createText(linkpos, 4, linksize, linksize,
"exittext" + str(page))
scribus.setText("X", exittext)
scribus.setFontSize(20, exittext)
scribus.setTextAlignment(1, exittext)
# create link annotation
exitlink = scribus.createText(linkpos, 2, linksize, linksize,
"exitlink" + str(page))
#setLinkAnnotation(page,x,y,["name"])
scribus.setLinkAnnotation(int(exittopage), 0, 0, exitlink)
# add page number to iteration
page += 1
# go back to active layer
scribus.setActiveLayer(activelayer)
def main():
try:
import scribus
except ImportError:
# if the script does not run inside of scribus, launch scribus with this script as paremeter
filename = []
if (len(sys.argv) == 2):
print("launching the script for " + sys.argv[1])
filename.append(sys.argv[1])
else:
print("launching the script for each .sla in the directory.")
for file in os.listdir('.'):
filenameSplit = os.path.splitext(file)
if filenameSplit[-1] == '.sla' and filenameSplit[0].find(
'_autosave_') == -1:
filename.append(file)
arguments = []
for argument in sys.argv[1:]:
if argument[0] == '-':
# arguments.append('--python-arg')
arguments.append('-pa')
arguments.append(argument.strip('-'))
print(arguments)
for file in filename:
call(['scribus', '-g', '-py', sys.argv[0]] + arguments +
['--', file])
sys.exit(1)
if scribus.haveDoc():
page_sizes = {(210, 297): 'A4', (148, 210): 'A5', (105, 148): 'A6'}
filename = os.path.splitext(scribus.getDocName())[0]
pdf = scribus.PDFfile()
page_size = tuple(int(round(s)) for s in scribus.getPageSize())
print(page_sizes[page_size])
page_size = page_sizes[page_size]
pdf.file = filename + '-' + page_size.lower() + '.pdf'
pdf.save()
single_sided = 'single' in sys.argv
print(sys.argv)
print(single_sided)
# sys.exit(1)
pdf = scribus.PDFfile()
pdf.file = filename + "-reordered.pdf"
pdf.pages = get_a4_pages(page_size, single_sided, scribus.pageCount())
print(page_size)
print(single_sided)
print(scribus.pageCount())
print(pdf.pages)
pdf.save()
# os.system("pdfnup --nup 2x2 --frame false --no-landscape " + filename + "-reordered.pdf --outfile " + filename.replace("a6", "a4") + ".pdf")
call([
'pdfnup', '--nup', '2x2', '--frame', 'false', '--no-landscape',
filename + '-reordered.pdf', '--outfile', filename + "-a4.pdf"
])
os.remove(pdf.file)
else:
print("No file open")
def make_textframe (self):
margins = scribus.getPageMargins()
size = scribus.getPageSize()
w = size[0] - margins[1] - margins[3]
h = size[1] - margins[0] - margins[2]
return scribus.createText (margins[1], margins[0], w, h)
#!/usr/bin/env python ''' Create image like Mondrian drawings ''' import scribus import random rectColor = "Black" topMargin, leftMargin, rightMargin, bottomMargin = scribus.getPageMargins() pageWidth, pageHeight = scribus.getPageSize() printAreaWidth = pageWidth - leftMargin - rightMargin printAreaHeight = pageHeight - topMargin - bottomMargin vertRectW = random.randrange(2,4) vertRectH = random.randrange(48,50) horRectW = random.randrange(47,49) horRectH = random.randrange(2,5) startx = leftMargin endx = pageWidth - leftMargin - horRectW starty = topMargin endy = pageHeight - topMargin - vertRectH numberRectVert = random.randrange(400,600) numberRectHor = random.randrange(400,600) opacity = 0 for i in range(1, numberRectVert): opacity = opacity + 0.002 xpos = random.randrange(int(startx),int(endx))
def main(argv):
###########################################
info_text = '''
Welcome to Auto-Photobook!
1. Select the process mode:
9f = creates a 9x9 layout on each page and fill them with images.
4f = creates a 4x4 layout on each page and fill them with images.
9e = creates an empty 9x9 layout on each page.
4e = creates an empty 4x4 layout on each page.
9f+4f = creates a filled 9x9 layout on odd pages and a filled 4x4 layout on even pages.
9e+4e = creates an empty 9x9 layout on odd pages and an empty 4x4 layout on even pages.
9f+4e = creates a filled 9x9 layout on odd pages and an empty 4x4 layout on even pages (default).
9e+4f = creates an empty 9x9 layout on odd pages and a filled 4x4 layout on even pages.
2. Select a document layout, the margins (they need to be equal) and the bleed (if needed). Ignore the number of pages.
3. Define the space between the images (default: 6mm).
4a. If "9f" or "4f" is in your mode, you can choose an image folder and an image filter will be prompted.
4b. Otherwise, set the amount of pages you want to create (default: 10 pages).
5. Wait until it is done...
6. Adjust you layouts and move your images as you need.
Process mode:'''
# start dialog, choose mode
#scribus.messageBox("Auto-Photobook", info_text)
todo = scribus.valueDialog("Auto-Photobook", info_text, "9f+4e")
todo = list(todo.split("+"))
# wrong process mode
if "9f" not in todo and "9e" not in todo and "4f" not in todo and "9e" not in todo:
scribus.messageBox(
"Error", "Wrong process mode. Auto-Photobook was cancelled.")
sys.exit()
# show new document dialog
newdoc = scribus.newDocDialog()
# exit if cancelled
if newdoc == False:
scribus.messageBox("Exit", "Auto-Photobook was cancelled.")
sys.exit()
if scribus.haveDoc:
scribus.setUnit(scribus.UNIT_MILLIMETERS)
(w, h) = scribus.getPageSize()
###################
# delete all pages except the first:
pageamount = scribus.pageCount()
while pageamount > 1:
scribus.deletePage(pageamount)
pageamount = scribus.pageCount()
# set image border and bleed
border = int(
scribus.valueDialog("Space between images",
"Define the space between the images (mm).",
"6"))
#border = 6
# reset image border for easier calculations
border = border * 0.75
if "9f" in todo or "4f" in todo:
# ask for workdir
workdir = scribus.fileDialog("Open directory with images",
"",
haspreview=False,
issave=False,
isdir=True)
#workdir = "/media/sda7/Programming/Python/scribus_auto_photobook/pics"
# file filter
filefilter = scribus.valueDialog(
"File filter",
"File filter examples: \n\n* or *.* = add all files\n*.jpg = add .jpg files only\nIMG_*.* = add all files starting with IMG_\n\nThis filter is case sensitive!",
"*.*")
# get image paths
filelist = sorted(glob.glob(os.path.join(workdir, filefilter)))
#filelist = sorted(glob.glob(os.path.join(workdir, "*")))
# count files
filesinworkdir = len(filelist)
scribus.messageBox(
"Files in directory",
"Images matched in folder: " + str(filesinworkdir))
#error
if filesinworkdir == 0:
scribus.messageBox("Error", "This directory is empty.")
sys.exit()
#messagebar text
scribus.messagebarText("Importing images...")
#progressbar max
scribus.progressTotal(filesinworkdir)
# set maxpages (not needed here but needs to be assigned)
maxpages = len(filelist)
else:
# ask for page amount
maxpages = int(
scribus.valueDialog("Set page amount",
"How many pages you want to create?",
"10"))
#progressbar max
scribus.progressTotal(maxpages)
# get page size (without bleed)
size = scribus.getPageSize()
# get margins
margins = scribus.getPageMargins()[0]
# set page final size
final_size = (size[0] - margins, size[1] - margins)
# simplify calc for 9x9 layout
guide_layout_x = final_size[0] / 3 - margins / 3
guide_layout_y = final_size[1] / 3 - margins / 3
# set indexes
page = 1
pic = 0
#create pages, add and load images
x = True
while x == True:
scribus.progressSet(page)
scribus.gotoPage(page)
# create 9x9 layout
if "9f" in todo or "9e" in todo:
#guides
scribus.setVGuides([
margins + guide_layout_x - border,
margins + guide_layout_x + border / 2,
margins + guide_layout_x * 2 - border / 2,
margins + guide_layout_x * 2 + border
])
scribus.setHGuides([
margins + guide_layout_y - border,
margins + guide_layout_y + border / 2,
margins + guide_layout_y * 2 - border / 2,
margins + guide_layout_y * 2 + border
])
# create images
scribus.createImage(margins, margins,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image1")
scribus.createImage(margins + guide_layout_x + border / 2,
margins,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image2")
scribus.createImage(margins + guide_layout_x * 2 + border,
margins,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image3")
scribus.createImage(margins,
margins + guide_layout_y + border / 2,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image4")
scribus.createImage(margins + guide_layout_x + border / 2,
margins + guide_layout_y + border / 2,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image5")
scribus.createImage(margins + guide_layout_x * 2 + border,
margins + guide_layout_y + border / 2,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image6")
scribus.createImage(margins,
margins + guide_layout_y * 2 + border,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image7")
scribus.createImage(margins + guide_layout_x + border / 2,
margins + guide_layout_y * 2 + border,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image8")
scribus.createImage(margins + guide_layout_x * 2 + border,
margins + guide_layout_y * 2 + border,
guide_layout_x + border - border * 2,
guide_layout_y - border,
"page" + str(page) + "image9")
#load and scale images
if "9f" in todo:
try:
scribus.loadImage(filelist[pic],
"page" + str(page) + "image1")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image1")
scribus.loadImage(filelist[pic + 1],
"page" + str(page) + "image2")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image2")
scribus.loadImage(filelist[pic + 2],
"page" + str(page) + "image3")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image3")
scribus.loadImage(filelist[pic + 3],
"page" + str(page) + "image4")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image4")
scribus.loadImage(filelist[pic + 4],
"page" + str(page) + "image5")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image5")
scribus.loadImage(filelist[pic + 5],
"page" + str(page) + "image6")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image6")
scribus.loadImage(filelist[pic + 6],
"page" + str(page) + "image7")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image7")
scribus.loadImage(filelist[pic + 7],
"page" + str(page) + "image8")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image8")
scribus.loadImage(filelist[pic + 8],
"page" + str(page) + "image9")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image9")
except:
x = False
# increase picture index
pic += 9
# add page
scribus.newPage(-1)
page += 1
# create 4x4 layout
if "4f" in todo or "4e" in todo:
#guides
scribus.setVGuides(
[size[0] / 2 - border * 0.75, size[0] / 2 + border * 0.75])
scribus.setHGuides(
[size[1] / 2 - border * 0.75, size[1] / 2 + border * 0.75])
# create images
scribus.createImage(margins, margins,
size[0] / 2 - border * 0.75 - margins,
size[1] / 2 - border * 0.75 - margins,
"page" + str(page) + "image1")
scribus.createImage(size[0] / 2 + border * 0.75, margins,
size[0] / 2 - border * 0.75 - margins,
size[1] / 2 - border * 0.75 - margins,
"page" + str(page) + "image2")
scribus.createImage(margins, size[1] / 2 + border * 0.75,
size[0] / 2 - border * 0.75 - margins,
size[1] / 2 - border * 0.75 - margins,
"page" + str(page) + "image3")
scribus.createImage(size[0] / 2 + border * 0.75,
size[1] / 2 + border * 0.75,
size[0] / 2 - border * 0.75 - margins,
size[1] / 2 - border * 0.75 - margins,
"page" + str(page) + "image4")
#load and scale images
if "4f" in todo:
try:
scribus.loadImage(filelist[pic],
"page" + str(page) + "image1")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image1")
scribus.loadImage(filelist[pic + 1],
"page" + str(page) + "image2")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image2")
scribus.loadImage(filelist[pic + 2],
"page" + str(page) + "image3")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image3")
scribus.loadImage(filelist[pic + 3],
"page" + str(page) + "image4")
scribus.setScaleImageToFrame(True,
proportional=True,
name="page" + str(page) +
"image4")
except:
x = False
# increase picture index
pic += 4
# add page
scribus.newPage(-1)
page += 1
#scribus.setImageOffset(0, 0, "imagename"+str(page))
#scribus.setScaleFrameToImage(name="imagename"+str(page))
# stop if maxpages reached
if page > maxpages:
x = False
#delete last blank page
scribus.deletePage(page)
import scribus
import os
import glob
pageNum = scribus.pageCount()
print(pageNum)
result = ""
os.chdir(os.path.dirname(scribus.getDocName()) + "/../png")
listeImages = sorted(glob.glob("*"))
itemNum = 0
for i in range(1, pageNum + 1):
scribus.gotoPage(i)
for o in scribus.getAllObjects():
if (scribus.getObjectType(o) == "ImageFrame"):
if (scribus.getSize(o)[0] >= scribus.getPageSize()[0] * 0.99):
#result = result + "item:" + str(itemNum) + " page:" + str(i) + " name: " + o + "\n" + " imageFile:" + scribus.getImageFile(o)
scribus.loadImage(listeImages[itemNum], o)
itemNum = itemNum + 1
#scribus.messageBox("caption", result)
#scribus.messageBox("listeImages", "\n".join(listeImages))
http://www.opensource.org/licenses/mit-license.html
"""
from __future__ import division
from itertools import cycle
import sys
try:
import scribus
except ImportError:
print "This script only works from within Scribus"
sys.exit(1)
unit_current=scribus.getUnit() #get unit and change it to mm
scribus.setUnit(scribus.UNIT_MILLIMETERS)
page = scribus.getPageSize()
margin = scribus.getPageMargins()
layer = scribus.getActiveLayer()
if ('guides' in scribus.getLayers()) :
scribus.setActiveLayer('guides')
else:
scribus.createLayer('guides')
# add the baseline grid (when it's not too close to a guide)
baseline_start = 0 # in mm
baseline = 14.4 # in pt
multiplicator = 10000
def main(argv):
unit = scribus.getUnit()
units = ['pts', 'mm', 'inches', 'picas', 'cm', 'ciceros']
unitlabel = units[unit]
# get page size
xysize = scribus.getPageSize()
# ask for layout style
layout_style = scribus.valueDialog("Guides Layout", layout_text, "1")
if layout_style == "":
sys.exit()
# 0 = erase all guides
if layout_style == "0":
#guides
scribus.setVGuides([])
scribus.setHGuides([])
sys.exit()
# 1 = guides around page
if layout_style == "1":
# set guides distance
pageguides_str = scribus.valueDialog(
"Create Guides around Page",
"Set distance to page borders (" + unitlabel +
") :\n\n- positive (e.g. 3) for page margin\n\n- negative (e.g. -3) for page bleed\n",
"3")
if pageguides_str != "":
pageguides = float(pageguides_str)
else:
sys.exit()
#set guides
scribus.setVGuides(scribus.getVGuides() +
[pageguides, xysize[0] - pageguides])
scribus.setHGuides(scribus.getHGuides() +
[pageguides, xysize[1] - pageguides])
# 2 = guides around selected object
if layout_style == "2":
# set guides distance
objectguides_str = scribus.valueDialog(
"Create Guides around selected Objects",
"Set distance to object borders (" + unitlabel +
") :\n\n- 0 for around the object borders\n\n- positive (e.g. 3) towards inside the object\n\n- negative (e.g. -3) towards outside the object\n",
"0")
if objectguides_str != "":
objectguides = float(objectguides_str)
else:
sys.exit()
if scribus.selectionCount() == 0:
scribus.messageBox("Error",
"Select an object first !",
icon=scribus.ICON_WARNING)
sys.exit()
#get selected object
selection_name = scribus.getSelectedObject(0)
objectpos = scribus.getPosition(selection_name)
objectsize = scribus.getSize(selection_name)
#set guides
scribus.setVGuides(scribus.getVGuides() + [
objectpos[0] + objectguides, objectpos[0] + objectsize[0] -
objectguides
])
scribus.setHGuides(scribus.getHGuides() + [
objectpos[1] + objectguides, objectpos[1] + objectsize[1] -
objectguides
])
(margin_top, margin_left, margin_right, margin_bottom) = scribus.getPageNMargins(scribus.currentPage())
print "left " + str(margin_left)
print "right " + str(margin_right)
(width, height) = scribus.getPageNSize(scribus.currentPage())
print "width " + str(width)
print "height " + str(height)
cell_width = (width - (margin_left + margin_right) - (gap * (n - 1))) / n
print cell_width
guide = []
previous_guide = margin_left
for i in range(0, n - 1):
guide.append(previous_guide + cell_width)
guide.append(previous_guide + cell_width + gap)
previous_guide = previous_guide + cell_width + gap
scribus.setHGuides(guide)
unit_current=scribus.getUnit() #get unit and change it to mm
scribus.setUnit(scribus.UNIT_MILLIMETERS)
page = scribus.getPageSize()
margin = scribus.getPageMargins()
# scribus.setHGuides([10,20,30])
setGuidesColumn(6, 5)
setGuidesRow(4, 5)
scribus.setUnit(unit_current)
def main(argv):
scribus.setUnit(scribus.UNIT_MILLIMETERS)
# get page size and page count
pagesize = scribus.getPageSize()
pagenum = scribus.pageCount()
#create on page
selectedpage = scribus.valueDialog(
"Select page", "Create arrows and annotation links on page (1-" +
str(pagenum) + ") :", "1")
# get active layer, create new layer for exit buttons, set it as active
#activelayer = scribus.getActiveLayer()
scribus.createLayer("Arrowlinks")
scribus.setActiveLayer("Arrowlinks")
#progressbar max
scribus.progressTotal(pagenum)
arrowinitxpos = 10
arrowinitypos = 30
scribus.gotoPage(int(selectedpage))
page = 1
###########################################
for i in range(pagenum):
# create rectangle
#exitrect = scribus.createRect(arrowinitxpos, 50, 30, 30, "exitrect")
#messagebar text
scribus.messagebarText(
"Creating arrows and annotation links on page " + selectedpage +
"...")
#progress bar
scribus.progressSet(page)
#create and distribute arrow
arrowpoly = [
10, 30, 30, 10, 50, 30, 40, 30, 40, 50, 20, 50, 20, 30, 10, 30
]
arrowup = scribus.createPolygon(arrowpoly)
scribus.sizeObject(10, 10, arrowup)
scribus.moveObjectAbs(arrowinitxpos, arrowinitypos, arrowup)
scribus.setFillColor("White", arrowup)
#create and distribute links
arrowlink = scribus.createText(arrowinitxpos, arrowinitypos + 11, 10,
10, "link_to_page_" + str(page))
#setLinkAnnotation(page,x,y,["name"])
scribus.setLinkAnnotation(int(page), 0, 0, arrowlink)
arrowinitxpos += 11
if arrowinitxpos > 250:
arrowinitypos += 24
arrowinitxpos = 10
# add page number to iteration
page += 1
