def getColorsFromDoc():
    """returns a list ("name", c,y,m,k)
    get all the colors of that doc. """
    #get a list of al the colornames
    scribus.statusMessage("Reading Colors...")

    try:
        colorlist = scribus.getColorNames()
        scribus.progressTotal(len(colorlist))
        i = 0
        colordata = []
        for color in colorlist:
            colorvalues = scribus.getColor(color)
            c = int(colorvalues[0] / 2.55)  #convert values from 0-255 to 0-100
            m = int(colorvalues[1] / 2.55)
            y = int(colorvalues[2] / 2.55)
            k = int(colorvalues[3] / 2.55)
            name = color.strip()  #eliminate leading and tailing whitespace
            cd = [name, c, m, y, k]
            colordata.append(cd)
            i = i + 1
            scribus.progressSet(i)

        return colordata
    except:
        scribus.messageBox("color2csv",
                           "Can not retrieve colors - There is no Document",
                           icon=scribus.ICON_WARNING)
        sys.exit()
Example #2
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)
Example #3
0
def getColorsFromDoc():
    """returns a list ("name", c,y,m,k)
    get all the colors of that doc. """
    #get a list of al the colornames
    scribus.statusMessage("Reading Colors...")

    try:
        colorlist = scribus.getColorNames()
        scribus.progressTotal(len(colorlist))
        i=0
        colordata=[]
        for color in colorlist:
            colorvalues=scribus.getColor(color)
            c=int(colorvalues[0]/2.55) #convert values from 0-255 to 0-100
            m=int(colorvalues[1]/2.55)
            y=int(colorvalues[2]/2.55)
            k=int(colorvalues[3]/2.55)
            name=color.strip() #eliminate leading and tailing whitespace
            cd = [name,c ,m,y,k] 
            colordata.append(cd)
            i=i+1
            scribus.progressSet(i)
        
        return colordata
    except:
        scribus.messageBox("color2csv", "Can not retrieve colors - There is no Document", icon=scribus.ICON_WARNING)
        sys.exit()
Example #4
0
def main():
    try:
        scribus.statusMessage('Running script...')
        # scribus.progressReset()
        adfc_gui.main("-scribus")
    finally:
        if scribus.haveDoc() > 0:
            scribus.redrawAll()
        scribus.statusMessage('Done.')
def main_wrapper(argv):
  try:
		scribus.statusMessage("Running script...")
		scribus.progressReset()
		main(argv)
  finally:
		if scribus.haveDoc():
		    scribus.setRedraw(True)
		scribus.statusMessage("")
		scribus.progressReset()
def main_wrapper(argv):
    try:
        scribus.statusMessage("Running script...")
        scribus.progressReset()
        main(argv)
    finally:
        if scribus.haveDoc():
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
def main():
    cache = defaultdict(dict)
    try:
        with open(CACHE_FILE, "rb") as cache_file:
            cache = defaultdict(dict, json.load(cache_file))
    except:
        pass

    with open(DATA_FILE, "rb") as data_file:
        songs_data = json.load(data_file)

    with open(MANUEL_PROCESSING_FILE, "rb") as manual_file:
        manual_processing = defaultdict(dict, json.load(manual_file))

    scribus.statusMessage("Running script...")
    scribus.progressReset()
    scribus.progressTotal(len(songs_data))

    init()
    front_matter()
    add_page_number()

    # trying to get the best sorting
    # setting all songs to the max height
    all_songs = dict(zip(songs_data.keys(), [EFFECTIVE_PAGE_HEIGHT] * len(songs_data)))
    # update according to cache
    for song_name, data in cache.iteritems():
        all_songs[song_name] = min(data.get("height", EFFECTIVE_PAGE_HEIGHT), EFFECTIVE_PAGE_HEIGHT)
    # let's see which songs should be set on a double sided page:
    songs_double_page = filter(lambda x: manual_processing[x].get("double_page", False), manual_processing)
    for double_page in songs_double_page:
        all_songs[double_page] = EFFECTIVE_PAGE_HEIGHT # all double page songs should get a whole page despite their height

    appendix_filter = lambda a_s, boolean : {k:v for k,v in a_s.iteritems() if manual_processing[k].get("appendix", False) == boolean}

    main_songs = appendix_filter(all_songs, False)
    add_songs(main_songs, songs_double_page, manual_processing, songs_data, cache)

    appendix_songs = appendix_filter(all_songs, True)
    add_songs(appendix_songs, songs_double_page, manual_processing, songs_data, cache)


    toc = []
    for filename in filter(lambda s: manual_processing[s].get("show", True), all_songs.keys()):
        toc.append((songs_data[filename]["name"], cache[filename].get("page", "XX")))
    toc.sort(key=lambda (x,y): x)
    create_toc(toc)

    if scribus.haveDoc():
        scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()

    with open(CACHE_FILE, "wb") as cache_file:
        json.dump(cache, cache_file, indent=2)
Example #8
0
def main_wrapper(argv):
    try:
        scribus.statusMessage("Importing .csv table...")
        scribus.progressReset()
        main(argv)
    finally:
        #exit
        if scribus.haveDoc() > 0:
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
Example #9
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  #
    #########################
    userdim = scribus.getUnit()  # get unit and change it to mm
    scribus.setUnit(scribus.UNIT_MILLIMETERS)
    cellwidthleft = 0
    cellwidthright = 0
    cellHeight = 0
    pos = getPosition()
    while cellwidthleft <= 0:
        cellwidthL = scribus.valueDialog("Left Cell Width", "How wide (mm) do you wish left cells to be?", "30.0")
        cellwidthleft = float(cellwidthL)
    while cellwidthright <= 0:
        cellwidthR = scribus.valueDialog("Right Cell Width", "How wide (mm) do you wish right cells to be?", "30.0")
        cellwidthright = float(cellwidthR)
    while cellHeight <= 0:
        cellheight = scribus.valueDialog("Cell Height", "How tall (mm) do you wish cells to be?", "10.0")
        cellHeight = float(cellheight)
    data = getCSVdata()
    di = getDataInformation(data)
    hposition = pos[1]
    vposition = pos[0]

    objectlist = []  # here we keep a record of all the created textboxes so we can group them later
    i = 0
    scribus.progressTotal(len(data))
    scribus.setRedraw(False)
    for row in data:
        c = 0
        for cell in row:
            cell = cell.strip()
            cellsize = cellwidthleft
            if c == 1:
                cellsize = cellwidthright
            textbox = scribus.createText(hposition, vposition, cellsize, cellHeight)  # create a textbox
            objectlist.append(textbox)
            scribus.insertText(cell, 0, textbox)  # insert the text into the textbox
            hposition = hposition + cellwidthleft  # move the position for the next cell
            c = 1
        vposition = vposition + cellHeight  # set vertical position for next row
        hposition = pos[1]  # reset vertical position for next row
        i = i + 1
        scribus.progressSet(i)

    scribus.groupObjects(objectlist)
    scribus.progressReset()
    scribus.setUnit(userdim)  # reset unit to previous value
    scribus.docChanged(True)
    scribus.statusMessage("Done")
    scribus.setRedraw(True)
Example #10
0
def getColorDict():
    """get the colors that already exist from the opened Document and return a dictionary"""
    scribus.statusMessage("Reading existing colors...")
    colornames = scribus.getColorNames()
    scribus.progressTotal(len(colornames))
    i=0
    colordict={}
    for name in colornames:
        colordict[name]=None
        i=i+1
        scribus.progressSet(i)
    return colordict #we can ask this dict if the color already exists
Example #11
0
def getColorDict():
    """get the colors that already exist from the opened Document and return a dictionary"""
    scribus.statusMessage("Reading existing colors...")
    colornames = scribus.getColorNames()
    scribus.progressTotal(len(colornames))
    i = 0
    colordict = {}
    for name in colornames:
        colordict[name] = None
        i = i + 1
        scribus.progressSet(i)
    return colordict  #we can ask this dict if the color already exists
Example #12
0
def main_wrapper(argv):
    try:
        scribus.statusMessage("Running script...")
        scribus.progressReset()
        main(argv)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if scribus.haveDoc():
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
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)
Example #14
0
def writeColorCsvFile(filename, colorlist):
    """writes all the colors to a csv file"""
    scribus.statusMessage("Writing colors to csv file...")
    scribus.progressTotal(len(colorlist))
    i=0
    try:
        csvwriter=csv.writer(file(filename, "w"), quoting=csv.QUOTE_NONNUMERIC)
        for line in colorlist:
            csvwriter.writerow(line)
            i=i+1
            scribus.progressSet(i)
    except:
        scribus.messageBox("color2csv", "Could not write file!", icon=scribus.ICON_WARNING)
        sys.exit()
Example #15
0
def main_wrapper(argv):
    try:
        if(scribus.haveDoc()):
            scribus.setRedraw(False)
        scribus.statusMessage(CONST.APP_NAME)
        scribus.progressReset()
        main(argv)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if(scribus.haveDoc()):
            scribus.setRedraw(True)
        scribus.statusMessage('')
        scribus.progressReset()
def main_wrapper(argv):
    try:
        if (scribus.haveDoc()):
            scribus.setRedraw(False)
        scribus.statusMessage(CONST.APP_NAME)
        scribus.progressReset()
        main(argv)

    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if (scribus.haveDoc()):
            scribus.setRedraw(True)
        scribus.statusMessage('')
        scribus.progressReset()
Example #17
0
 def getColors():
     """gets the colors and returns a list[name,c,m,y,k]"""
     colorNames=scribus.getColorNames()
     list=[]
     scribus.statusMessage("Reading Colors...")
     stepsTotal=len(colorNames)
     scribus.progressTotal(stepsTotal)
     steps=0
     for name in colorNames:
         color=scribus.getColor(name)
         listitem=[name, color[0], color[1],  color[2],  color[3]]
         list.append(listitem)
         #update progress bar
         steps=steps+1
         scribus.progressSet(steps)
     return list
def writeColorCsvFile(filename, colorlist):
    """writes all the colors to a csv file"""
    scribus.statusMessage("Writing colors to csv file...")
    scribus.progressTotal(len(colorlist))
    i = 0
    try:
        csvwriter = csv.writer(file(filename, "w"),
                               quoting=csv.QUOTE_NONNUMERIC)
        for line in colorlist:
            csvwriter.writerow(line)
            i = i + 1
            scribus.progressSet(i)
    except:
        scribus.messageBox("color2csv",
                           "Could not write file!",
                           icon=scribus.ICON_WARNING)
        sys.exit()
Example #19
0
def main_wrapper(argv):
    """The main_wrapper() function disables redrawing, sets a sensible generic
    status bar message, and optionally sets up the progress bar. It then runs
    the main() function. Once everything finishes it cleans up after the main()
    function, making sure everything is sane before the script terminates."""
    try:
        #scribus.statusMessage("Running script...")
        scribus.progressReset()
        main(argv)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if scribus.haveDoc():
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
Example #20
0
def main_wrapper(argv):
    """The main_wrapper() function disables redrawing, sets a sensible generic
    status bar message, and optionally sets up the progress bar. It then runs
    the main() function. Once everything finishes it cleans up after the main()
    function, making sure everything is sane before the script terminates."""
    try:
        #scribus.statusMessage("Running script...")
        scribus.progressReset()
        main(argv)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if scribus.haveDoc():
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
def main_wrapper(argv):
    try:
        if(scribus.haveDoc()):
            scribus.setRedraw(False)
            scribus.statusMessage(CONST.APP_NAME)
            scribus.progressReset()
            main(argv)
        else:
            scribus.messageBox('Usage Error', 'You need a Document open', icon=scribus.ICON_WARNING, button1=scribus.BUTTON_OK)
            sys.exit(2)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if scribus.haveDoc():
            scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()
Example #22
0
def importColors(colorlist):
        """check if colors exists an import"""
        colordict=getColorDict()
        scribus.statusMessage("Defining new colors...")
        scribus.progressTotal(len(colorlist))
        i=0
        for color in colorlist:
            name=color[0]
            c=color[1]
            m=color[2]
            y=color[3]
            k=color[4]
            while colordict.has_key(name):# check if color already exists - then add PREFIX to name
                name = PREFIX+name
            
            scribus.defineColor(name, c, m, y, k)
            i=i+1
            scribus.progressSet(i)
Example #23
0
def importColors(colorlist):
    """check if colors exists an import"""
    colordict = getColorDict()
    scribus.statusMessage("Defining new colors...")
    scribus.progressTotal(len(colorlist))
    i = 0
    for color in colorlist:
        name = color[0]
        c = color[1]
        m = color[2]
        y = color[3]
        k = color[4]
        while name in colordict:  # check if color already exists - then add PREFIX to name
            name = PREFIX + name

        scribus.defineColorCMYK(name, c, m, y, k)
        i = i + 1
        scribus.progressSet(i)
def main(argv):
    """The main() function disables redrawing, sets a sensible generic
    status bar message, and optionally sets up the progress bar. It then runs
    the main() function. Once everything finishes it cleans up after the create()
    function, making sure everything is sane before the script terminates."""
    currentDoc = scribus.getDocName()
    try:
        scribus.statusMessage("Importing .csv table...")
        scribus.progressReset()
        create(argv)
        if scribus.haveDoc():
	  scribus.closeDoc()
	scribus.openDoc(currentDoc)
    finally:
        # Exit neatly even if the script terminated with an exception,
        # so we leave the progress bar and status bar blank and make sure
        # drawing is enabled.
        if scribus.haveDoc():
            scribus.setRedraw(True)
            scribus.closeDoc()
	scribus.openDoc(currentDoc)
        scribus.statusMessage("")
        scribus.progressReset()
Example #25
0
def main_wrapper():
   """The main_wrapper() function disables redrawing, sets a sensible generic
   status bar message, and optionally sets up the progress bar. It then runs
   the main() function. Once everything finishes it cleans up after the main()
   function, making sure everything is sane before the script terminates."""
   scribus.messageBox("Version",SCRIPT_VERSION)
   if not scribus.haveDoc():
      scribus.messageBox("Bwaaaahaha","Need a base document open")
   else:
      scribus.setRedraw(False)
      try:
          scribus.statusMessage("Running script...")
          scribus.progressReset()
          main()
      finally:
          # Exit neatly even if the script terminated with an exception,
          # so we leave the progress bar and status bar blank and make sure
          # drawing is enabled.
          if scribus.haveDoc():
              scribus.setRedraw(True)
              scribus.docChanged(True)
          scribus.statusMessage("")
          scribus.progressReset()
Example #26
0
def main_wrapper():
    """The main_wrapper() function disables redrawing, sets a sensible generic
   status bar message, and optionally sets up the progress bar. It then runs
   the main() function. Once everything finishes it cleans up after the main()
   function, making sure everything is sane before the script terminates."""
    scribus.messageBox("Version", SCRIPT_VERSION)
    if not scribus.haveDoc():
        scribus.messageBox("Bwaaaahaha", "Need a base document open")
    else:
        scribus.setRedraw(False)
        try:
            scribus.statusMessage("Running script...")
            scribus.progressReset()
            main()
        finally:
            # Exit neatly even if the script terminated with an exception,
            # so we leave the progress bar and status bar blank and make sure
            # drawing is enabled.
            if scribus.haveDoc():
                scribus.setRedraw(True)
                scribus.docChanged(True)
            scribus.statusMessage("")
            scribus.progressReset()
Example #27
0
def generateContent(string, window):

    #generates all the elements/only one element
    start = 0
    end = 0
    if string == "all":
        #dont include the first line to make the data sort work [1:]
        #sort the the elements by date
        data = sorted(getCSVdata()[1:],
                      key=lambda row: dateFun(str.strip(row[5])),
                      reverse=True)
        end = len(data)
        print(str(end) + "  " + str(start))
        print("generating elements from all lines")
        window.destroy()
    elif RepresentsInt(string):
        start = int(string) - 1  #index shifting
        end = int(string)
        print("only generating line " + string)
        data = getCSVdata()
        window.destroy()
    else:
        print(string + " is not a valid value")
        print("exiting")
        window.destroy()
        sys.exit()

    if not scribus.haveDoc() > 0:  #do we have a doc?
        scribus.messageBox("importcvs2table",
                           "No opened document.\nPlease open one first.")
        sys.exit()
    userdim = scribus.getUnit()  #get unit and change it to mm
    scribus.setUnit(scribus.UNIT_MILLIMETERS)

    lineWidth = 3.92  #aka 1.383mm, kp warum

    rowDate = ""
    for i in range(start, end):

        rowName = str.strip(data[i][0])
        rowCategory = str.strip(data[i][1])
        rowDescription = str.strip(data[i][2])
        rowPrice = str.strip(data[i][3])
        rowPlace = str.strip(data[i][4])
        rowDate = str.strip(data[i][5])
        rowTime = str.strip(data[i][6])

        if rowName == "":  #skip empty csv lines
            continue

        print("add element: " + rowName)

        #random values
        hpos = 120.0
        vpos = 200.0
        hposition = 120.0
        vposition = 200.0

        objectlist = []  #list for all boxes

        x = 0  #sets the progress
        #create the blue box
        print("create the blue line")
        blueBox = scribus.createLine(hposition + 1, vposition, hposition + 1,
                                     vposition + 5.863)
        scribus.setLineColor("Cyan", blueBox)
        scribus.setLineWidth(lineWidth, blueBox)
        objectlist.append(blueBox)
        scribus.progressSet(x)

        x = 1
        #create the data character box
        #these are the width values for the numbers
        zero = 4.608
        one = 2.839
        two = 4.724
        three = 4.393
        four = 4.625
        five = 4.261
        six = 4.278
        seven = 4.261
        eight = 4.625
        nine = 4.708

        lenArray = [zero, one, two, three, four, five, six, seven, eight, nine]

        marginleft = 1.3
        margintop = 0.519  #substract, cause the box is heigher that the blue line
        cellwidthright = 10.951
        cellHeight = 8.282
        hposition = hposition + marginleft + 1
        textbox = scribus.createText(hposition, vposition - margintop,
                                     cellwidthright, cellHeight)
        scribus.setFont("Quicksand Regular", textbox)
        scribus.setFontSize(20.0, textbox)
        finalDate = ""
        rowDateLength = 0
        #checks if the rowDate is from 01-09, in that case remove the zero
        if rowDate[0] == '0':
            finalDate = rowDate[1]
            rowDateLength = lenArray[int(rowDate[1])]

        else:
            finalDate = rowDate[:2]
            rowDateLength = lenArray[int(rowDate[0])] + lenArray[int(
                rowDate[1])]

        scribus.insertText(finalDate, 0, textbox)
        print("day: " + finalDate)
        objectlist.append(textbox)
        scribus.progressSet(x)

        x = 2
        #create the month/day box
        print("create the box with the day and month")
        width = 19.447
        height = 8.025
        marginleft = rowDateLength  #gain that from the calculations above, depends on the width of the rowDate characters

        monthBox = scribus.createText(hposition + marginleft + 0.7, vposition,
                                      width, height)
        scribus.setFont("Quicksand Regular", monthBox)
        scribus.setFontSize(8.5, monthBox)

        month = ""
        m = rowDate[3:5]
        if m == '01':
            month = "Januar"
        elif m == '02':
            month = "Februar"
        elif m == '03':
            month = "März"
        elif m == '04':
            month = "April"
        elif m == '05':
            month = "Mai"
        elif m == '06':
            month = "Juni"
        elif m == '07':
            month = "Juli"
        elif m == '08':
            month = "August"
        elif m == '09':
            month = "September"
        elif m == '10':
            month = "Oktober"
        elif m == '11':
            month = "November"
        elif m == '12':
            month = "Dezember"
        else:
            print("cant determine month!")

        day = datetime.date(int(rowDate[6:]), int(m),
                            int(rowDate[:2])).weekday()
        dayName = ""

        if day == 0:
            dayName = "Montag"
        elif day == 1:
            dayName = "Dienstag"
        elif day == 2:
            dayName = "Mittwoch"
        elif day == 3:
            dayName = "Donnerstag"
        elif day == 4:
            dayName = "Freitag"
        elif day == 5:
            dayName = "Samstag"
        elif day == 6:
            dayName = "Sonntag"
        else:
            print("cant determine day!")

        text = month + "\n" + dayName
        scribus.setStyle("Kalender_neu_Monat und Tag", monthBox)
        scribus.insertText(text, 0, monthBox)
        print("month: " + month + " day: " + dayName)
        objectlist.append(monthBox)
        scribus.progressSet(x)

        x = 3
        #create the main text box
        print("create the main text box")
        margintop = 5.5
        hpos = hpos - 0.383  #i dont know why but scribus always places the element 0.383 right than it should be :/
        mainTextBox = scribus.createText(
            hpos, vposition + margintop, 43.0,
            45.0)  #minus eins weil der blaue balken seinen kasten overflowed

        #insert category
        print("insert the category: " + rowCategory)
        scribus.insertText(rowCategory, 0, mainTextBox)
        endCategory = scribus.getTextLength(mainTextBox)
        scribus.selectText(0, endCategory, mainTextBox)
        scribus.setFontSize(10.5, mainTextBox)
        scribus.selectText(0, endCategory, mainTextBox)
        scribus.setStyle("Kalender_Eventname", mainTextBox)

        #insert main text
        print("insert the main text")
        scribus.insertText("\n" + rowDescription, endCategory, mainTextBox)
        endMainText = scribus.getTextLength(mainTextBox) - endCategory
        scribus.selectText(endCategory, endMainText, mainTextBox)
        scribus.setStyle("Kalender_Eventbeschreibung", mainTextBox)

        #get start length to color everything black and set font size
        startAll = scribus.getTextLength(mainTextBox)
        createPlaceTimePrice(mainTextBox, "\n| Ort: ", "",
                             "Kalender_Eventname")

        #insert value for place
        createPlaceTimePrice(mainTextBox, rowPlace, "Heuristica Regular", "")

        #insert time letters
        createPlaceTimePrice(mainTextBox, " | Zeit: ", "Quicksand Regular", "")

        #insert time value
        createPlaceTimePrice(mainTextBox, rowTime, "Heuristica Regular", "")

        #insert price letters
        createPlaceTimePrice(mainTextBox, " | Eintritt: ", "Quicksand Regular",
                             "")

        #insert price value
        createPlaceTimePrice(mainTextBox, rowPrice, "Heuristica Regular", "")

        #setFontSize and black color for the whole detail box
        endAll = scribus.getTextLength(mainTextBox) - startAll
        scribus.selectText(startAll, endAll, mainTextBox)
        scribus.setFontSize(8.5, mainTextBox)
        scribus.selectText(startAll, endAll, mainTextBox)
        scribus.setTextColor("Black", mainTextBox)

        objectlist.append(mainTextBox)
        scribus.progressSet(x)

        #do some generell stuff
        scribus.groupObjects(objectlist)
        scribus.progressReset()
        scribus.setUnit(userdim)  # reset unit to previous value
        scribus.docChanged(True)
        scribus.statusMessage("Done")
        scribus.setRedraw(True)

    print("done")
    return 0
Example #28
0
def create_guide(gp):
    fh = FrameHandler()
    toc = TableOfContents(gp.numpagesforcontents)
    index = ClimbIndex()

    scribus.statusMessage("Creating document...")
    nchapters = len(gp.chapters)
    scribus.progressTotal(nchapters)
    scribus.progressReset()
    progress = 0

    currentregion = ""
    crag = ""

    for (xmlid, region) in gp.chapters:
        scribus.statusMessage("Parsing " + xmlid + "...")
        progress = progress + 1
        scribus.progressTotal(nchapters)
        scribus.progressSet(progress)

        p = xml.dom.minidom.parse(gp.path + os.sep + xmlid + os.sep + xmlid +
                                  ".xml")

        for g in p.getElementsByTagName("guide"):

            for n in g.childNodes:

                if n.nodeName == "header":

                    intro = n.getAttribute("intro")
                    name = n.getAttribute("name")
                    rock = n.getAttribute("rock")
                    sun = n.getAttribute("sun")
                    access = n.getAttribute("access")
                    acknow = n.getAttribute("acknowledgement")
                    walk = n.getAttribute("walk")
                    camping = n.getAttribute("camping")
                    history = n.getAttribute("history")
                    stars = g.getAttribute("guidestars").replace(
                        "*", GLYPH_STAR)

                    scribus.statusMessage("Parsing " + xmlid + " (" + name +
                                          ")...")
                    scribus.progressTotal(nchapters)
                    scribus.progressSet(progress)

                    fh.endFrame()
                    #fh.sidebar.setText("")
                    fh.sidebar.setText(name)
                    fh.newPage()
                    fh.setColumns(1)
                    #if scribus.currentPage() % 2 != 0:
                    #   fh.newPage()

                    fh.placeText(name,
                                 "Title",
                                 columns=1,
                                 keepwithnext=True,
                                 nosplit=True)
                    if region != currentregion:
                        toc.add(region, 1, scribus.currentPage())
                        currentregion = region
                    toc.add(name + " " + stars, 2, scribus.currentPage())
                    crag = name
                    #fh.sidebar.setText(crag)

                    graphpath = gp.path + os.sep + xmlid + os.sep + "graph.pdf"
                    fh.placeGuide(rock, sun, walk, graphpath, iconpath=gp.path)

                    if len(acknow) > 0:
                        fh.placeText("Contributors",
                                     "IntroTitle",
                                     nosplit=True,
                                     keepwithnext=True)
                        fh.placeText(acknow, "Intro", nosplit=True)

                    if len(intro) > 0:
                        fh.placeText("General Rave",
                                     "IntroTitle",
                                     nosplit=True,
                                     keepwithnext=True)
                        fh.placeText(intro, "Intro")

                    if len(history) > 0:
                        fh.placeText("History",
                                     "IntroTitle",
                                     nosplit=True,
                                     keepwithnext=True)
                        fh.placeText(history, "Intro")

                    if len(access) > 0:
                        fh.placeText("Access",
                                     "IntroTitle",
                                     nosplit=True,
                                     keepwithnext=True)
                        fh.placeText(access, "Intro")

                    if len(camping) > 0:
                        fh.placeText("Camping",
                                     "IntroTitle",
                                     nosplit=True,
                                     keepwithnext=True)
                        fh.placeText(camping, "Intro")

                    fh.endFrame()

                    fh.setColumns(2)

                elif n.nodeName == "climb" or n.nodeName == "problem":

                    extra = n.getAttribute("extra")
                    grade = n.getAttribute("grade")
                    length = n.getAttribute("length")
                    name = n.getAttribute("name")
                    fa = n.getAttribute("fa")
                    stars = n.getAttribute("stars").replace("*", GLYPH_STAR)
                    number = n.getAttribute("number")

                    scribus.statusMessage("Parsing " + xmlid + " (" + crag +
                                          ") " + name)
                    scribus.progressTotal(nchapters)
                    scribus.progressSet(progress)

                    # OK for now, but we will want to break this up later
                    routename = stars + "  " + name + "  " + length + "  " + grade + "  " + extra
                    if number != "":
                        routename = "(" + number + ")  " + routename

                    #routename = chr(TAB) + stars + chr(TAB) + name + chr(TAB) + length + chr(TAB) + grade + chr(TAB) + extra
                    #if number != "":
                    #   routename = "(" + number + ")" + routename

                    fh.placeText(routename,
                                 "Route Name",
                                 columns=2,
                                 nosplit=True,
                                 keepwithnext=True)

                    for t in n.childNodes:
                        if t.nodeType == 3:
                            txt = t.nodeValue
                            #fh.placeText(t.nodeValue, "Route Description", columns=2, nosplit=True, keepwithnext=(len(fa)>0))
                            fh.placeText(txt,
                                         "Route Description",
                                         columns=2,
                                         nosplit=(len(txt) < NOSPLIT_LIMIT),
                                         keepwithnext=(len(fa) > 0))

                    if len(fa) > 0:
                        fh.placeText(fa, "FA Details", columns=2, nosplit=True)

                    if n.nodeName == "climb":
                        index.add(name, grade, stars, crag,
                                  scribus.currentPage())
                        if name[:3] == "The":
                            index.add(name[4:] + ", The", grade, stars, crag,
                                      scribus.currentPage())
                        #if name in gp.aliases:
                        #   index.add(gp.aliases[name].decode("utf-8"), grade, stars, crag, scribus.currentPage())
                        #   print "Alias Match (via key): " + name + " matches " + route + " substitute " + alternatename
                        for (route, alternatename) in gp.aliases.iteritems():
                            if name == route:
                                #     print "Alias Match(via unrolled niceness): " + name + " matches " + route + " substitute " + alternatename
                                index.add(alternatename.decode("utf-8"), grade,
                                          stars, crag, scribus.currentPage())

                elif n.nodeName == "text":

                    # class can be one of...
                    #    text, heading1, heading2, heading3, intro, indentedHeader
                    #    Editor, Discussion, DiscussionNoIndents, noPrint
                    # assign Style to class name & control layout from Scribus Style Editor

                    clss = n.getAttribute("class")
                    if clss == "": clss = "text"

                    for t in n.childNodes:
                        if t.nodeType == 3:
                            txt = t.nodeValue

                            if clss == "indentedHeader":
                                firstline = txt.split("\n")[0]
                                rest = txt[len(firstline) + 1:]
                                if firstline[-1] == ":":
                                    fh.placeText(firstline[:-1],
                                                 "heading3",
                                                 nosplit=True,
                                                 keepwithnext=True)
                                    fh.placeText(rest, "Intro")
                                else:
                                    fh.placeText(txt, "Intro")

                            elif clss == "heading3":
                                fh.placeText(GLYPH_RIGHTPOINTER + " " + txt,
                                             clss,
                                             nosplit=True,
                                             keepwithnext=True)
                                #if txt != currentregion:
                                toc.add(txt, 4, scribus.currentPage())

                            elif clss == "heading2":
                                #fh.endFrame()
                                fh.placeText(txt,
                                             clss,
                                             columns=2,
                                             nosplit=True,
                                             keepwithnext=True)
                                #if txt != currentregion:
                                toc.add(txt, 3, scribus.currentPage())

                            elif clss == "heading1":
                                fh.endFrame()
                                fh.sidebar.setText("")
                                #fh.sidebar.setText(txt)
                                fh.newPage()
                                fh.placeText(txt,
                                             "Title",
                                             columns=1,
                                             nosplit=True,
                                             keepwithnext=True)
                                if region != currentregion:
                                    toc.add(region, 1, scribus.currentPage())
                                    currentregion = region
                                toc.add(txt, 2, scribus.currentPage())

                            elif clss == "intro":
                                fh.placeText(txt,
                                             "Intro",
                                             nosplit=True,
                                             keepwithnext=True)

                            elif clss == "text":
                                fh.placeText(txt,
                                             clss,
                                             columns=2,
                                             nosplit=True,
                                             keepwithnext=True)
                                #fh.placeText(txt, clss, nosplit=True, keepwithnext=False)

                elif n.nodeName == "image":
                    src = n.getAttribute("src")
                    legend = n.getAttribute("legend")
                    legendtitle = n.getAttribute("legendTitle")
                    legendfooter = n.getAttribute("legendFooter")
                    noprint = n.getAttribute("noPrint")

                    scribus.statusMessage("Parsing " + xmlid + " (" + crag +
                                          ") image=" + src)
                    scribus.progressTotal(nchapters)
                    scribus.progressSet(progress)

                    if src in gp.images:
                        attr = gp.images[src]
                    else:
                        attr = {}

                    if noprint != "true":
                        fullsrc = gp.path + os.sep + xmlid + os.sep + src
                        if not os.path.exists(fullsrc):
                            scribus.messageBox('Bummer, dude',
                                               'Image file missing: ' +
                                               fullsrc,
                                               icon=scribus.ICON_WARNING)
                        else:
                            try:
                                i = Image.open(fullsrc)
                                (width, height) = i.size
                                attr["width"] = width
                                attr["height"] = height
                                if legend == "true":
                                    if len(legendtitle.strip()) > 0:
                                        attr["title"] = legendtitle
                                    if len(legendfooter.strip()) > 0:
                                        attr["footer"] = legendfooter
                                fh.placeImage(fullsrc, attr)
                            except IOError:
                                scribus.messageBox(
                                    "Bummer, dude",
                                    "Image file corrupt: " + fullsrc)

        fh.expandFrame()
        fh.endGuide()

    if gp.includeindexbyname:
        scribus.statusMessage("Creating index by name...")
        scribus.progressReset()
        scribus.newPage(-1)
        if scribus.currentPage() % 2 == 0:  # even page
            scribus.newPage(-1)
        page = scribus.currentPage()
        index.drawIndexByName()
        toc.add("Index by Route Name", 1, page)
    if gp.includeindexbygrade:
        scribus.statusMessage("Creating index by grade...")
        scribus.progressReset()
        scribus.newPage(-1)
        page = scribus.currentPage()
        index.drawIndexByGrade()
        toc.add("Index by Grade", 1, page)
    if gp.levelsofcontents > 0:
        scribus.statusMessage("Creating table of contents...")
        scribus.progressReset()
        toc.draw(gp.levelsofcontents)
try:
    import MySQLdb
except ImportError:
    print "You must have 'MySQLdb' installed."
    sys.exit(1)


# connection parameters
hostname = 'server.foo.org'
dbname = 'name'
username = '******'
password = '******'

# connection to the network wide server would be time consuming. So get the hint to the user.
scribus.statusMessage('Connecting to the ' + hostname + ' server. Be patient, please...')

# Database related issues
try:
    conn = MySQLdb.connect(passwd=password, db=dbname, host=hostname, user=username)
except:
	scribus.messageBox('DB connection example', 'Connection error. You should specify your login in the script')
	sys.exit(1)

cur = conn.cursor()
# get the list of the databases
# it's like 'select * from dba_tables' in Oracle
count = cur.execute('show tables')
# formating the output
result = str(count) + ' table(s) in the ' + dbname + ' database.\n\n'
for i in cur.fetchall():
Example #30
0
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):
    userdim = scribus.getUnit()  # get unit and change it to mm
    scribus.setUnit(scribus.UNIT_MILLIMETERS)
    cellwidthleft = 0
    cellwidthright = 0
    # Set starting position
    hposition = 28
    vposition = 20
    data = getCSVdata()
    di = getDataInformation(data)
    ncol = len(data[0])
    nrow = len(data)
    scribus.messageBox("Table", "   " + str(ncol) + " columns,    " +
                       str(nrow) + " rows   ")  #jpg
    ColWidthList = []
    TableWidth = 0
    RowHeightList = []
    TableHeight = 0
    i = 0
    for row in data:
        if i == 0:
            c = 0
            for cell in row:
                ColWidth = 40
                ColWidthList.append(ColWidth)
        TableWidth = TableWidth + ColWidth
        c = c + 1
        RowHeight = 15
        RowHeightList.append(RowHeight)
        TableHeight = TableHeight + RowHeight
        i = i + 1
    objectlist = [
    ]  # here we keep a record of all the created textboxes so we can group them later
    i = 0
    scribus.progressTotal(len(data))
    scribus.setRedraw(False)
    rowindex = 0
    new_row_indication = 1
    new_page_indication = 1
    firstorigin_indicator = 1
    while rowindex < len(data):
        c = 0
        origin_cd = data[rowindex][0].strip()
        origin = data[rowindex][1].strip()
        origin_complete = origin + ' (' + origin_cd + ")"
        headerorigin = origin_complete
        origin_added = 0
        destination_cd = data[rowindex][2].strip()
        destination = data[rowindex][3].strip()
        destination_complete = destination + ' (' + destination_cd + ")"
        fareplan = data[rowindex][4].strip()
        fareplan_type = data[rowindex][5].strip()
        fareplan_complete = fareplan + ' ' + fareplan_type[:1]
        fare = data[rowindex][6].strip()
        fare = float(fare)
        fare = "{0:.2f}".format(fare)
        fare_onboard = data[rowindex][7].strip()
        fare_onboard = float(fare_onboard)
        fare_onboard = "{0:.2f}".format(fare_onboard)
        cellheight_market = 5
        cellheight_market_dos = 5

        try:
            last_origin = data[rowindex - 1][1].strip()
        except:
            last_origin = origin

        try:
            last_destination = data[rowindex - 1][3].strip()
        except:
            last_destination = destination

        cellsize = ColWidthList[c]
        cellHeight = RowHeightList[i]

        # Check to see if near bottom of the page, if so wrap it over
        if (vposition > 227):
            hposition = hposition + cellsize
            vposition = 20
            new_row_indication = 1
        # If at end, reset and create new page
        if (hposition > 174):
            scribus.newPage(-1)
            hposition = 28
            vposition = 20
            new_page_indication = 1
            firstorigin_indicator = 0

        if new_row_indication == 1:
            textbox = scribus.createText(hposition, 16, cellsize / 2,
                                         4)  # create a textbox.
            objectlist.append(textbox)
            scribus.setStyle('FareplanHeader', textbox)
            scribus.insertText('Fareplan', 0, textbox)
            c = c + 1

            textbox = scribus.createText(hposition + (cellsize / 2), 16,
                                         cellsize / 2, 4)  # create a textbox.
            objectlist.append(textbox)
            scribus.setStyle('FareplanHeader', textbox)
            scribus.insertText('Amount', 0, textbox)
            c = c + 1


#			if (firstorigin_indicator == 1):
#				headerorigin = origin_complete
#				textbox = scribus.createText(20, 10, cellsize*4, 4) # create a textbox.
#				objectlist.append(textbox)
#				scribus.setStyle('HeaderOrigin', textbox)
#				scribus.insertText(headerorigin, 0, textbox)
#				c = c + 1

# Origin textbox
        if (rowindex < len(data)):
            if ((origin != last_origin) or (rowindex == 0)):
                # Add 'btwn' text
                textbox = scribus.createText(hposition, vposition, cellsize,
                                             4)  # create a textbox.
                objectlist.append(textbox)
                scribus.setStyle(
                    'Headings', textbox
                )  # set it in the style 'Headings' as defined in Scribus.
                scribus.insertText(
                    'btwn', 0, textbox)  # insert the origin into the textbox.
                # scribus.setDistances(1,1,1,1) # set the distances.
                vposition = vposition + 4  # Shift position of cell down.
                c = c + 1

                textbox = scribus.createText(
                    hposition, vposition, cellsize,
                    cellheight_market_dos)  # create a textbox.
                objectlist.append(textbox)
                scribus.setStyle(
                    'Headings', textbox
                )  # set it in the style 'Headings' as defined in Scribus.
                scribus.insertText(
                    origin_complete, 0,
                    textbox)  # insert the origin into the textbox.
                while (scribus.textOverflows(textbox) > 0):
                    cellheight_market_dos += 1
                    scribus.sizeObject(cellsize, cellheight_market_dos,
                                       textbox)
                vposition = vposition + cellheight_market_dos  # Shift position of cell down.
                c = c + 1

                # Add 'and' text
                textbox = scribus.createText(hposition, vposition, cellsize,
                                             4)  # create a textbox.
                objectlist.append(textbox)
                scribus.setStyle(
                    'andStyle', textbox
                )  # set it in the style 'andStyle' as defined in Scribus.
                scribus.insertText(
                    'and', 0, textbox)  # insert the origin into the textbox.
                vposition = vposition + 4  # Shift position of cell down.
                c = c + 1

                origin_added = 1
                firstorigin_indicator = firstorigin_indicator + 1

                # Insert the origin at the top margin
                if (firstorigin_indicator == 1 or rowindex == 0):
                    headerorigin = origin_complete
                    textbox = scribus.createText(28, 10, cellsize * 4,
                                                 4)  # create a textbox.
                    objectlist.append(textbox)
                    scribus.setStyle('HeaderOrigin', textbox)
                    scribus.insertText(headerorigin, 0, textbox)
                    c = c + 1

        # Destination textbox
        if ((destination != last_destination) or (rowindex == 0)
                or (origin_added == 1)):
            textbox = scribus.createText(
                hposition, vposition, cellsize,
                cellheight_market)  # create a textbox.
            objectlist.append(textbox)
            scribus.setStyle(
                'Headings', textbox
            )  # set it in the style 'Headings' as defined in Scribus.
            scribus.insertText(
                destination_complete, 0,
                textbox)  # insert the destination into the textbox.
            while (scribus.textOverflows(textbox) > 0):
                cellheight_market += 1
                scribus.sizeObject(cellsize, cellheight_market, textbox)

            vposition = vposition + cellheight_market  # Shift position of cell down.
            c = c + 1
        rowindex = rowindex + 1

        # Fareplan textbox
        fareplan_box_height = 5
        if fare_onboard != '0.00':
            fareplan_box_height = 10
        textbox = scribus.createText(hposition, vposition, cellsize / 2,
                                     fareplan_box_height)  # create a textbox.
        objectlist.append(textbox)
        scribus.insertText(fareplan_complete, 0,
                           textbox)  # insert the fareplan into the textbox.
        hposition = hposition + (cellsize / 2)  # Shift position of cell right.
        c = c + 1

        # Fare textbox
        textbox = scribus.createText(hposition, vposition, cellsize / 2,
                                     5)  # create a textbox.
        objectlist.append(textbox)
        scribus.insertText(fare, 0,
                           textbox)  # insert the fare into the textbox.
        c = c + 1

        if fare_onboard != '0.00':
            vposition = vposition + 5  # Shift position of cell down.
            textbox = scribus.createText(hposition, vposition, cellsize / 2,
                                         5)  # create a textbox.
            objectlist.append(textbox)
            scribus.setStyle('OnBoard', textbox)
            scribus.insertText(fare_onboard, 0,
                               textbox)  # insert the fare into the textbox.
            hposition = hposition - (cellsize / 2
                                     )  # Shift position of cell back.
            vposition = vposition + 5  # Shift position of cell down.
            c = c + 1
        else:
            hposition = hposition - (cellsize / 2
                                     )  # Shift position of cell back.
            vposition = vposition + 5  # Shift position of cell down.
        i = i + 1
        new_row_indication = 0
        new_page_indication = 0

    scribus.deselectAll()
    scribus.groupObjects(objectlist)
    scribus.progressReset()
    scribus.setUnit(userdim)  # reset unit to previous value
    scribus.docChanged(True)
    scribus.statusMessage("Done")
    scribus.setRedraw(True)
	pdf = scribus.PDFfile()
	pdf.info = pdfname
	pdf.pages = [1]
        pdf.file = os.path.join(baseDirName, pdfname+'.pdf')
        pdf.save()
        
        #Incarese Rowcount and update Progress
        i = i + 1;
        scribus.progressSet(i)
    
    #Done Close tmpfile and remove it
    scribus.closeDoc()
    os.remove(tmpFileName)
    
    scribus.progressReset()
    scribus.statusMessage("Done")
 
 
def main(argv):
    """The main() function disables redrawing, sets a sensible generic
    status bar message, and optionally sets up the progress bar. It then runs
    the main() function. Once everything finishes it cleans up after the create()
    function, making sure everything is sane before the script terminates."""
    currentDoc = scribus.getDocName()
    try:
        scribus.statusMessage("Importing .csv table...")
        scribus.progressReset()
        create(argv)
        if scribus.haveDoc():
	  scribus.closeDoc()
	scribus.openDoc(currentDoc)
Example #33
0
    sys.exit(1)

try:
    import MySQLdb
except ImportError:
    print "You must have 'MySQLdb' installed."
    sys.exit(1)

# connection parameters
hostname = 'server.foo.org'
dbname = 'name'
username = '******'
password = '******'

# connection to the network wide server would be time consuming. So get the hint to the user.
scribus.statusMessage('Connecting to the ' + hostname +
                      ' server. Be patient, please...')

# Database related issues
try:
    conn = MySQLdb.connect(passwd=password,
                           db=dbname,
                           host=hostname,
                           user=username)
except:
    scribus.messageBox(
        'DB connection example',
        'Connection error. You should specify your login in the script')
    sys.exit(1)

cur = conn.cursor()
# get the list of the databases
def main():
    cache = defaultdict(dict)
    try:
        with open(CACHE_FILE, "rb") as cache_file:
            cache = defaultdict(dict, json.load(cache_file))
    except:
        pass

    with open(DATA_FILE, "rb") as data_file:
        songs_data = json.load(data_file)

    with open(MANUEL_PROCESSING_FILE, "rb") as manual_file:
        manual_processing = defaultdict(dict, json.load(manual_file))

    scribus.statusMessage("Running script...")
    scribus.progressReset()
    scribus.progressTotal(len(songs_data))

    init()
    front_matter()
    add_page_number()

    # trying to get the best sorting
    # setting all songs to the max height
    all_songs = dict(
        zip(songs_data.keys(), [EFFECTIVE_PAGE_HEIGHT] * len(songs_data)))
    # update according to cache
    for song_name, data in cache.iteritems():
        all_songs[song_name] = min(data.get("height", EFFECTIVE_PAGE_HEIGHT),
                                   EFFECTIVE_PAGE_HEIGHT)
    # let's see which songs should be set on a double sided page:
    songs_double_page = filter(
        lambda x: manual_processing[x].get("double_page", False),
        manual_processing)
    for double_page in songs_double_page:
        all_songs[
            double_page] = EFFECTIVE_PAGE_HEIGHT  # all double page songs should get a whole page despite their height

    appendix_filter = lambda a_s, boolean: {
        k: v
        for k, v in a_s.iteritems()
        if manual_processing[k].get("appendix", False) == boolean
    }

    main_songs = appendix_filter(all_songs, False)
    add_songs(main_songs, songs_double_page, manual_processing, songs_data,
              cache)

    appendix_songs = appendix_filter(all_songs, True)
    add_songs(appendix_songs, songs_double_page, manual_processing, songs_data,
              cache)

    toc = []
    for filename in filter(lambda s: manual_processing[s].get("show", True),
                           all_songs.keys()):
        toc.append(
            (songs_data[filename]["name"], cache[filename].get("page", "XX")))
    toc.sort(key=lambda (x, y): x)
    create_toc(toc)

    if scribus.haveDoc():
        scribus.setRedraw(True)
        scribus.statusMessage("")
        scribus.progressReset()

    with open(CACHE_FILE, "wb") as cache_file:
        json.dump(cache, cache_file, indent=2)
Example #35
0
def create_guide(gp):
   fh = FrameHandler()
   toc = TableOfContents(gp.numpagesforcontents)
   index = ClimbIndex()

   scribus.statusMessage("Creating document...")
   nchapters = len(gp.chapters)
   scribus.progressTotal(nchapters)
   scribus.progressReset()
   progress = 0
   
   currentregion = ""
   crag = ""
   
   
   for (xmlid,region) in gp.chapters:
      scribus.statusMessage("Parsing " + xmlid + "...")
      progress = progress + 1
      scribus.progressTotal(nchapters)
      scribus.progressSet(progress)
  
      p = xml.dom.minidom.parse(gp.path + os.sep + xmlid + os.sep + xmlid + ".xml")
               
      for g in p.getElementsByTagName("guide"):
         
         for n in g.childNodes:

            if n.nodeName == "header":
         
               intro = n.getAttribute("intro")
               name = n.getAttribute("name")
               rock = n.getAttribute("rock")
               sun = n.getAttribute("sun")
               access = n.getAttribute("access")
               acknow = n.getAttribute("acknowledgement")
               walk = n.getAttribute("walk")
               camping = n.getAttribute("camping")
               history = n.getAttribute("history")
               stars = g.getAttribute("guidestars").replace("*",GLYPH_STAR)
            
               scribus.statusMessage("Parsing " + xmlid + " (" + name + ")...")
               scribus.progressTotal(nchapters)
               scribus.progressSet(progress)
               
               fh.endFrame()
               #fh.sidebar.setText("")
               fh.sidebar.setText(name)
               fh.newPage()
               fh.setColumns(1)
               #if scribus.currentPage() % 2 != 0:
               #   fh.newPage()
            
               fh.placeText(name, "Title", columns=1, keepwithnext=True, nosplit=True)
               if region != currentregion:
                  toc.add(region, 1, scribus.currentPage())
                  currentregion = region
               toc.add(name + " " + stars,2,scribus.currentPage())
               crag = name
               #fh.sidebar.setText(crag)
                  
               graphpath = gp.path + os.sep + xmlid + os.sep + "graph.pdf"
               fh.placeGuide(rock, sun, walk, graphpath, iconpath=gp.path)
               
               if len(acknow) > 0:
                  fh.placeText("Contributors", "IntroTitle", nosplit=True, keepwithnext=True)
                  fh.placeText(acknow, "Intro", nosplit=True)
            
               if len(intro) > 0:
                  fh.placeText("General Rave", "IntroTitle", nosplit=True, keepwithnext=True)
                  fh.placeText(intro, "Intro")
                     
               if len(history) > 0:
                  fh.placeText("History", "IntroTitle", nosplit=True, keepwithnext=True)
                  fh.placeText(history, "Intro")
                     
               if len(access) > 0:
                  fh.placeText("Access", "IntroTitle", nosplit=True, keepwithnext=True)
                  fh.placeText(access, "Intro")
                     
               if len(camping) > 0:
                  fh.placeText("Camping", "IntroTitle", nosplit=True, keepwithnext=True)
                  fh.placeText(camping, "Intro")
            
               fh.endFrame()  
               
               fh.setColumns(2)        
            
  
            elif n.nodeName == "climb" or n.nodeName == "problem":

               
               extra = n.getAttribute("extra")
               grade = n.getAttribute("grade")
               length = n.getAttribute("length")
               name = n.getAttribute("name")
               fa = n.getAttribute("fa")
               stars = n.getAttribute("stars").replace("*",GLYPH_STAR)
               number = n.getAttribute("number")

               scribus.statusMessage("Parsing " + xmlid + " (" + crag + ") " + name)
               scribus.progressTotal(nchapters)
               scribus.progressSet(progress)
               
               # OK for now, but we will want to break this up later
               routename = stars + "  " + name + "  " + length + "  " + grade + "  " + extra
               if number != "": routename = "(" + number + ")  " + routename

               #routename = chr(TAB) + stars + chr(TAB) + name + chr(TAB) + length + chr(TAB) + grade + chr(TAB) + extra
               #if number != "":
               #   routename = "(" + number + ")" + routename
            
               fh.placeText(routename, "Route Name", columns=2, nosplit=True, keepwithnext=True)
            
               for t in n.childNodes:
                  if t.nodeType == 3:
                     txt = t.nodeValue
                     #fh.placeText(t.nodeValue, "Route Description", columns=2, nosplit=True, keepwithnext=(len(fa)>0))        
                     fh.placeText(txt, "Route Description", columns=2, nosplit=(len(txt)<NOSPLIT_LIMIT), keepwithnext=(len(fa)>0))        
            
               if len(fa) > 0:
                  fh.placeText(fa, "FA Details", columns=2, nosplit=True)
            
               if n.nodeName == "climb":
                  index.add(name, grade, stars, crag, scribus.currentPage())
                  if name[:3] == "The":
                     index.add(name[4:] + ", The", grade, stars, crag, scribus.currentPage())
                  #if name in gp.aliases:
                  #   index.add(gp.aliases[name].decode("utf-8"), grade, stars, crag, scribus.currentPage())
                  #   print "Alias Match (via key): " + name + " matches " + route + " substitute " + alternatename
                  for (route, alternatename) in gp.aliases.iteritems():
                     if name == route:
                  #     print "Alias Match(via unrolled niceness): " + name + " matches " + route + " substitute " + alternatename
                        index.add(alternatename.decode("utf-8"), grade, stars, crag, scribus.currentPage())




            elif n.nodeName == "text":
         
               # class can be one of...
               #    text, heading1, heading2, heading3, intro, indentedHeader
               #    Editor, Discussion, DiscussionNoIndents, noPrint
               # assign Style to class name & control layout from Scribus Style Editor 
       
               clss = n.getAttribute("class")
               if clss == "": clss = "text"

               for t in n.childNodes:
                  if t.nodeType == 3:
                     txt = t.nodeValue
                  
                     if clss == "indentedHeader":
                        firstline = txt.split("\n")[0]
                        rest = txt[len(firstline)+1:]
                        if firstline[-1] == ":":
                           fh.placeText(firstline[:-1], "heading3", nosplit=True, keepwithnext=True)
                           fh.placeText(rest, "Intro")
                        else:
                           fh.placeText(txt, "Intro")
                     
                     elif clss == "heading3":
                        fh.placeText(GLYPH_RIGHTPOINTER + " " + txt, clss, nosplit=True, keepwithnext=True)
                        #if txt != currentregion:
                        toc.add(txt,4,scribus.currentPage())
                     
                     elif clss == "heading2":
                        #fh.endFrame()
                        fh.placeText(txt, clss, columns=2, nosplit=True, keepwithnext=True)
                        #if txt != currentregion:
                        toc.add(txt,3,scribus.currentPage())
                     
                     elif clss == "heading1":
                        fh.endFrame()
                        fh.sidebar.setText("")
                        #fh.sidebar.setText(txt)
                        fh.newPage()
                        fh.placeText(txt, "Title", columns=1, nosplit=True, keepwithnext=True)
                        if region != currentregion:
                           toc.add(region, 1, scribus.currentPage())
                           currentregion = region
                        toc.add(txt,2,scribus.currentPage())
             
                     elif clss == "intro":
                        fh.placeText(txt, "Intro", nosplit=True, keepwithnext=True)
                        
                     elif clss == "text":
                        fh.placeText(txt, clss, columns=2, nosplit=True, keepwithnext=True)
                        #fh.placeText(txt, clss, nosplit=True, keepwithnext=False)
                     
                     
            elif n.nodeName == "image":
               src = n.getAttribute("src")
               legend = n.getAttribute("legend")
               legendtitle = n.getAttribute("legendTitle")
               legendfooter = n.getAttribute("legendFooter")
               noprint = n.getAttribute("noPrint")

               scribus.statusMessage("Parsing " + xmlid + " (" + crag + ") image=" + src)
               scribus.progressTotal(nchapters)
               scribus.progressSet(progress)
                
               if src in gp.images:
                  attr = gp.images[src]
               else:
                  attr = {}
               
               if noprint != "true":
                  fullsrc = gp.path + os.sep + xmlid + os.sep + src
                  if not os.path.exists(fullsrc):
                     scribus.messageBox('Bummer, dude', 'Image file missing: ' + fullsrc, icon=scribus.ICON_WARNING)
                  else:
                     try:
                        i = Image.open(fullsrc)
                        (width,height) = i.size
                        attr["width"] = width
                        attr["height"] = height
                        if legend == "true":
                           if len(legendtitle.strip()) > 0:
                              attr["title"] = legendtitle
                           if len(legendfooter.strip()) > 0:
                              attr["footer"] = legendfooter
                        fh.placeImage(fullsrc, attr)
                     except IOError:
                        scribus.messageBox("Bummer, dude", "Image file corrupt: " + fullsrc)
                     
      fh.expandFrame()
      fh.endGuide()

      
   if gp.includeindexbyname:
      scribus.statusMessage("Creating index by name...")
      scribus.progressReset()
      scribus.newPage(-1)
      if scribus.currentPage() % 2 == 0:    # even page
         scribus.newPage(-1)
      page = scribus.currentPage()
      index.drawIndexByName()
      toc.add("Index by Route Name",1,page)
   if gp.includeindexbygrade:
      scribus.statusMessage("Creating index by grade...")
      scribus.progressReset()
      scribus.newPage(-1)
      page = scribus.currentPage()
      index.drawIndexByGrade()
      toc.add("Index by Grade",1,page)
   if gp.levelsofcontents > 0:
      scribus.statusMessage("Creating table of contents...")
      scribus.progressReset()
      toc.draw(gp.levelsofcontents)
Example #36
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  #
    #########################
    userdim = scribus.getUnit()  #get unit and change it to mm
    scribus.setUnit(scribus.UNIT_MILLIMETERS)
    cellwidthleft = 0
    cellwidthright = 0
    cellHeight = 0
    pos = getPosition()
    while cellwidthleft <= 0:
        cellwidthL = scribus.valueDialog(
            'Left Cell Width', 'How wide (mm) do you wish left cells to be?',
            '30.0')
        cellwidthleft = float(cellwidthL)
    while cellwidthright <= 0:
        cellwidthR = scribus.valueDialog(
            'Right Cell Width', 'How wide (mm) do you wish right cells to be?',
            '30.0')
        cellwidthright = float(cellwidthR)
    while cellHeight <= 0:
        cellheight = scribus.valueDialog(
            'Cell Height', 'How tall (mm) do you wish cells to be?', '10.0')
        cellHeight = float(cellheight)
    data = getCSVdata()
    di = getDataInformation(data)
    hposition = pos[1]
    vposition = pos[0]

    objectlist = [
    ]  # here we keep a record of all the created textboxes so we can group them later
    i = 0
    scribus.progressTotal(len(data))
    scribus.setRedraw(False)
    for row in data:
        c = 0
        for cell in row:
            cell = cell.strip()
            cellsize = cellwidthleft
            if c == 1: cellsize = cellwidthright
            textbox = scribus.createText(hposition, vposition, cellsize,
                                         cellHeight)  #create a textbox
            objectlist.append(textbox)
            scribus.insertText(cell, 0,
                               textbox)  #insert the text into the textbox
            hposition = hposition + cellwidthleft  #move the position for the next cell
            c = 1
        vposition = vposition + cellHeight  #set vertical position for next row
        hposition = pos[1]  #reset vertical position for next row
        i = i + 1
        scribus.progressSet(i)

    scribus.groupObjects(objectlist)
    scribus.progressReset()
    scribus.setUnit(userdim)  # reset unit to previous value
    scribus.docChanged(True)
    scribus.statusMessage("Done")
    scribus.setRedraw(True)
Example #37
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)
Example #38
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)
def importSocietes(filename, fileCat, iPro):
    arrLines=[]#liste de lignes du fichier csv, chaque ligne est une liste de champs 
    mapCol={}#table de correspondance entre les champs à importer et les numéros de colonne du fichier csv
    mapCat={}#table de correspondance entre numéro de catégorie et nom de catégorie
    nbCat=readSocietes(filename, fileCat, mapCat, arrLines, mapCol)
    (nbChg, nbPro)=(0,0)
    numPro=1
    while scribus.getTextLength("txtPros%d" % numPro)>0 and numPro<=NB_TXT:
        numPro+=1
    if iPro==1 and scribus.objectExists("txtBureauxChange"):
        scribus.deleteText("txtBureauxChange")

    scribus.progressTotal(len(arrLines))
    strPro="txtPros%d"%numPro
    scribus.statusMessage("Remplissage du cadre de texte %s..."%strPro)
    bFirstPro=True
    strCat="#"
    for record in arrLines:#Pour chaque pro
        # log("nbPro=%d\n"%nbPro)
        if strCat != record[mapCol["cat"]]:#nouvelle categorie
            strCat=record[mapCol["cat"]]
            bNewCat=True
        else:
            bNewCat=False

        nbPro+=1
        if nbPro<iPro:#déjà importé à l'exécution précédente
            continue
        try:
          scribus.progressSet(nbPro)
          if record[mapCol["chg"]]=="True" and scribus.objectExists("txtBureauxChange"):
            try:
                nbCarBureau=scribus.getTextLength("txtBureauxChange")
                appendText(u"● "+toUnicode(record[mapCol["nom"]])+"\n","styleChangeTitre","txtBureauxChange")
                appendText(toUnicode(record[mapCol["adr"]].replace("\\n"," - "))+"\n","styleChangeAdresse","txtBureauxChange")
                appendText(record[mapCol["post"]]+" "+toUnicode(record[mapCol["ville"]].upper()+"\n"),"styleChangeAdresse","txtBureauxChange")
                nbChg+=1
            except Exception as ex:
                scribus.messageBox( "Erreur","Une erreur est survenue sur ce bureau de change: \n%s\n\n%s" %(record, str(ex)))
                sys.exit()
          else :
            nbCarBureau=0

          nbCar=scribus.getTextLength(strPro)
          if bNewCat or bFirstPro:    
            if bFirstPro and not bNewCat:
                appendText(toUnicode(strCat+" (suite)")+"\n","styleProCatSuite",strPro)
            else:
                appendText(toUnicode(strCat)+"\n","styleProCat",strPro)

          bFirstPro=False
          appendText(u"● "+toUnicode(record[mapCol["nom"]])+"\n","styleProTitre",strPro)
          if record[mapCol["chg"]]=="True" :
            appendText(u"\n","styleProBureau",strPro) #icone du bureau de change en police FontAwesome
         
          appendText(processDesc(toUnicode(record[mapCol["desc"]]))+"\n","styleProDesc",strPro)
          if bLivret:
              strAdr=toUnicode(record[mapCol["adr"]].replace("\\n"," - "))+" - " + toUnicode(record[mapCol["post"]])+" "
              strAdr+=processDesc(toUnicode(record[mapCol["ville"]].upper()))
              if record[mapCol["tel"]].strip():
                  strAdr+=" ("+toUnicode(record[mapCol["tel"]].strip().replace(" ","\xC2\xA0"))+")\n" #numéro de téléphone insécable
              else:
                  strAdr+="\n"

              appendText(strAdr, "styleProAdresse", strPro)
          else:
            appendText(toUnicode(record[mapCol["adr"]].replace("\\n"," - "))+"\n","styleProAdresse",strPro)
            appendText(toUnicode(record[mapCol["post"]])+" "+processDesc(toUnicode(record[mapCol["ville"]]).upper())+"\n","styleProAdresse",strPro)
            if record[mapCol["tel"]].strip(): 
                appendText(processTelephone(record[mapCol["tel"]])+"\n","styleProAdresse",strPro)


          if scribus.textOverflows(strPro, nolinks=1): #effacement du paragraphe de pro tronqué et du bureau de change en double
            scribus.selectText(nbCar, scribus.getTextLength(strPro)-nbCar, strPro)
            scribus.deleteText(strPro)
            if nbCarBureau:
                scribus.selectText(nbCarBureau, scribus.getTextLength("txtBureauxChange")-nbCarBureau, "txtBureauxChange")
                scribus.deleteText("txtBureauxChange")

            #log("Cadre rempli : le cadre de texte %s est plein à la ligne %d\n" % (strPro, nbPro))
            break
        except Exception as exc:
                scribus.messageBox( "Erreur","Une erreur est survenue sur ce professionnel: \n%s\n\n%s" %(record, str(exc)))
                sys.exit()
    
        
    return (nbChg, nbPro, nbCat)
Example #40
0
def main(argv):

    unit = scribus.getUnit()
    units = [' pts','mm',' inches',' picas','cm',' ciceros']
    unitlabel = units[unit]
    if scribus.selectionCount() == 0:
        scribus.messageBox('Scribus - Script Error',
            "There is no object selected.\nPlease select a text frame and try again.",
            scribus.ICON_WARNING, scribus.BUTTON_OK)
        sys.exit(2)
    if scribus.selectionCount() > 1:
        scribus.messageBox('Scribus - Script Error',
            "You have more than one object selected.\nPlease select one text frame and try again.",
            scribus.ICON_WARNING, scribus.BUTTON_OK)
        sys.exit(2)

    textbox = scribus.getSelectedObject()
    pageitems = scribus.getPageItems()
    boxcount = 1
    for item in pageitems:
        if (item[0] == textbox):
            if (item[1] != 4):
                scribus.messageBox('Scribus - Script Error', 
                          "This is not a textframe. Try again.", scribus.ICON_WARNING, scribus.BUTTON_OK)
                sys.exit(2)

# While we're finding out what kind of frame is selected, we'll also make sure we
# will come up with a unique name for our infobox frame - it's possible we may want
# more than one for a multicolumn frame.
        if (item[0] == ("infobox" + str(boxcount) + textbox)):
                boxcount += 1

    elem = textbox;
    pathUp = '';
    pathUpShort = "";

    while elem != None:
        elemId = getElemId(elem);
        pElemId = getParentElemId(elem);

        text = scribus.getText(elem);
        if (text.find("Holder")!=-1):
            text = "";
        
        pathUpShort = "<" + getElemName(elem) + " id=\"" + str(getElemId(elem)) + "\">" + text + "\n" + pathUpShort;
        pathUp = dumpElem(elem) + " // " +  pathUp;
        elem = findElemById(pElemId);

    if (pathUp != ''):
        pathUp = pathUp[0:len(pathUp)-4];
    if (pathUpShort != ''):
        pathUpShort = pathUpShort[0:len(pathUpShort)-1];

    #framename = scribus.valueDialog('XML Tree','XML Tree', elemName + '[@id=' + elemId + '] parent: ' + parent + ' text:' + text + "," + parent)
    #scribus.messagebarText("It works !!!");
    scribus.statusMessage(pathUp);
    #scribus.zoomDocument(200);
    #scribus.selectFrameText(0,100);
    #framename = scribus.valueDialog('XML Tree','XML Tree (Path UP)', pathUp);

    #t = scribus.qApp.mainWidget();
    
    #if (not framename) :
    #    sys.exit(0)
    #scribus.messageBox('XML struct',
    #        pathUp + "\n\n" + pathUpShort,
    #        scribus.ICON_WARNING, scribus.BUTTON_OK)

    #impl = getDOMImplementation();
    #newdoc = impl.createDocument(None, "root", None);

    newdoc = createDOMDocument();
    #xmlelem = createDOMElement(newdoc, root);
    #newdoc.documentElement.appendChild(xmlelem);
    x = newdoc.toxml();
    #x = str(dir(root));

    scribus.structview(x);
Example #41
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)