Python canvas.drawString函数代码示例

def printColors(canvas):  
    canvas.setFont("Helvetica",10)
    y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2  
    rdx=(dx-w)/2; rdy=h/5.0
    available_paper = 10*inch

    for name, color in colors.getAllNamedColors().iteritems():

    # for [namedcolor, name] in (  
        # 'darkseagreen', 'darkslateblue',
        #  [colors.darkblue, 'darkblue'],
        #  [colors.darkcyan, 'darkcyan'],
        #  [colors.darkolivegreen, 'darkolivegreen'],
        #  [colors.cornflower, 'cornflower'],
        #  [colors.orchid, 'orchid'],
        
        #  [colors.lavenderblush, "lavenderblush"],  
        #  [colors.lawngreen, "lawngreen"],  
        #  [colors.lemonchiffon, "lemonchiffon"],  
        #  [colors.lightblue, "lightblue"],  
        #  [colors.lightcoral, "lightcoral"]):  
        canvas.setFillColor(color)  
        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
        canvas.setFillColor(colors.black)  
        canvas.drawString(x+dx/4 + 1*inch, y+rdy, name)  
        rdy += .2*inch
        available_paper -= (y+rdy)
        if available_paper < 1*inch:
            c.showPage()
            y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2  
            rdx=(dx-w)/2; rdy=h/5.0
            available_paper = 10*inch

 def docPage(canvas,doc):
     canvas.saveState()
     canvas.setFont('Times-Bold', 10)
     canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - (.25 * inch), Title)
     canvas.setFont('Times-Roman',9)
     canvas.drawString(7 * inch, .75 * inch, "Page %d" % (doc.page,))
     canvas.restoreState()

def _draw_subsection(canvas, yc, title_left, title_middle, title_right, text_tuples):
    if title_left or title_middle or title_right:
        canvas.setFont(SUBSECTION_TITLE_FONT, SUBSECTION_FONT_SIZE)
        title_y = yc - SUBSECTION_FONT_SIZE
        if title_left:
            title_x = H_TEXT_MARGIN
            canvas.drawString(title_x, title_y, title_left)
        if title_middle:
            title_x = RESUME_PAGE_SIZE[0] / 2
            canvas.drawCentredString(title_x, title_y, title_middle)
        if title_right:
            title_x = RESUME_PAGE_SIZE[0] - H_TEXT_MARGIN
            canvas.drawRightString(title_x, title_y, title_right)        
        yc = title_y - V_SEPARATOR
        
    canvas.setFont(SUBSECTION_FONT, SUBSECTION_FONT_SIZE)
    for (draw_bullet, text) in text_tuples:
        if draw_bullet:
            text = u"•  " + unicode(text)
            
        lines = _break_text(text, RESUME_PAGE_SIZE[0] - (2*H_TEXT_MARGIN + SUBSECTION_H_INDENT), SUBSECTION_FONT, SUBSECTION_FONT_SIZE)
        
        line_x = H_TEXT_MARGIN + SUBSECTION_H_INDENT                
        for line in lines:
            line_y = yc - SUBSECTION_FONT_SIZE        
            canvas.drawString(line_x, line_y, line)
            yc = line_y - V_SEPARATOR
    
    return yc - SUBSECTION_V_SPACER

 def myFirstPage(self, canvas, doc):
     canvas.saveState()
     canvas.setFont('Times-Roman',9)
     canvas.drawString(inch, 0.75 * inch, "Page 1 / %s" % pageinfo)
     self.headerTable.wrapOn(canvas, 540, height)
     self.headerTable.drawOn(canvas, *coord(1.0, 1.5, cm))
     canvas.restoreState()

    def myPage(canvas, doc):
        canvas.saveState()  # save the current state
        canvas.setFont('InconsolataBold', 16)  # set the font for the name
        canvas.drawString(
            .4 * inch,
            HEIGHT - (.4 * inch),
            contact['name'])  # draw the name on top left page 1
        canvas.setFont('Inconsolata', 8)  # sets the font for contact
        canvas.drawRightString(
            WIDTH - (.4 * inch),
            HEIGHT - (.4 * inch),
            contact['website'])  
        canvas.line(.4 * inch, HEIGHT - (.47 * inch), 
            WIDTH - (.4 * inch), HEIGHT - (.47 * inch))
        canvas.drawString(
            .4 * inch,
            HEIGHT - (.6 * inch),
            contact['phone'])
        canvas.drawCentredString(
			WIDTH / 2.0,
			HEIGHT - (.6 * inch),
			contact['address'])
        canvas.drawRightString(
			WIDTH - (.4 * inch),
			HEIGHT - (.6 * inch),
			contact['email'])
        # restore the state to what it was when saved
        canvas.restoreState()

def el_encogedor_de_fuentes_de_doraemon(canvas, fuente, tamannoini, xini, xfin, y, texto, alineacion = -1):
    """
    Comenzando por el tamaño inicial "tamannoini", encoge el texto 
    hasta que quepa en los límites fijados y después lo escribe.
    Convierte el texto por si está en una codificación no soportada.
    Al finalizar, devuelve las propiedades de texto del canvas a 
    su estado original y la fuente a su tamaño inicial.
    NO AVANZA LÍNEA.
    Si alineacion == -1: Alineación a la izquierda. Si 0, centrado y si 1, a la derecha.
    """
    # PLAN: No estaría mal pasar un tamaño mínimo de fuente, y si se alcanza o se supera, cortar la línea con 
    # agregarFila y el último tamaño de fuente válido. Claro que entonces habría que devolver también las líneas 
    # avanzadas, etc...
    canvas.saveState()
    size = tamannoini
    texto = escribe(texto)
    while canvas.stringWidth(texto, fuente, size) > (xfin - xini) and size > 4:
        size -= 1
    canvas.setFont(fuente, size)
    if alineacion == -1:
        canvas.drawString(xini, y, texto)
    elif alineacion == 1:
        canvas.drawRightString(xfin, y, texto)
    elif alineacion == 0:
        canvas.drawCentredString((xfin + xini) / 2.0, y, texto)
    else:
        print "geninformes.py::el_encogedor_de_fuentes_de_doraemon -> Error alineación. Uso alineación a la izquierda por defecto."
        canvas.drawString(xini, y, texto)
    canvas.restoreState()

def contig_ticker(canvas, feature, cLen, Y0, offset, offset_mode):
    """Draw contig separators."""
    # get contig name
    name = feature.qualifiers.get('id')[0]
    # take start and end points
    location = feature.location
    Zs = location.nofuzzy_start
    Ze = location.nofuzzy_end
    # calculate offset coordinates
    if offset_mode == 'loop':
        offZs = offset_coord(Zs, cLen, offset)
        offZe = offset_coord(Ze, cLen, offset)
    elif offset_mode == 'nudge':
        offZs = nudge_coord(Zs, offset)
        offZe = nudge_coord(Ze, offset)
    else:
        offZs = Zs
        offZe = Ze
    xs, xe = offZs*u, offZe*u
    # set Y axis coordinates
    y0 = Y0-dop*3.5
    # draw
    canvas.setLineWidth(2)
    ttl = canvas.beginPath()
    ttl.moveTo(xs,y0)
    ttl.lineTo(xs,y0-h*4)
    ttl.lineTo(xs+dop,y0-h*4)
    canvas.drawPath(ttl, stroke=1, fill=0)
    canvas.setFont(bFont, NfSize)
    canvas.drawString(xs+dop*2, y0-h*4.5, name)
    canvas.setFont(rFont, SfSize)
    canvas.drawString(xs+dop*2,y0-h*8,"".join(["[",str(Zs),"-",str(Ze),"]"]))
    canvas.setFont(rFont, NfSize)
    ttl.close()

        def _build_header_canvas(canvas, doc):
            """
            Draw the document header.

            Local function to be passed later to output_doc.build().
            Reportlab automatically passes args when called.
            """
            # The header function to be passed later to output_doc.build()
            # Set up positions
            header_y_position = (11 * units.inch) - 45
            page_number = doc.page
            if page_number % 2 == 0:
                # Left-hand page
                page_number_x_position = 60
            else:
                # Right-hand page
                page_number_x_position = (8.5 * units.inch) - 60
            canvas.saveState()
            canvas.setFont(self.paragraph_style.fontName,
                           self.paragraph_style.fontSize)
            if self.title:
                canvas.drawCentredString((8.5 * units.inch) / 2,
                                         header_y_position,
                                         self.title)
            canvas.drawString(page_number_x_position, header_y_position,
                              str(page_number))
            canvas.restoreState()

 def draw_cable(self, canvas):
     txt = {'de': 'Kabellänge: {0}', 'en': 'Cablelength: {0}'}
     txt = txt[self.lang].format(self.cable)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

def create_first_page(canvas, doc):
    canvas.saveState()
    canvas.setFont('Helvetica', 16)
    canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT-58, TITLE)
    canvas.setFont('Helvetica', 10)
    canvas.drawString(BORDER_HORIZONTAL, BORDER_VERTICAL, TITLE)
    canvas.drawRightString(PAGE_WIDTH-BORDER_HORIZONTAL , BORDER_VERTICAL, "Seite 1")
    canvas.restoreState()

 def draw_amount(self, canvas):
     txt = {'de': 'Stückzahl: {0}', 'en': 'Amount: {0}'}
     txt = txt[self.lang].format(self.amount)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_connector(self, canvas):
     txt = {'de': 'Anschluss: {0}', 'en': 'Connector: {0}'}
     txt = txt[self.lang].format(self.connector)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

    def draw_intro_text(self, canvas):
        txt = {
            'de': 'Durch die gewählten Messpunkte ergab sich folgende \
Konfiguration:',
            'en': 'Given measuring points lead to the following \
configuration:'}
        canvas.drawString(self.center, self.y, txt[self.lang])
        self.y -= 2*self.y_decrease

 def draw_tubeoffset(self, canvas):
     txt = {'de': 'Rohrüberstand: {0}cm', 'en': 'Clearance: {0}cm'}
     txt = txt[self.lang].format(self.offset)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease

 def draw_tubelength(self, canvas):
     txt = {'de': 'Rohrlänge: {0}cm', 'en': 'Tubelength: {0}cm'}
     txt = txt[self.lang].format(self.tube)
     canvas.drawString(self.center, self.y, txt)
     canvas.rect(
         self._rect_x(self.center), self._rect_y(self.y), self.rect_width,
         self.rect_height)
     self.y -= self.y_decrease