示例#1
0
def prepareDocument():
    """creates the new document, sets up colors """
    colorList = getColorsFromDocument()
    spotDict = getSpotColors()
    scribus.statusMessage("Preparing new document...")
    scribus.newDocument(scribus.PAPER_A4,  (15,15,  20, 20),  scribus.PORTRAIT, 1, scribus.UNIT_POINTS,  scribus.PAGE_1, 0, 1) 
    scribus.setUnit(scribus.UNIT_MILLIMETERS)
    #delete existing colors
    cols = scribus.getColorNames()
    for col in cols:
        scribus.deleteColor(col, "None")

    #create our new colors
    for color in colorList:
        cname=color[0]
        c = int(color[1])
        m = int(color[2])
        y = int(color[3])
        k = int(color[4])
        scribus.defineColorCMYK(cname,  c, m, y, k )
        if spotDict.has_key(cname):
            scribus.setSpotColor(cname, spotDict[cname])

    #get the pageTitle form user and store it in PageTitle
    global pageTitle
    pageTitle=scribus.valueDialog("ColorChart by Sebastian Stetter", "Please enter document title", "Scribus COLOR CHART")
    drawHeaderFooter(pageTitle)
def helperNewDocument(
    pageWidth,
    pageHeight,
    leftMargin,
    topMargin,
    rightMargin,
    bottomMargin,
    orientation,
    firstPageNumber,
    unit,
    pagesType,
    firstPageOrder,
    numPages,
):

    # size (height, width)
    # margins (left, top, right, bottom)
    return scribus.newDocument(
        (pageHeight, pageWidth),
        (leftMargin, topMargin, rightMargin, bottomMargin),
        orientation,
        firstPageNumber,
        unit,
        pagesType,
        firstPageOrder,
        numPages,
    )
def helperNewDocument(pageWidth, pageHeight, leftMargin, topMargin,
                      rightMargin, bottomMargin, orientation, firstPageNumber,
                      unit, pagesType, firstPageOrder, numPages):

    # size (height, width)
    # margins (left, top, right, bottom)
    return scribus.newDocument(
        (pageHeight, pageWidth),
        (leftMargin, topMargin, rightMargin, bottomMargin), orientation,
        firstPageNumber, unit, pagesType, firstPageOrder, numPages)
示例#4
0
 def __init__(self):
     self.doc = scribus.newDocument(
         self.page_size,
         (self.margins["left"].scribus_repr(
             self.units), self.margins["right"].scribus_repr(
                 self.units), self.margins["top"].scribus_repr(self.units),
          self.margins["bottom"].scribus_repr(self.units)),
         self.orientation,
         1,  # Number of first page
         self.units.scribus_repr(),
         scribus.FACINGPAGES,
         scribus.FIRSTPAGELEFT,
         1  # Number of pages in document
     )
     self.current_position = hv_position(self.margins["left"],
                                         self.margins["top"])
     return
示例#5
0
 def __init__(self):
     self.doc = scribus.newDocument(
         self.page_size,
         (
             self.margins["left"].scribus_repr(self.units),
             self.margins["right"].scribus_repr(self.units),
             self.margins["top"].scribus_repr(self.units),
             self.margins["bottom"].scribus_repr(self.units),
         ),
         self.orientation,
         1,  # Number of first page
         self.units.scribus_repr(),
         scribus.FACINGPAGES,
         scribus.FIRSTPAGELEFT,
         1,  # Number of pages in document
     )
     self.current_position = hv_position(self.margins["left"], self.margins["top"])
     return
示例#6
0
def main(argv):
    """This is a documentation string. Write a description of what your code
    does here. You should generally put documentation strings ("docstrings")
    on all your Python functions."""
    #########################
    #  YOUR CODE GOES HERE  #
    #########################
    scribus.statusMessage(str(scribus.PAPER_A4))
    scribus.newDocument(
        scribus.PAPER_A4,  #paper
        (MARGIN, MARGIN, MARGIN, MARGIN),  #margins
        scribus.LANDSCAPE,  #orientation
        0,  #firstPageNumber
        scribus.UNIT_MILLIMETERS,  #unit
        scribus.PAGE_1,  #pagesType
        0,  #firstPageOrder
        0,  #numPages
    )
    scribus.createCharStyle('date1', 'Athelas Bold', 45)
    scribus.createCharStyle('month1', 'Athelas Bold', 16)
    scribus.createCharStyle('name1', 'Athelas Regular', 16)
    scribus.createParagraphStyle('dateL',
                                 alignment=scribus.ALIGN_LEFT,
                                 charstyle='date1')
    scribus.createParagraphStyle('monthL',
                                 alignment=scribus.ALIGN_LEFT,
                                 charstyle='month1')
    scribus.createParagraphStyle('nameL',
                                 alignment=scribus.ALIGN_LEFT,
                                 charstyle='name1')
    scribus.createParagraphStyle('dateR',
                                 alignment=scribus.ALIGN_RIGHT,
                                 charstyle='date1')
    scribus.createParagraphStyle('monthR',
                                 alignment=scribus.ALIGN_RIGHT,
                                 charstyle='month1')
    scribus.createParagraphStyle('nameR',
                                 alignment=scribus.ALIGN_RIGHT,
                                 charstyle='name1')
    masterPage()

    d = data.loadData()
    """
    We want to make pamphlet (signature) of 5 x A4 papers printed from both sides with 2 weeks on each side
    2sided 4imposition refer imposition.py
    """
    def pageFn(left, right):
        page = scribus.newPage(-1, 'planner')
        i = 0
        sizeDate = (20, 15)
        sizeMonth = (20, 7)
        sizeName = (290, 7)
        for xend, y in iterDayLines():
            try:
                tLeftDate = left[i]
                posLeftDate = (xstart, y - sizeDate[1])
                posLeftMonth = (xstart + sizeDate[0], y - sizeDate[1])
                posLeftName = (xstart + sizeDate[0], y - sizeName[1])
                tLeftName = ', '.join(d[tLeftDate.month][tLeftDate.day])
                objLeftDate = scribus.createText(*posLeftDate + sizeDate)
                objLeftMonth = scribus.createText(*posLeftMonth + sizeMonth)
                objLeftName = scribus.createText(*posLeftName + sizeName)
                scribus.setText(tLeftDate.strftime('%d'), objLeftDate)
                scribus.setText(mm(tLeftDate), objLeftMonth)
                scribus.setText(tLeftName, objLeftName)
                scribus.setStyle('dateL', objLeftDate)
                scribus.setStyle('monthL', objLeftMonth)
                scribus.setStyle('nameL', objLeftName)
            except IndexError:
                pass

            try:
                posRightDate = (xend - sizeDate[0], y - sizeDate[1])
                posRightMonth = (xend - sizeDate[0] - sizeMonth[0],
                                 y - sizeDate[1])
                posRightName = (xend - sizeDate[0] - sizeName[0],
                                y - sizeName[1])
                tRightDate = right[i]
                tRightName = ', '.join(d[tRightDate.month][tRightDate.day])
                objRightDate = scribus.createText(*posRightDate + sizeDate)
                objRightMonth = scribus.createText(*posRightMonth + sizeMonth)
                objRightName = scribus.createText(*posRightName + sizeName)
                scribus.setText(tRightDate.strftime('%d'), objRightDate)
                scribus.setText(mm(tRightDate), objRightMonth)
                scribus.setText(tRightName, objRightName)
                scribus.setStyle('dateR', objRightDate)
                scribus.setStyle('monthR', objRightMonth)
                scribus.setStyle('nameR', objRightName)
            except IndexError:
                pass
            i += 1

    dates.forEachWeek(pageFn)
    scribus.deletePage(1)
示例#7
0
# When 4 pics per page, coords are: (15, 42),(310, 187), (15, 388), (310, 533)
# When 6 pics per page: (15, 42),(310, 42), (15, 290), (310, 290),(15,533),(310,533)
# if nrimages == '4':
#     xpos = [15, 310, 15, 310]
#     ypos = [42, 187, 388, 533]
# if nrimages == '6':
#     xpos = [15, 310, 15, 310, 15, 310]
#     ypos = [42, 42, 290, 290, 533, 533]
# This proportion is right for photographs from my digital camera
pwidth = 69.35
pheight = 94.35
imagecount = 0
# framecount = 0
if len(D) > 0:
    if scribus.newDocument((69.35, 94.35), (0, 0, 0, 0), scribus.PORTRAIT, 1, scribus.UNIT_MM, scribus.PAGE_1, 0, 1):
        while imagecount < len(D):
            if imagecount > 0:
                scribus.newPage(-1)
                framecount = 0
            # L is the frame at the top of each page showing the directory name
            # L = scribus.createText(15, 20, 200, 20)
            # scribus.setText("Dir: " + imagedir, L)
            # scribus.setTextAlignment(scribus.ALIGN_LEFT, L)
            # scribus.setFont(labelFont, L)
            # scribus.setFontSize(10, L)
            # Here is where we're loading images into the page, four at a time, then go back up for a newPage
            if imagecount < len(D):
                f = scribus.createImage(0, 0, pwidth, pheight)
                scribus.loadImage(imagedir + '/' + D[imagecount], f)
                scribus.setScaleImageToFrame(scaletoframe=1, proportional=0, name=f)
示例#8
0
G = float(G)

W = scribus.valueDialog('Book Cover Calculator', 'Enter Page Width')

W = float(W)

H = scribus.valueDialog('Book Cover Calculator', 'Enter Page Height')

H = float(H)

R = scribus.valueDialog('Book Cover Calculator', 'Enter Cover Paper thickness')

R = float(R)

W1 = W

WW = W + 0.125

S = P / G + (R * 2)

S = float(S)

W = W + S + W + 0.25

H = H + 0.25

scribus.newDocument((W, H), (0.375, 0.375, 0.375, 0.375), scribus.PORTRAIT, 1,
                    scribus.UNIT_INCHES, scribus.PAGE_1, 0, 1)

scribus.setVGuides(
    [WW, (W1 / 2 + 0.125), (WW + S / 2), (WW + S), (WW + S + W1 / 2)])
#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import random
import scribus

# page size in inch (letter)
pageX = 8.5
pageY = 11.0
lineY = 0.4125
spaceY = 0.1875

scribus.newDocument((pageX, pageY), (0.0, 0.0, 0.0, 0.0), scribus.PORTRAIT, 1, scribus.UNIT_INCHES, scribus.PAGE_1, 0, 1)
scribus.defineColor("lightgray",21,21,21,21)
scribus.defineColor("gray",51,51,51,51)
scribus.defineColor("darkgray",91,91,91,91)

l = scribus.createLine(1.0,0.0,1.0,11)
scribus.setLineColor("gray", l)
l = scribus.createLine(1.05,0.0,1.05,11)
scribus.setLineColor("gray", l)  

for x in range(0,19):
	l = scribus.createLine(0.0,lineY-spaceY,8.5,lineY-spaceY)
	scribus.setLineColor("gray", l) 

	l = scribus.createLine(0.0,lineY,8.5,lineY)
	scribus.setLineColor("lightgray", l)
	scribus.setLineStyle(scribus.LINE_DOT,l) 
示例#10
0

    #add Logo
    hOffset=37
    wOffset=5
    addLogo(marginl+(roffset-1)*w+wOffset,margint+(coffset-1)*h+hOffset, isBlack)
    return


# Main
colstotal=get_multipl(WIDTH, CARDWIDTH, MARGINS[0], MARGINS[1])
rowstotal=get_multipl(HEIGHT, CARDHEIGHT, MARGINS[2], MARGINS[3])
#print "n per rows: "+ str(colstotal) + ", n per cols: " + str(rowstotal) 

# create a new document 
t=scribus.newDocument((WIDTH,HEIGHT), MARGINS, scribus.PORTRAIT, 1, scribus.UNIT_MILLIMETERS, scribus.FACINGPAGES, scribus.FIRSTPAGERIGHT,1)
cr=1
cc=1
nol=0

# ask for CSV infos
tstr=scribus.valueDialog('Cvs Delimiter, Quote and Column to process','Type 1 delimiter, 1 quote character and the column number (Clear for default ,"0):',';"0')
if len(tstr) > 0: delim=tstr[0] 
else: delim=','
if len(tstr) > 1: qc=tstr[1]
else: qc='"'
if len(tstr) > 2: numcol=int(tstr[2])
else: numcol=0

# select black or white cards
color=scribus.valueDialog('Color of the cards :','black (b) or white (w)','w')
示例#11
0
    def main (self) :

        # Load up all the file and record information.
        # Use CSV reader to build list of record dicts
        records         = self.loadCSVData(self.dataFile)
        totalRecs       = len(records)

        # Reality check first to see if we have anything to process
        if totalRecs <= 0 :
            scribus.messageBox('Not Found', 'No records found to process!')
            sys.exit()

        pageNumber      = 1
        recCount        = 0
        row             = 0
        pageSide        = 'Odd'
        scribus.progressTotal(totalRecs)
        paIndex         = {}
        lastName        = ''
        firstName       = ''
        photoFirstName  = ''
        verseRef        = ''
        verseText       = ''

        # Get the page layout coordinates for this publication
        crds = self.getCoordinates(self.dimensions)

        # Make a new document to put our records on
        if scribus.newDocument(getattr(scribus, self.dimensions['page']['scribusPageCode']), 
                    (self.dimensions['margins']['left'], self.dimensions['margins']['right'], self.dimensions['margins']['top'], self.dimensions['margins']['bottom']),
                        scribus.PORTRAIT, 1, scribus.UNIT_POINTS, scribus.NOFACINGPAGES, 
                            scribus.FIRSTPAGERIGHT, 1) :

            self.setPageNumber(crds, pageSide, row, pageNumber)

            while recCount < totalRecs :

                # Output a new page on the first row after we have done the first page
                if row == 0 and recCount != 0:
                    scribus.newPage(-1)
                    if pageSide == 'Odd' :
                        pageSide = 'Even'
                    else :
                        pageSide = 'Odd'

                    self.setPageNumber(crds, pageSide, row, pageNumber)

                ########### Now set the current record in the current row ##########

                # Set the last name
                lastName = records[recCount]['NameLast']

                # Adjust the NameFirst field to include the spouse if there is one
                if records[recCount]['Spouse'] != '' :
                    firstName = records[recCount]['NameFirst'] + ' & ' + records[recCount]['Spouse']
                else :
                    firstName = records[recCount]['NameFirst']
                    
                # Make the photo file name
                photoFirstName = firstName.replace('&', '-').replace('.', '').replace(' ', '')

                # Set our record count for progress display and send a status message
                scribus.progressSet(recCount)
                scribus.statusMessage('Placing record ' + `recCount` + ' of ' + `totalRecs`)

                # Add a watermark if a string is specified
                if self.outputWatermark :
                    self.addWatermark()

                # Put the last name element in this row
                nameLastBox = scribus.createText(crds[row]['nameLastXPos'], crds[row]['nameLastYPos'], crds[row]['nameLastWidth'], crds[row]['nameLastHeight'])
                scribus.setText(lastName, nameLastBox)
                scribus.setTextAlignment(scribus.ALIGN_RIGHT, nameLastBox)
                scribus.setTextDistances(0, 0, 0, 0, nameLastBox)
                scribus.setFont(self.fonts['nameLast']['bold'], nameLastBox)
                scribus.setFontSize(self.fonts['nameLast']['size'], nameLastBox)
                scribus.setTextShade(80, nameLastBox)
                scribus.rotateObject(90, nameLastBox)

                # Place the first name element in this row
                nameFirstBox = scribus.createText(crds[row]['nameFirstXPos'], crds[row]['nameFirstYPos'], crds[row]['nameFirstWidth'], crds[row]['nameFirstHeight'])
                scribus.setText(records[recCount]['Caption'], nameFirstBox)
                scribus.setTextAlignment(scribus.ALIGN_LEFT, nameFirstBox)
                scribus.setFont(self.fonts['nameFirst']['boldItalic'], nameFirstBox)
                scribus.setFontSize(self.fonts['nameFirst']['size'], nameFirstBox)

                # Place the image element in this row
                # We will need to do some processing on the first pass
                # The default output format is JPG
                orgImgFileName = records[recCount]['Photo']
                orgImgFile = os.path.join(self.orgImgDir, orgImgFileName)
                baseImgFileName = lastName + '_' + photoFirstName
                if self.willBePngImg :
                    ext = 'png'
                else :
                    ext = 'jpg'
                if not self.rgbColor :
                    imgFile = os.path.join(getattr(self, ext + 'ImgDir'), baseImgFileName + '-gray' + '.' + ext)
                else :
                    imgFile = os.path.join(getattr(self, ext + 'ImgDir'), baseImgFileName + '.' + ext)

                # Process the image now if there is none
                if not os.path.exists(imgFile) :
                    self.img_process.sizePic(orgImgFile, imgFile, self.maxHeight)
#                    self.img_process.outlinePic(imgFile, imgFile)
                    self.img_process.scalePic(imgFile, imgFile, self.imgDensity)
                    self.img_process.addPoloroidBorder(imgFile, imgFile)
                    # Color RGB is the default
                    if not self.rgbColor :
                        self.img_process.makeGray(imgFile, imgFile)

                # Double check the output and substitute with placeholder pic
                if not os.path.exists(imgFile) :
                    imgFile = self.placeholderPic
                # Create the imageBox and load the picture
                imageBox = scribus.createImage(crds[row]['imageXPos'], crds[row]['imageYPos'], crds[row]['imageWidth'], crds[row]['imageHeight'])
                if os.path.isfile(imgFile) :
                    scribus.loadImage(imgFile, imageBox)
                scribus.setScaleImageToFrame(scaletoframe=1, proportional=1, name=imageBox)

                # Place the country element in this row (add second one if present)
                countryBox = scribus.createText(crds[row]['countryXPos'], crds[row]['countryYPos'], crds[row]['countryWidth'], crds[row]['countryHeight'])
                countryLine = records[recCount]['Country1']
                try :
                    if records[recCount]['Country2'] != '' :
                        countryLine = countryLine + ' & ' + records[recCount]['Country2']
                except :
                    pass
                scribus.setText(countryLine, countryBox)
                scribus.setTextAlignment(scribus.ALIGN_RIGHT, countryBox)
                scribus.setFont(self.fonts['text']['boldItalic'], countryBox)
                scribus.setFontSize(self.fonts['text']['size'], countryBox)

                # Place the assignment element in this row
                assignBox = scribus.createText(crds[row]['assignXPos'], crds[row]['assignYPos'], crds[row]['assignWidth'], crds[row]['assignHeight'])
                scribus.setText(self.fixText(records[recCount]['Assignment']), assignBox)
                # Assign style to box
#                scribus.createParagraphStyle(name='assignStyle', alignment=0, leftmargin=10, firstindent=-10)
#                scribus.setStyle('assignStyle', assignBox)
                # Hard formated box
                scribus.setTextAlignment(scribus.ALIGN_LEFT, assignBox)
                scribus.setFont(self.fonts['text']['italic'], assignBox)
                scribus.setFontSize(self.fonts['text']['size'], assignBox)
                scribus.setLineSpacing(self.fonts['text']['size'] + 1, assignBox)
                scribus.setTextDistances(4, 0, 0, 0, assignBox)
                # Resize the frame height and determine the difference for
                # placing the next frame below it
                assignHeightNew = self.resizeFrame(assignBox)
                assignHeightDiff = crds[row]['assignHeight'] - assignHeightNew

                # Place the verse element in this row
                verseYPosNew = crds[row]['verseYPos'] - assignHeightDiff
                verseBox = scribus.createText(crds[row]['verseXPos'], verseYPosNew, crds[row]['verseWidth'], crds[row]['verseHeight'])
                # The verse element may be either a Scripture verse or a prayer request
                # If it is Scripture, and it has a verse ref, we want to set that
                # seperatly so we need to do a little preprocess on the text to find
                # out if it has a ref. This script will only recognize references
                # at the end of the string that are enclosed in brackets. See the
                # findVerseRef() function for more details
                verseRef = self.findVerseRef(records[recCount]['Prayer'])
                if verseRef :
                    verseText = self.removeVerseRef(self.fixText(records[recCount]['Prayer']))
                    scribus.setText(verseText, verseBox)
                else :
                    scribus.setText(self.fixText(records[recCount]['Prayer']), verseBox)
                # Can't find a way to set alignment to justified using setTextAlignment()
#                scribus.setTextAlignment(scribus.ALIGN_LEFT, verseBox)
                # Because of this, we make a style which seems to work
                scribus.createParagraphStyle(name='vBoxStyle', alignment=3)
                scribus.setStyle('vBoxStyle', verseBox)
                scribus.setFont(self.fonts['verse']['regular'], verseBox)
                scribus.setFontSize(self.fonts['verse']['size'], verseBox)
                scribus.setLineSpacing(self.fonts['verse']['size'] + 1, verseBox)
                scribus.setTextDistances(4, 0, 4, 0, verseBox)
                if self.hyphenate :
                    scribus.hyphenateText(verseBox)
                # Get the height difference in case we need to set ref box
                verseHeightNew = self.resizeFrame(verseBox)
                verseHeightDiff = crds[row]['verseHeight'] - verseHeightNew
                if verseRef :
                    # Set coordinates for this box
                    vRefBoxX = crds[row]['verseXPos']
                    vRefBoxY = (verseYPosNew + verseHeightNew)
                    vRefBoxH = crds[row]['nameFirstHeight'] / 2
                    vRefBoxW = crds[row]['verseWidth']
                    verseRefBox = scribus.createText(vRefBoxX, vRefBoxY, vRefBoxW, vRefBoxH)
                    scribus.setText(verseRef, verseRefBox)
                    scribus.setTextAlignment(scribus.ALIGN_RIGHT, verseRefBox)
                    scribus.setFont(self.fonts['verse']['italic'], verseRefBox)
                    scribus.setFontSize(self.fonts['verse']['size'] - 2, verseRefBox)
                    scribus.setLineSpacing(self.fonts['verse']['size'], verseRefBox)
                    scribus.setTextDistances(2, 0, 0, 0, verseRefBox)

                # Up our counts
                if row >= self.dimensions['rows']['count'] - 1 :
                    row = 0
                    pageNumber +=1
                else :
                    row +=1
                    
                recCount +=1

            # Create the index page here
            # Output a new page for the index
            if row == 0 and recCount != 0:
                scribus.newPage(-1)
                if pageSide == 'Odd' :
                    pageSide = 'Even'
                else :
                    pageSide = 'Odd'

                self.setPageNumber(crds, pageSide, 0, pageNumber)

        # Outut the index entries at this point
#        for key in paIndex.keys() :

        # Report we are done now before we loose focus
        scribus.statusMessage('Process Complete!')

###############################################################################
############################## Output Results #################################
###############################################################################

        # Now we will output the results to PDF if that is desired
        if self.makePdf :
            pdfExport =  scribus.PDFfile()
            pdfExport.info = self.pdfFile
            pdfExport.file = self.pdfFile
            pdfExport.save()

        # View the output if set
        if self.makePdf and self.viewPdf :
            cmd = ['evince', self.pdfFile]
            try :
                subprocess.Popen(cmd)
            except Exception as e :
                result = scribus.messageBox ('View PDF command failed with: ' + str(e), scribus.BUTTON_OK)
示例#12
0
		i = random.randint(0,2)
		if i == 0:
			random_degree = 0
		elif i == 1:
			random_degree = 120
		elif i == 2:
			random_degree = 240	

		scribus.rotateObject(random_degree, bars)
		scribus.sentToLayer("randombars", bars)

####################################################################################
# create new document (landscape) 
####################################################################################

if scribus.newDocument((document_width,document_height), (document_margin,document_margin,document_margin,document_margin), scribus.PORTRAIT, 1, scribus.UNIT_MILLIMETERS, scribus.PAGE_2, 0, 1):

	scribus.setMargins(0,6.35,3.175,3.175)
 	# create some layers; so objects appear front/background
	scribus.createLayer("randombars")
	scribus.createLayer("randomcircles")
	scribus.createLayer("textlayer")


distros.keys().sort()

for distro in sorted(distros.iterkeys()):
	# extract the dictionary content
	description = distros[distro][0]
	filesizeiso = distros[distro][1]
	md5sum = distros[distro][2]
示例#13
0
def main():
    colstotal = get_multipl(WIDTH, CARDWIDTH, MARGINS[0], MARGINS[1])
    rowstotal = get_multipl(HEIGHT, CARDHEIGHT, MARGINS[2], MARGINS[3])

    # create a new document
    t = scribus.newDocument(
        (WIDTH, HEIGHT),
        MARGINS,
        scribus.PORTRAIT,
        1,
        scribus.UNIT_MILLIMETERS,
        scribus.FACINGPAGES,
        scribus.FIRSTPAGERIGHT,
        1,
    )
    cr = 1
    cc = 1
    nol = 0

    # ask for CSV infos
    tstr = scribus.valueDialog(
        'Cvs Delimiter, Quote and Column to process',
        'Type 1 delimiter, 1 quote character '
        'and the column number (Clear for default ,"0):',
        ';"0',
    )
    if len(tstr) > 0:
        delim = tstr[0]
    else:
        delim = ','
    if len(tstr) > 1:
        qc = tstr[1]
    else:
        qc = '"'
    if len(tstr) > 2:
        numcol = int(tstr[2])
    else:
        numcol = 0

    # select black or white cards
    color = scribus.valueDialog(
        'Color of the cards :',
        'black (b) or white (w)',
        'w',
    )
    if len(color) > 0 and 'b' == color[0]:
        is_black = True
    else:
        is_black = False

    # open CSV file
    data = getCSVdata(delim=delim, qc=qc)

    # Process data
    scribus.messagebarText("Processing " + str(nol) + " elements")
    scribus.progressTotal(len(data))
    for row in data:
        scribus.messagebarText("Processing " + str(nol) + " elements")
        celltext = row[numcol].strip()
        if len(celltext) != 0:
            createCell(
                celltext,
                cr,
                cc,
                CARDWIDTH,
                CARDHEIGHT,
                MARGINS[0],
                MARGINS[2],
                is_black,
            )
            nol = nol + 1
            if cr == colstotal and cc == rowstotal:
                #create new page
                scribus.newPage(-1)
                scribus.gotoPage(scribus.pageCount())
                cr = 1
                cc = 1
            else:
                if cr == colstotal:
                    cr = 1
                    cc = cc + 1
                else:
                    cr = cr + 1
            scribus.progressSet(nol)
    scribus.messagebarText("Processed " + str(nol) + " items. ")

    # open CSV file
    data = getCSVdata(delim=delim, qc=qc)

    # Process data
    scribus.messagebarText("Processing " + str(nol) + " elements")
    scribus.progressReset()
    scribus.progressTotal(len(data))
    nol = 0
    cr = 1
    cc = cc + 2
    for row in data:
        scribus.messagebarText("Processing " + str(nol) + " elements")
        celltext = row[numcol].strip()
        if len(celltext) != 0:
            createCell(
                celltext,
                cr,
                cc,
                CARDWIDTH,
                CARDHEIGHT,
                MARGINS[0],
                MARGINS[2],
                is_black=True,
            )
            nol = nol + 1
            if cr == colstotal and cc == rowstotal:
                #create new page
                scribus.newPage(-1)
                scribus.gotoPage(scribus.pageCount())
                cr = 1
                cc = 1
            else:
                if cr == colstotal:
                    cr = 1
                    cc = cc + 1
                else:
                    cr = cr + 1
            scribus.progressSet(nol)
    scribus.messagebarText("Processed " + str(nol) + " items. ")
    scribus.progressReset()
示例#14
0
文件: hd.py 项目: fleshgordo/HDbuch
	scribus.createText(x, y, width, height, text_id)
#scribus.text_id = scribus.createText(120, 10, 200, 20)
	scribus.setText(parsedtext, text_id)
	scribus.setFont(font, text_id)
	scribus.setTextColor(text_colour, text_id)
	scribus.setTextDistances(3*spacing, spacing, 0, spacing, text_id)
	scribus.sentToLayer(layer, text_id)
	scribus.setFontSize(fontsize, text_id)

def loadimages(img_id, img_x, img_y, img_width, img_height, img_path, layer, scaletoframe):
	scribus.createImage(img_x, img_y, img_width, img_height, img_id)
	scribus.loadImage(img_path, img_id)
	scribus.sentToLayer(layer, img_id)

# create new document (smallsquare) 
if scribus.newDocument((document_width,document_height), (0,6.35,3.175,3.175), scribus.PORTRAIT, 1, scribus.UNIT_MILLIMETERS, scribus.PAGE_2, 1, 0):

	i = 0
	scribus.createLayer("images")
	scribus.createLayer("text")

	textframes("titel", 42.5, 50, 129.7, 17.99, "White","Black", 39, "FreeSans Bold", 0, "DIE SCHWÄRZUNG","text", 0, 0)
	scribus.createLine(20.2,67.5,190.2,67.5)
	scribus.createImage(55, 72.7, 99.5, 20.2, "logo")
	scribus.loadImage("handydandy_logo.eps", "logo")
	scribus.sentToLayer("images", "logo")
	scribus.setScaleImageToFrame(1,1,"logo")
	textframes("jahr", 81.7, 216.7, 46.1, 18.5, "White","Black", 22, "FreeSans Medium", 0, "2006 - 2012","text", 0, 0)
	
	scribus.newPage(-1)
#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import scribus

# page size in inch (letter)
pageX = 8.5
pageY = 11
scribus.defineColor("gray",21,21,21,21)

scribus.newDocument((pageX, pageY), (0.0, 0.0, 0.0, 0.0), scribus.LANDSCAPE, 1, scribus.UNIT_INCHES, scribus.PAGE_1, 0, 1)

#0,13 for final
for x in range(0,13):
	#1,12,6 for final
	for y in range(1,12,6):
		rx = x
		ry = y
		for zx in range(0,2):
			for zy in range(0,3):						
				a = scribus.createText(2.25+((zx+0)*(pageX/1.55)), 0.75+(zy*(pageY/3.84)), 1.25, 0.25)
				scribus.setFont('Arial Regular',a)		
				scribus.setFontSize(12, a)
				scribus.setTextColor("gray", a)
				scribus.setTextAlignment(scribus.ALIGN_CENTERED, a)
				scribus.rotateObject(180, a);
				
				rxy = rx-ry
				scribus.insertText('%(rx)d - %(ry)d = %(rxy)d' % locals(), 0, a)		
				
示例#16
0
from __future__ import print_function, division
import scribus

page_width = scribus.valueDialog('Cover Assistant', 'Page width (mm)', '148')
page_height = scribus.valueDialog('Cover Assistant', 'Page height (mm)', '210')
spine_width = scribus.valueDialog('Cover Assistant', 'Spine width (mm)', '8')
page_width = float(page_width)
page_height = float(page_height)
spine_width = float(spine_width)

cover_width = 2 * page_width + spine_width
cover_height = page_height

print('Spine width: {} mm'.format(spine_width))
print('Cover width: {} mm'.format(cover_width))
print('Cover height: {} mm'.format(cover_height))

scribus.newDocument((cover_width, cover_height), (0, 0, 0, 0),
                    scribus.PORTRAIT, 1, scribus.UNIT_MILLIMETERS,
                    scribus.PAGE_1, 0, 1)
vguides = [page_width, page_width + spine_width]
scribus.setVGuides(vguides)
示例#17
0

    #add Logo
    hOffset=37
    wOffset=5
    addLogo(marginl+(roffset-1)*w+wOffset,margint+(coffset-1)*h+hOffset, isBlack)
    return


# Main
colstotal=get_multipl(WIDTH, CARDWIDTH, MARGINS[0], MARGINS[1])
rowstotal=get_multipl(HEIGHT, CARDHEIGHT, MARGINS[2], MARGINS[3])
#print "n per rows: "+ str(colstotal) + ", n per cols: " + str(rowstotal) 

# create a new document 
t=scribus.newDocument((WIDTH,HEIGHT), MARGINS, scribus.PORTRAIT, 1, scribus.UNIT_MILLIMETERS, scribus.FACINGPAGES, scribus.FIRSTPAGERIGHT,1)
cr=1
cc=1
nol=0

# ask for CSV infos
tstr=scribus.valueDialog('Cvs Delimiter, Quote and Column to process','Type 1 delimiter, 1 quote character and the column number (Clear for default ,"0):',';"0')
if len(tstr) > 0: delim=tstr[0] 
else: delim=','
if len(tstr) > 1: qc=tstr[1]
else: qc='"'
if len(tstr) > 2: numcol=int(tstr[2])
else: numcol=0

# select black or white cards
color=scribus.valueDialog('Color of the cards :','black (b) or white (w)','w')
示例#18
0
    def main(self):

        # Load up all the file and record information.
        # Use CSV reader to build list of record dicts
        records = self.loadCSVData(self.dataFile)
        totalRecs = len(records)

        # Reality check first to see if we have anything to process
        if totalRecs <= 0:
            scribus.messageBox('Not Found', 'No records found to process!')
            sys.exit()

        pageNumber = 1
        recCount = 0
        row = 0
        pageSide = 'Odd'
        scribus.progressTotal(totalRecs)
        paIndex = {}
        lastName = ''
        firstName = ''
        photoFirstName = ''
        verseRef = ''
        verseText = ''

        # Get the page layout coordinates for this publication
        crds = self.getCoordinates(self.dimensions)

        # Make a new document to put our records on
        if scribus.newDocument(
                getattr(scribus, self.dimensions['page']['scribusPageCode']),
            (self.dimensions['margins']['left'],
             self.dimensions['margins']['right'],
             self.dimensions['margins']['top'],
             self.dimensions['margins']['bottom']), scribus.PORTRAIT, 1,
                scribus.UNIT_POINTS, scribus.NOFACINGPAGES,
                scribus.FIRSTPAGERIGHT, 1):

            self.setPageNumber(crds, pageSide, row, pageNumber)

            while recCount < totalRecs:

                # Output a new page on the first row after we have done the first page
                if row == 0 and recCount != 0:
                    scribus.newPage(-1)
                    if pageSide == 'Odd':
                        pageSide = 'Even'
                    else:
                        pageSide = 'Odd'

                    self.setPageNumber(crds, pageSide, row, pageNumber)

                ########### Now set the current record in the current row ##########

                # Set the last name
                lastName = records[recCount]['NameLast']

                # Adjust the NameFirst field to include the spouse if there is one
                if records[recCount]['Spouse'] != '':
                    firstName = records[recCount][
                        'NameFirst'] + ' & ' + records[recCount]['Spouse']
                else:
                    firstName = records[recCount]['NameFirst']

                # Make the photo file name
                photoFirstName = firstName.replace('&', '-').replace(
                    '.', '').replace(' ', '')

                # Set our record count for progress display and send a status message
                scribus.progressSet(recCount)
                scribus.statusMessage('Placing record ' + ` recCount ` +
                                      ' of ' + ` totalRecs `)

                # Add a watermark if a string is specified
                if self.outputWatermark:
                    self.addWatermark()

                # Put the last name element in this row
                nameLastBox = scribus.createText(crds[row]['nameLastXPos'],
                                                 crds[row]['nameLastYPos'],
                                                 crds[row]['nameLastWidth'],
                                                 crds[row]['nameLastHeight'])
                scribus.setText(lastName, nameLastBox)
                scribus.setTextAlignment(scribus.ALIGN_RIGHT, nameLastBox)
                scribus.setTextDistances(0, 0, 0, 0, nameLastBox)
                scribus.setFont(self.fonts['nameLast']['bold'], nameLastBox)
                scribus.setFontSize(self.fonts['nameLast']['size'],
                                    nameLastBox)
                scribus.setTextShade(80, nameLastBox)
                scribus.rotateObject(90, nameLastBox)

                # Place the first name element in this row
                nameFirstBox = scribus.createText(crds[row]['nameFirstXPos'],
                                                  crds[row]['nameFirstYPos'],
                                                  crds[row]['nameFirstWidth'],
                                                  crds[row]['nameFirstHeight'])
                scribus.setText(records[recCount]['Caption'], nameFirstBox)
                scribus.setTextAlignment(scribus.ALIGN_LEFT, nameFirstBox)
                scribus.setFont(self.fonts['nameFirst']['boldItalic'],
                                nameFirstBox)
                scribus.setFontSize(self.fonts['nameFirst']['size'],
                                    nameFirstBox)

                # Place the image element in this row
                # We will need to do some processing on the first pass
                # The default output format is JPG
                orgImgFileName = records[recCount]['Photo']
                orgImgFile = os.path.join(self.orgImgDir, orgImgFileName)
                baseImgFileName = lastName + '_' + photoFirstName
                if self.willBePngImg:
                    ext = 'png'
                else:
                    ext = 'jpg'
                if not self.rgbColor:
                    imgFile = os.path.join(
                        getattr(self, ext + 'ImgDir'),
                        baseImgFileName + '-gray' + '.' + ext)
                else:
                    imgFile = os.path.join(getattr(self, ext + 'ImgDir'),
                                           baseImgFileName + '.' + ext)

                # Process the image now if there is none
                if not os.path.exists(imgFile):
                    self.img_process.sizePic(orgImgFile, imgFile,
                                             self.maxHeight)
                    #                    self.img_process.outlinePic(imgFile, imgFile)
                    self.img_process.scalePic(imgFile, imgFile,
                                              self.imgDensity)
                    self.img_process.addPoloroidBorder(imgFile, imgFile)
                    # Color RGB is the default
                    if not self.rgbColor:
                        self.img_process.makeGray(imgFile, imgFile)

                # Double check the output and substitute with placeholder pic
                if not os.path.exists(imgFile):
                    imgFile = self.placeholderPic
                # Create the imageBox and load the picture
                imageBox = scribus.createImage(crds[row]['imageXPos'],
                                               crds[row]['imageYPos'],
                                               crds[row]['imageWidth'],
                                               crds[row]['imageHeight'])
                if os.path.isfile(imgFile):
                    scribus.loadImage(imgFile, imageBox)
                scribus.setScaleImageToFrame(scaletoframe=1,
                                             proportional=1,
                                             name=imageBox)

                # Place the country element in this row (add second one if present)
                countryBox = scribus.createText(crds[row]['countryXPos'],
                                                crds[row]['countryYPos'],
                                                crds[row]['countryWidth'],
                                                crds[row]['countryHeight'])
                countryLine = records[recCount]['Country1']
                try:
                    if records[recCount]['Country2'] != '':
                        countryLine = countryLine + ' & ' + records[recCount][
                            'Country2']
                except:
                    pass
                scribus.setText(countryLine, countryBox)
                scribus.setTextAlignment(scribus.ALIGN_RIGHT, countryBox)
                scribus.setFont(self.fonts['text']['boldItalic'], countryBox)
                scribus.setFontSize(self.fonts['text']['size'], countryBox)

                # Place the assignment element in this row
                assignBox = scribus.createText(crds[row]['assignXPos'],
                                               crds[row]['assignYPos'],
                                               crds[row]['assignWidth'],
                                               crds[row]['assignHeight'])
                scribus.setText(self.fixText(records[recCount]['Assignment']),
                                assignBox)
                # Assign style to box
                #                scribus.createParagraphStyle(name='assignStyle', alignment=0, leftmargin=10, firstindent=-10)
                #                scribus.setStyle('assignStyle', assignBox)
                # Hard formated box
                scribus.setTextAlignment(scribus.ALIGN_LEFT, assignBox)
                scribus.setFont(self.fonts['text']['italic'], assignBox)
                scribus.setFontSize(self.fonts['text']['size'], assignBox)
                scribus.setLineSpacing(self.fonts['text']['size'] + 1,
                                       assignBox)
                scribus.setTextDistances(4, 0, 0, 0, assignBox)
                # Resize the frame height and determine the difference for
                # placing the next frame below it
                assignHeightNew = self.resizeFrame(assignBox)
                assignHeightDiff = crds[row]['assignHeight'] - assignHeightNew

                # Place the verse element in this row
                verseYPosNew = crds[row]['verseYPos'] - assignHeightDiff
                verseBox = scribus.createText(crds[row]['verseXPos'],
                                              verseYPosNew,
                                              crds[row]['verseWidth'],
                                              crds[row]['verseHeight'])
                # The verse element may be either a Scripture verse or a prayer request
                # If it is Scripture, and it has a verse ref, we want to set that
                # seperatly so we need to do a little preprocess on the text to find
                # out if it has a ref. This script will only recognize references
                # at the end of the string that are enclosed in brackets. See the
                # findVerseRef() function for more details
                verseRef = self.findVerseRef(records[recCount]['Prayer'])
                if verseRef:
                    verseText = self.removeVerseRef(
                        self.fixText(records[recCount]['Prayer']))
                    scribus.setText(verseText, verseBox)
                else:
                    scribus.setText(self.fixText(records[recCount]['Prayer']),
                                    verseBox)
                # Can't find a way to set alignment to justified using setTextAlignment()
#                scribus.setTextAlignment(scribus.ALIGN_LEFT, verseBox)
# Because of this, we make a style which seems to work
                scribus.createParagraphStyle(name='vBoxStyle', alignment=3)
                scribus.setStyle('vBoxStyle', verseBox)
                scribus.setFont(self.fonts['verse']['regular'], verseBox)
                scribus.setFontSize(self.fonts['verse']['size'], verseBox)
                scribus.setLineSpacing(self.fonts['verse']['size'] + 1,
                                       verseBox)
                scribus.setTextDistances(4, 0, 4, 0, verseBox)
                if self.hyphenate:
                    scribus.hyphenateText(verseBox)
                # Get the height difference in case we need to set ref box
                verseHeightNew = self.resizeFrame(verseBox)
                verseHeightDiff = crds[row]['verseHeight'] - verseHeightNew
                if verseRef:
                    # Set coordinates for this box
                    vRefBoxX = crds[row]['verseXPos']
                    vRefBoxY = (verseYPosNew + verseHeightNew)
                    vRefBoxH = crds[row]['nameFirstHeight'] / 2
                    vRefBoxW = crds[row]['verseWidth']
                    verseRefBox = scribus.createText(vRefBoxX, vRefBoxY,
                                                     vRefBoxW, vRefBoxH)
                    scribus.setText(verseRef, verseRefBox)
                    scribus.setTextAlignment(scribus.ALIGN_RIGHT, verseRefBox)
                    scribus.setFont(self.fonts['verse']['italic'], verseRefBox)
                    scribus.setFontSize(self.fonts['verse']['size'] - 2,
                                        verseRefBox)
                    scribus.setLineSpacing(self.fonts['verse']['size'],
                                           verseRefBox)
                    scribus.setTextDistances(2, 0, 0, 0, verseRefBox)

                # Up our counts
                if row >= self.dimensions['rows']['count'] - 1:
                    row = 0
                    pageNumber += 1
                else:
                    row += 1

                recCount += 1

            # Create the index page here
            # Output a new page for the index
            if row == 0 and recCount != 0:
                scribus.newPage(-1)
                if pageSide == 'Odd':
                    pageSide = 'Even'
                else:
                    pageSide = 'Odd'

                self.setPageNumber(crds, pageSide, 0, pageNumber)

        # Outut the index entries at this point
#        for key in paIndex.keys() :

# Report we are done now before we loose focus
        scribus.statusMessage('Process Complete!')

        ###############################################################################
        ############################## Output Results #################################
        ###############################################################################

        # Now we will output the results to PDF if that is desired
        if self.makePdf:
            pdfExport = scribus.PDFfile()
            pdfExport.info = self.pdfFile
            pdfExport.file = self.pdfFile
            pdfExport.save()

        # View the output if set
        if self.makePdf and self.viewPdf:
            cmd = ['evince', self.pdfFile]
            try:
                subprocess.Popen(cmd)
            except Exception as e:
                result = scribus.messageBox(
                    'View PDF command failed with: ' + str(e),
                    scribus.BUTTON_OK)