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

def addText(canvas,element,styles):
	for run in element.getElementsByTagName("sn:r"):
		if(len(run.getElementsByTagName("sn:t")) > 0):
			##TODO: support italic, bold and underlined text
			charStyle = styles["Character" + run.getAttributeNode("sn:rStyle").value]
			text=run.getElementsByTagName("sn:t")[0].firstChild.nodeValue
			canvas.setFont("Helvetica",charStyle.size)
			canvas.setFillColor(charStyle.color)
			canvas.drawString(40,810-charStyle.size,text)

def _draw_section_title(canvas, yc, title):
    title = title.upper()
    title_x = H_TEXT_MARGIN
    title_y = yc - SECTION_V_SPACE - SECTION_FONT_SIZE
    line_y = title_y - V_SEPARATOR
    canvas.setFont(SECTION_FONT, SECTION_FONT_SIZE)
    canvas.drawString(title_x, title_y, title)
    canvas.line(H_TEXT_MARGIN - H_LINE_MARGIN_OFFSET, line_y, RESUME_PAGE_SIZE[0] - (H_TEXT_MARGIN - H_LINE_MARGIN_OFFSET), line_y)
    return line_y# - V_SEPARATOR

def framePage(canvas, title, pos):
    canvas.setFont('Times-Roman', 15)
    canvas.drawString(inch, pos * inch, title)
    canvas.setFont('Times-Roman', 10)
    canvas.drawCentredString(4.135 * inch, 0.75 * inch,
                            'Página %d' % canvas.getPageNumber())
    #reset carefully afterwards
    canvas.setLineWidth(1)
    canvas.setStrokeColorRGB(0, 0, 0)

def genBarcode(code, value, canvas, scale):
    dr = createBarcodeDrawing(code, value=value, humanReadable=True)
    dr.renderScale = scale
    bounds = dr.getBounds()
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    dr.drawOn(canvas, (297*mm)/2-width*scale/2, (210*mm)/2-height*scale/2)
    canvas.drawString(1*mm, 1*mm, "generated at "+str(datetime.now()) + " from "+request.url)
    canvas.showPage()

def base_draw(canvas, cName, cLen, feats, key, dop_Y, Y0, X_shift,
             map_mode, annot_cnt, offset, offset_mode, seq_len,
             annot_mode, fct_flags, fct_colors) :
    """Draw contig baseline and features."""
    # draw plasmid baseline
    baseliner(cLen, canvas, Y0, offset, offset_mode)
    # label the baseline with plasmid name and size
    labeller(cName, cLen, canvas, Y0)
    # label the annotations list
    Y_annot = 0
    if map_mode != 'n':
        canvas.setFont(bFont, LfSize)
        canvas.drawString(X_shift, y_adj, cName)
    canvas.setFont(rFont, SfSize)
    Y_annot +=2
    # filter and draw annotation features
    ORFcnt = 0
    shift_flag = False
    for feature in feats :
        if feature.type == 'contig':
            contig_ticker(canvas, feature, cLen, Y0, offset, offset_mode)
        elif feature.type == 'ref_seg':
            ref_ticker(canvas, feature, cLen, Y0, offset, offset_mode)
        elif feature.type == 'CDS' or feature.type == 'cds':
            ORFcnt += 1
            # determine functional category color
            try:
                annot = feature.qualifiers.get(key)[0]
            except TypeError:
                annot = 'none'
            fct_key = annot_color(fct_flags, annot)
            color_hex = HexColor(fct_colors[fct_key][0])
            # calculate coordinates for canvas
            featL, midLZ, coords, split_flag = orf_coords(feature, Y0, cLen,
                                                         offset, offset_mode)
            # check for CDS sitting across the origin
            if split_flag:
                # split coords
                coords1, featL1, coords2, featL2 = orf_split(coords, cLen)
                # draw square feature
                orf_eus(canvas, featL1, coords1, color_hex, shape='square')
                # draw arrow feature
                orf_eus(canvas, featL2, coords2, color_hex, shape=None)
            else:
                # draw arrow feature
                orf_eus(canvas, featL, coords, color_hex, shape=None)
            # write annotation line and CDS number
            if map_mode != 'n':
                if map_mode == 'single' and Y_annot-1 > annot_cnt/2:
                    X_shift = seq_len/2
                    if not shift_flag:
                        Y_annot -= annot_cnt/2
                        shift_flag = True
                Y_annot = orf_annot(canvas, cLen, annot, Y_annot, ORFcnt,
                                   Y0+dop_Y, midLZ, X_shift, split_flag,
                                   annot_mode)