def hello(c, link):
	c.translate(ORIGIN_X, ORIGIN_Y)

	# Draw paragraph
	stylesheet = getSampleStyleSheet()
	style = stylesheet['BodyText']
	style.fontName = 'LeagueGothic'
	style.fontSize = 42
	style.leading = 44

	p = Paragraph('<b>print</b><br/>your<br/><b>badge</b><br/>here', style)
	qr_left = 30*mm
	p_w, p_h = p.wrap(qr_left, HEIGHT)
	p.drawOn(c, 0, 0)


	# Add QR Code
	qr_code = qr.QrCodeWidget(link)
	qr_bounds = qr_code.getBounds()
	qr_width = qr_bounds[2] - qr_bounds[0]
	qr_height = qr_bounds[3] - qr_bounds[1]
	d = Drawing(HEIGHT, HEIGHT, transform=[HEIGHT/qr_width,0,0,HEIGHT/qr_height,0,0])
	d.add(qr_code)
	renderPDF.draw(d, c, qr_left, 0)

	# Draw thin line between text and QR code
	c.line(qr_left, 0, qr_left, HEIGHT)
	c.line(qr_left + HEIGHT, 0, qr_left+HEIGHT, HEIGHT)

	img_left = qr_left + HEIGHT

	# Draw images
	c.drawImage('images/ipv6.jpg', img_left, 0, 20*mm, 1/3 * HEIGHT, mask=None, preserveAspectRatio=True, anchor='c')
	c.drawImage('images/ffrhein_logo_claim_line_rot.png', img_left, 1/3*HEIGHT, 20*mm, 2/3 * HEIGHT, mask=None, preserveAspectRatio=True, anchor='c')

def draw_code128_questionnaire_id(canvas, survey, id):
    # Only supports ascii for now (see also defs.py)
    barcode_value = unicode(id).encode('ascii')
    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = defs.corner_mark_left

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x + defs.code128_hpad

    # The barcode should be flush left.
    barcode_x = barcode_x

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + \
             defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

def createBarCodes(path, barcode_value):
    from reportlab.graphics.barcode import eanbc
    from reportlab.graphics.shapes import Drawing
    from reportlab.pdfgen import canvas
    from reportlab.graphics import renderPDF
    from reportlab.lib.units import cm, mm
    from reportlab.lib.styles import getSampleStyleSheet
    from reportlab.platypus.para import Paragraph

    # draw the eanbc13 code
    barcode_eanbc13 = eanbc.Ean13BarcodeWidget(barcode_value)
    bounds = barcode_eanbc13.getBounds()
    barcode_eanbc13.barHeight = 19*mm
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    d = Drawing()
    d.add(barcode_eanbc13)

    c = canvas.Canvas(path, pagesize=(43*mm, 25*mm))

    # print width, height
    text = "%s.%s" % (150, '00')
    p = Paragraph(text, getSampleStyleSheet()["Normal"])
    p.wrapOn(c, 43*mm, 5*mm)
    p.drawOn(c, 16*mm, 20*mm)
    renderPDF.draw(d, c, 3*mm, 1*mm)
    c.save()

    def create_header(self):
        headerCanvas = Drawing()
        headerRect = Rect(0, 0, width=self.width, height=50)
        headerRect.fillColor = HexColor("#607D8B")
        headerRect.strokeColor = HexColor("#607D8B")
        headerCanvas.add(headerRect)
        renderPDF.draw(headerCanvas, self.c, 0, self.height - 50)

        _header_styles = ParagraphStyle(
            "Header",
            parent=self.styles["Heading1"],
            textColor=white,
            fontName='Helvetica'
        )
        p = Paragraph("Kit Trading Fund Report", style = _header_styles)

        p.wrapOn(self.c, self.width, self.height - 50)
        p.drawOn(self.c, *self.coord(75, 10, mm))

        _sub_header_styles = ParagraphStyle(
            "SubHeader",
            parent=self.styles["Heading4"],
            textColor=white,
            fontName='Helvetica'
        )
        p = Paragraph("Monthly Report: January 2016", style = _sub_header_styles)
        p.wrapOn(self.c, self.width, self.height - 50)
        p.drawOn(self.c, *self.coord(85, 16, mm))

    def draw_qrcode(self, value, x, y, size=40, halign=None, valign=None):
        """
            Helper function to draw a QR code

            @param value: the string to encode
            @param x: drawing position
            @param y: drawing position
            @param size: the size (edge length) of the QR code
            @param halign: horizontal alignment ("left"|"center"|"right"), default left
            @param valign: vertical alignment ("top"|"middle"|"bottom"), default bottom
        """

        qr_code = qr.QrCodeWidget(value)

        bounds = qr_code.getBounds()
        w = bounds[2] - bounds[0]
        h = bounds[3] - bounds[1]

        transform = [float(size) / w, 0, 0, float(size) / h, 0, 0]
        d = Drawing(size, size, transform=transform)
        d.add(qr_code)

        hshift = vshift = 0
        if halign == "right":
            hshift = size
        elif halign == "center":
            hshift = float(size) / 2.0

        if valign == "top":
            vshift = size
        elif valign == "middle":
            vshift = float(size) / 2.0

        renderPDF.draw(d, self.canv, x - hshift, y - vshift)

def draw_qr_global_id(canvas, survey):
    if survey.global_id is None:
        raise AssertionError

    # Only allow ascii
    value = survey.global_id.encode('ascii')

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = (survey.defs.paper_width - defs.corner_mark_right + defs.corner_mark_left) / 2

    qr_code = qr.QrCodeWidget(value, barLevel='H')
    bounds = qr_code.getBounds()

    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]

    # Squeeze into the space between corner mark and content
    size = defs.bottom_page_margin - defs.corner_mark_bottom

    code_y = y
    code_x = x - size / 2.0

    d = Drawing(size*mm, size*mm, transform=[float(size*mm)/width,0,0,-float(size*mm)/height,0,0])
    d.add(qr_code)

    renderPDF.draw(d, canvas, code_x*mm, code_y*mm)

def draw_code128_global_id(canvas, survey):
    if survey.global_id is None:
        raise AssertionError

    # Only allow ascii
    barcode_value = survey.global_id.encode('ascii')

    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = (survey.defs.paper_width - defs.corner_mark_right + defs.corner_mark_left) / 2

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x

    # Center
    barcode_x = barcode_x - barcode.width / mm / 2.0

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

 def draw_to_canvas(O, canvas):
   if (reportlab is None): return
   from reportlab.graphics.shapes import Drawing
   from reportlab.graphics import renderPDF
   drawing = Drawing(*O.page_size)
   drawing.add(O.top_group)
   renderPDF.draw(drawing=drawing, canvas=canvas, x=0, y=0)

def render_diploma(request, response, diploma):
    design = diploma.design

    c = canvas.Canvas(response)

    marginLeft = 2 * cm
    marginTop = 2 * cm
    marginBottom = 2.5 * cm
    cTop = 29.7 * cm - marginTop
    cLeft = marginLeft
    cMiddle = 21 * cm / 2
    logoHeight = 1.4 * cm
    pictureHeight = 2.5 * cm

    text_value_map = {
        '$grade': str(diploma.grade),
    }

    if design.logo:
        c.drawImage(design.logo.path, cLeft, cTop - logoHeight, height=logoHeight, preserveAspectRatio=True, anchor="nw")

    c.setFont("Helvetica-Bold", 30)
    c.setFillColorRGB(0, 0.25, 0.5)
    c.drawCentredString(10.5 * cm, cTop - 5 * cm, diploma.name)

    c.setFont("Helvetica", 14)
    c.setFillColorRGB(0, 0, 0)
    for i,line in enumerate(text_lines(design.title, text_value_map)):
        c.drawCentredString(cMiddle, cTop - 7 * cm - (i * 0.8 * cm), line)

    c.setFont("Helvetica", 10)
    c.setFillColorRGB(0, 0, 0)
    for i,line in enumerate(text_lines(design.body, text_value_map)):
        c.drawString(cLeft, cTop - 10 * cm - (i * 0.6 * cm), line)

    c.setFont("Helvetica", 12)
    c.setFillColorRGB(0, 0, 0)
    c.drawString(cLeft, cTop - 21 * cm, design.date)

    c.drawString(cLeft, cTop - 23.5 * cm, design.signature_name)
    c.drawString(cLeft, cTop - 24 * cm, design.signature_title)

    c.setFont("Helvetica", 7)
    c.setFillColorRGB(0, 0, 0)
    for i,line in enumerate(text_lines(design.small_print, text_value_map)):
        c.drawString(cLeft, marginBottom - (i * 0.3 * cm), line)

    qr_code = qr.QrCodeWidget(request.build_absolute_uri(diploma.get_absolute_url()))
    bounds = qr_code.getBounds()
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    d = Drawing(1200, 1200, transform=[60./width,0,0,60./height,0,0])
    d.add(qr_code)
    renderPDF.draw(d, c, 16.7 * cm, cTop - 24.3 * cm)

    c.showPage()
    #c.setAuthor("A+")
    c.setTitle("Course Diploma")
    #c.setSubject("")
    c.save()

def draw_code128_sdaps_info(canvas, survey, page):
    # The page number is one based here already
    # The survey_id is a 32bit number, which means we need
    # 10 decimal digits to encode it, then we need to encode the
    # the page with at least 3 digits(just in case someone is insane enough
    # to have a questionnaire with more than 99 pages.
    # So use 10+4 digits

    barcode_value = "%010d%04d" % (survey.survey_id, page)
    barcode = createBarcodeDrawing("Code128",
                                   value=barcode_value,
                                   barWidth=defs.code128_barwidth / 25.4 * 72.0,
                                   height=defs.code128_height / 25.4 * 72.0,
                                   quiet=False)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = survey.defs.paper_width - defs.corner_mark_right

    barcode_y = y - defs.code128_vpad - defs.code128_height
    barcode_x = x - defs.code128_hpad

    # The barcode should be flush left.
    barcode_x = barcode_x - barcode.width / mm

    renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)

    # Label
    text_x = barcode_x + barcode.width / mm / 2.0
    text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0

    canvas.saveState()
    canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
    canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
    canvas.restoreState()

def make_pdf(data):
    page_width, page_height = A4
    page_margin = 10.0
    qr_width, qr_height = 60.0, 60.0

    qr_margin = 5.0     # this is a desired margin, not the actual one
    num_rows = int(math.floor((page_height - 2 * page_margin) / (qr_height + qr_margin)))
    num_cols = int(math.floor((page_width - 2 * page_margin) / (qr_width + qr_margin)))

    qr_vertical_margin = ((page_height - 2 * page_margin) - num_rows * qr_height) / num_rows
    qr_horizontal_margin = ((page_width - 2 * page_margin) - num_cols * qr_width) / num_cols

    qr = QrCodeWidget(data)
    output = cStringIO.StringIO()
    p = canvas.Canvas(output, pagesize=A4)
    b = qr.getBounds()
    w, h = b[2]-b[0], b[3]-b[1]

    d = Drawing(qr_width, qr_height,
                transform=[qr_width / w, 0, 0, qr_height / h, 0, 0])
    d.add(qr)

    for i in xrange(num_cols):
        x = page_margin + i * (qr_horizontal_margin + qr_width)

        for j in xrange(num_rows):
            y = page_margin + j * (qr_vertical_margin + qr_height)
            renderPDF.draw(d, p, x, y)

    p.showPage()
    p.save()

    pdf_output = output.getvalue()
    output.close()
    return pdf_output

def respond_with_permit_pdf(permit):
    """
    :param permit: The permit for which to generate the PDF
    :return: An HTTP response
    """
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(content_type="application/pdf")
    response["Content-Disposition"] = 'attachment; filename="permit_%05d.pdf"' % permit.pk

    # Produce PDF using ReportLab:
    p = canvas.Canvas(response)
    pageW = defaultPageSize[0]
    pageH = defaultPageSize[1]
    refX = pageW / 2
    refY = pageH - 6.25 * inch

    # The tag that gets placed near the location.
    p.rect(refX - 2.0 * inch, refY - 0 * inch, 4 * inch, 5 * inch)

    refY += 4.5 * inch

    # Static header:
    p.setFont("Helvetica", 14)
    p.drawCentredString(refX, refY - 0.00 * inch, "XEROCRAFT HACKERSPACE")
    p.setFont("Helvetica-Bold", 28)
    p.drawCentredString(refX, refY - 0.40 * inch, "PARKING PERMIT")
    p.setFont("Helvetica", 14)
    p.drawCentredString(refX, refY - 0.66 * inch, "MEMBER-CLAIMED PROPERTY")

    # Changing refY allows the follwoing to be moved up/down as a group, w.r.t. the text above.
    refY -= 3.0 * inch

    # QR Code:
    qr = QrCodeWidget('{"permit":%d}' % permit.id)
    qrSide = 2.5 * inch  # REVIEW: This isn't actually 2.3 inches.  What is it?
    bounds = qr.getBounds()
    qrW = bounds[2] - bounds[0]
    qrH = bounds[3] - bounds[1]
    drawing = Drawing(1000, 1000, transform=[qrSide / qrW, 0, 0, qrSide / qrH, 0, 0])
    drawing.add(qr)
    renderPDF.draw(drawing, p, refX - qrSide / 2, refY)

    p.setFont("Helvetica", 10)
    p.drawCentredString(refX, refY - 0.00 * inch, permit.short_desc)
    u = permit.owner.auth_user
    p.drawCentredString(refX, refY - 0.20 * inch, "Parked by: %s %s" % (u.first_name, u.last_name))
    p.drawCentredString(refX, refY - 0.40 * inch, "Permit #%05d" % permit.id)

    p.setFont("Helvetica", 14)
    if permit.ok_to_move:
        p.drawCentredString(refX, refY - 0.80 * inch, "It is OK to carefully move this item")
        p.drawCentredString(refX, refY - 1.00 * inch, "to another location, if required.")

    else:
        p.drawCentredString(refX, refY - 0.80 * inch, "This item is fragile. Please attempt")
        p.drawCentredString(refX, refY - 1.00 * inch, "to contact me before moving it.")

    p.showPage()
    p.save()
    return response

    def draw_to_file(self, output_file, title):
        """Write the comparative plot to a file.

        Arguments:

        o output_file - The name of the file to output the information to,
                        or a handle to write to.

        o title - A title to display on the graphic.
        """
        width, height = self.page_size
        cur_drawing = Drawing(width, height)

        self._draw_title(cur_drawing, title, width, height)

        start_x = inch * .5
        end_x = width - inch * .5
        end_y = height - 1.5 * inch
        start_y = .5 * inch
        self._draw_scatter_plot(cur_drawing, start_x, start_y, end_x, end_y)

        if self.output_format == 'pdf':
            out_canvas = canvas.Canvas(output_file, pagesize = self.page_size)
            renderPDF.draw(cur_drawing, out_canvas, 0, 0)
            out_canvas.showPage()
            out_canvas.save()
        elif self.output_format == 'eps':
            renderPS.drawToFile(cur_drawing, output_file)
        else:
            raise ValueError("Invalid output format %s" % self.output_format)

def draw_bar_chart(pdf_text, page_height):
    '''Currently generates a dummy graph.
    Next, need to pass in data that shall
    be the reactors temp throughout the
    sequence.
    '''
    pdf_text.showPage()
    drawing = Drawing(400, 200)
    data = [
            (13, 5, 20, 22, 37, 45, 19, 4),
            (14, 6, 21, 23, 38, 46, 20, 5)
            ]
    bc = VerticalBarChart()
    bc.x = 50
    bc.y = 50
    bc.height = 125
    bc.width = 300
    bc.data = data
    bc.strokeColor = colors.black
    bc.valueAxis.valueMin = 0
    bc.valueAxis.valueMax = 50
    bc.valueAxis.valueStep = 10
    bc.categoryAxis.labels.boxAnchor = 'ne'
    bc.categoryAxis.labels.dx = 8
    bc.categoryAxis.labels.dy = -2
    bc.categoryAxis.labels.angle = 30
    bc.categoryAxis.categoryNames = ['Jan-99','Feb-99','Mar-99','Apr-99','May-99','Jun-99','Jul-99','Aug-99']
    drawing.add(bc)
    renderPDF.draw(drawing, pdf_text, inch, inch)
    
    return page_height

def draw_qr_sdaps_info(canvas, survey, page):
    # The page number is one based here already
    # The survey_id is a 32bit number, which means we need
    # 10 decimal digits to encode it, then we need to encode the
    # the page with at least 3 digits(just in case someone is insane enough
    # to have a questionnaire with more than 99 pages.
    # So use 10+4 digits

    value = "%010d%04d" % (survey.survey_id, page)

    y = survey.defs.paper_height - defs.corner_mark_bottom
    x = survey.defs.paper_width - defs.corner_mark_right

    qr_code = qr.QrCodeWidget(value, barLevel='H')
    bounds = qr_code.getBounds()

    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]

    # Squeeze into the space between corner mark and content
    size = defs.bottom_page_margin - defs.corner_mark_bottom

    code_y = y
    code_x = x - size

    d = Drawing(size*mm, size*mm, transform=[float(size*mm)/width,0,0,-float(size*mm)/height,0,0])
    d.add(qr_code)

    renderPDF.draw(d, canvas, code_x*mm, code_y*mm)

def print_barcode_page(request, page_id):
    bcp = get_object_or_404(BarcodePage, id=page_id)
    
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'attachment; filename="%s.pdf"' % slugify(bcp.titre)

    # Create the PDF object, using the response object as its "file."
    p = canvas.Canvas(response)
    width, height = A4
    p.drawCentredString(width/2, height-50, bcp.titre)
    produits = bcp.produits.all()
    for idx, prod in enumerate(produits):
        row = idx%7
        col = idx//7
        h = 110
        w = 180
        v_offset = height-80
        h_offset = 60
        img_offset = 80
        text_offset = 10
        
        d = createBarcodeDrawing("EAN13",value=str(prod.ean))
        p.drawString(h_offset+text_offset+col*w, v_offset-row*h, prod.nom)
        renderPDF.draw(d, p, h_offset+col*w, v_offset-img_offset-row*h)

    # Close the PDF object cleanly, and we're done.
    p.showPage()
    p.save()
    return response

    def __add_graph(self):
        drawing = Drawing(200, 100)
        data = list()
        labels = list()

        self.c.drawString(370, 730, 
            'Distribucion en pesos'.encode('utf-8'))

        for acc in self.accounts:
            balance = acc.balance
            if acc.currency == 'USD':
                balance = balance * self.dolar

            data.append(balance)
            labels.append(acc.name)

        pie = Pie()
        pie.x = 280
        pie.y = 630
        pie.height = 100
        pie.width = 100
        pie.data = data
        pie.labels = labels
        pie.simpleLabels = 1
        pie.slices.strokeWidth = 1
        pie.slices.strokeColor = black
        pie.slices.label_visible = 0

        legend = Legend()
        legend.x = 400
        legend.y = 680
        legend.dx              = 8
        legend.dy              = 8
        legend.fontName        = 'Helvetica'
        legend.fontSize        = 7
        legend.boxAnchor       = 'w'
        legend.columnMaximum   = 10
        legend.strokeWidth     = 1
        legend.strokeColor     = black
        legend.deltax          = 75
        legend.deltay          = 10
        legend.autoXPadding    = 5
        legend.yGap            = 0
        legend.dxTextSpace     = 5
        legend.alignment       = 'right'
        legend.dividerLines    = 1|2|4
        legend.dividerOffsY    = 4.5
        legend.subCols.rpad    = 30
        n = len(pie.data)
        self.__setItems(n,pie.slices,
            'fillColor',self.pdf_chart_colors)

        legend.colorNamePairs = [(pie.slices[i].fillColor, 
            (pie.labels[i][0:20],'$%0.2f' % pie.data[i])) for i in xrange(n)]


        drawing.add(pie)
        drawing.add(legend)
        x, y = 0, 0
        renderPDF.draw(drawing, self.c, x, y, showBoundary=False)

        def _DrawTop(self, x1, y1, x2, text):
            from reportlab.graphics import renderPDF
            R,G,B = VeriwaveGreen
            self.canvas.setFillColorRGB(R,G,B)
            self.canvas.roundRect(x1, y1 - 4*self._UnitHieght, x2, 4*self._UnitHieght, self._UnitHieght, stroke=0, fill=1)
            self.canvas.setFillColorRGB(0,0,0)

            _MaxStrLen = x2 - 4.0*self._UnitHieght
            textString = text
            if self._stringWidth(str(textString), "Helvetica",9) > _MaxStrLen:
                while self._stringWidth(str(textString) + "...", "Helvetica",9) > _MaxStrLen:
                    textString = textString[:-1]
                textString = textString + "..."
            self.canvas.setFont("Helvetica",9)
            self.canvas.drawString(x1 + self._UnitHieght , y1 - 2*self._UnitHieght, textString)
    
            # Add Port Icon
            if self.CardMap.has_key(text):
                (textStr, icon) = self.CardMap[text]
                self.canvas.setFont("Helvetica", 5)
                self.canvas.drawCentredString(x1 + x2 - 1.4*self._UnitHieght, y1 - 2.65*self._UnitHieght, textStr)
                d = Drawing(self._UnitHieght, self._UnitHieght)
                d.add(icon)
                renderPDF.draw(d, self.canvas, x1 + x2 - 2.2*self._UnitHieght, y1 - 1.9*self._UnitHieght, showBoundary=False)
        
            return self._UnitHieght*3

def create_diagram(cnarr, segarr, threshold, min_probes, outfname, title=None):
    """Create the diagram."""
    if cnarr and segarr:
        do_both = True  # Draw segments on left, probes on right.
        cnarr_is_seg = False  # Are probes actually the segmented values?
    else:
        if cnarr:
            cnarr_is_seg = False
        elif segarr:
            cnarr = segarr
            cnarr_is_seg = True
        else:
            raise ValueError("Must provide argument cnarr or segarr, or both. ")
        do_both = False
    gene_labels = _get_gene_labels(cnarr, segarr, cnarr_is_seg, threshold,
                                   min_probes)

    # NB: If multiple segments cover the same gene (gene contains breakpoints),
    # all those segments are marked as "hits".  We'll uniquify them.
    # TODO - use different logic to only label the gene's signficant segment(s)
    seen_genes = set()

    # Consolidate genes & coverage values as chromosome features
    features = collections.defaultdict(list)
    strand = 1 if do_both else None  # Draw on the chr. right half or full width
    chrom_sizes = plots.chromosome_sizes(cnarr)
    if not cnarr_is_seg:
        cnarr = cnarr.squash_genes()
    for row in cnarr:
        if row.start - 1 >= 0 and row.end <= chrom_sizes[row.chromosome]:  # Sanity check
            if row.gene in gene_labels and row.gene not in seen_genes:
                seen_genes.add(row.gene)
                feat_name = row.gene
                if "," in feat_name:
                    # TODO - line-wrap multi-gene labels (reportlab won't do \n)
                    feat_name = feat_name.replace(",", ", ")
            else:
                feat_name = None
            features[row.chromosome].append(
                (row.start - 1, row.end, strand, feat_name,
                 colors.Color(*plots.cvg2rgb(row.log2, not cnarr_is_seg))))
    if do_both:
        # Draw segments in the left half of each chromosome (strand -1)
        for chrom, segrows in segarr.by_chromosome():
            for srow in segrows:
                if srow.start - 1 >= 0 and srow.end <= chrom_sizes[chrom]:  # Sanity check
                    features[chrom].append(
                        (srow.start - 1, srow.end, -1, None,
                         colors.Color(*plots.cvg2rgb(srow.log2, False))))

    # Generate the diagram PDF
    if not outfname:
        outfname = cnarr.sample_id + '-diagram.pdf'
    drawing = build_chrom_diagram(features, chrom_sizes, cnarr.sample_id, title)
    cvs = canvas.Canvas(outfname, pagesize=PAGE_SIZE)
    renderPDF.draw(drawing, cvs, 0, 0)
    cvs.showPage()
    cvs.save()
    return outfname

 def drawOn(self, canvas, x, y, _sW=0):
     #There is basic support for drawing Barchart, Linechart for
     #the same dataset. This could be extended for more chart types
     #There is also basic support for including Legends in the chart
     #A list of Legends can be optionally specified. Legend config is
     #[String, Type,Color]. The last two are optional.
     #The charts are drawn in the order as specified in the config.
     #So, if the config is ['Line', 'Bar'], Linechart is drawn first
     #and then Barchart. Thus some parts of Line gets overdrawn by Bars.
     #To display both line and bar cleanly, it is suggested that the
     #config be ['Bar', 'Line']. There is also a minimum support to
     #split a chart. Separate charts are drawn in the same area for
     #each set of [y_vals].
     self.canvas = canvas
     self.canvas.saveState()
     self.drawing = Drawing(self.width, self.height)
     self.origHeight = origHeight = self.height
     if len(self.legendList) > 1:
         #Kludge: We encroach the space needed for legends by bringing down the 
         #y value by 28 below (y -= 28), so, the height is increased by 28
         self.origHeight += 28
     if (self.splitgraph == True and len(self.y_vals) > 1 and
             len(self.y_vals) * len(self.x_vals) > 30):
         origXval = x
         origYval = y
         origYvals = copy.deepcopy(self.y_vals)
         numSets = len(self.y_vals)
         origLegends = self.legendList[:]
         heightincr = origHeight/numSets
         self.numSplits = 0
         self.betweenSplitsF = True
         for i in range(numSets):
             self.y_vals = []
             self.y_vals.append(origYvals[i])
             self.height = heightincr
             y = y + (i * heightincr)
             self.legendList = []
             if len(origLegends) > i:
                 self.legendList.append(origLegends[i])
                 #Kludge: Bring the graph down by 28 points, as we add 28 points
                 #when we have legends 
                 y -= 28
             self.generateGraphs(x, y)
             self.numSplits += 1
         self.betweenSplitsF = False
         self.y_vals = copy.deepcopy(origYvals)
         self.legendList = origLegends[:]
         self.height = self.origHeight
         x = origXval
         y = origYval
     else:
         if len(self.legendList) > 0:
             #Kludge: Bring the graph down by 28 points, as we add 28 points
             #when we have legends 
             y -= 28
         self.generateGraphs(x, y)
     renderPDF.draw(self.drawing, self.canvas, x, y)
     self.canvas.restoreState()