Python canvas.setFillColor函数代码示例

 def get_canvas(self, packet):
     canvas = super(AnswerSheetMask, self).get_canvas(packet)
     canvas.setStrokeColor(colors.black)
     canvas.setFillColor(colors.white)
     canvas.setLineWidth(0.2 * mm)
     canvas.setFont('Helvetica', 8)
     return canvas

 def draw_half_star (self, inner_length=1*inch, outer_length=2*inch, points=5, origin=None):
     canvas = self.canv
     canvas.setLineWidth(0)
     if not origin: canvas.translate(self.size*0.5,self.size*0.5)
     else: canvas.translate(*origin)
     canvas.setFillColor(self.fillcolor)
     canvas.setStrokeColor(self.strokecolor)
     p = canvas.beginPath()
     inner = False # Start on top
     is_origin = True
     #print 'Drawing star with radius',outer_length,'(moving origin ',origin,')'
     for theta in range(0,360,360/(points*2)):
         if 0 < theta < 180: continue
         if inner: r = inner_length
         else: r = outer_length
         x = (math.sin(math.radians(theta)) * r)
         y = (math.cos(math.radians(theta)) * r)
         #print 'POINT:',x,y
         if is_origin:
             p.moveTo(x,y)
             is_origin = False
         else:
             p.lineTo(x,y)
         inner = not inner
     p.close()
     canvas.drawPath(p,fill=1)

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 __applyCanvasOptions(self, canvas, opts):
		for opt in opts:
			if opt == 'fillColor':
				canvas.setFillColor(opts[opt])
			if opt == 'fontSize':
				canvas.setFontSize(opts[opt])
		return canvas

def orf_eus(canvas, featL, coords, color_hex, shape):
    """Draw CDS and write count."""
    xs, xe, xn, y0, yt, yb, ynt, ynb = coords
    canvas.setLineWidth(1)
    # initialize path
    pORF = canvas.beginPath()
    if shape == 'square':
        pORF.moveTo(xs,ynt)
        pORF.lineTo(xe,ynt)
        pORF.lineTo(xe,ynb)
        pORF.lineTo(xs,ynb)
        pORF.lineTo(xs,ynt)
    # draw triangle-shaped ORFS
    elif featL <= minL:
        pORF.moveTo(xs,yt)
        pORF.lineTo(xe,y0)
        pORF.lineTo(xs,yb)
        pORF.lineTo(xs,yt)
    # draw arrow-shaped ORFS
    else:
        pORF.moveTo(xs,ynt)
        pORF.lineTo(xn,ynt)
        pORF.lineTo(xn,yt)
        pORF.lineTo(xe,y0)
        pORF.lineTo(xn,yb)
        pORF.lineTo(xn,ynb)
        pORF.lineTo(xs,ynb)
        pORF.lineTo(xs,ynt)
    # evaluate function category and set fill color
    canvas.setFillColor(color_hex)
    # finalize object path
    canvas.drawPath(pORF, stroke=1, fill=1)
    pORF.close()
    canvas.setFillColor(black)

	def show(self, canvas, showframe=None):
		if self._border_width > 0.0:
			canvas.saveState()
			canvas.setStrokeColor(self._border_color)
			canvas.setLineWidth(self._border_width)
			if self._border_fill_color.lower() != 'none':
				canvas.setFillColor(self._border_fill_color)                        
			canvas.rect(self.x, 
						self.y, 
						self.width, 
						self.height, 
						stroke=self._border_type, 
						fill=self._fill_border_rect)
			canvas.restoreState()

		if self.flowable is not None:                  
			self.flowable.width = self.width-(2.0*self._padding[0])
			self.flowable.height = self.height-(2.0*self._padding[1])
			self.flowable.drawOn(canvas, self.x+self._padding[0], self.y-self._padding[1])

			if showframe is not None:
				canvas.saveState()
				canvas.setLineWidth(showframe[0])
				canvas.rect(self.x, self.y, self.width, self.height, stroke=1, fill=showframe[1])
				canvas.restoreState()

		return self

 def drawShape(self, canvas, controls, color):
     """Utlity to draw a closed shape through a list of control points;
     extends the previous proc"""
     canvas.setFillColor(color)
     p = canvas.beginPath()
     self.curveThrough(p, controls)
     p.close()
     canvas.drawPath(p, stroke=1, fill=1)

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_circle (self, x, y, r):
     # Test...
     canvas = self.canv
     canvas.setLineWidth(0)        
     canvas.setStrokeColor(colors.grey)
     canvas.setFillColor(colors.grey)        
     p = canvas.beginPath()
     p.circle(x,y,r)
     p.close()
     canvas.drawPath(p,fill=1)

    def drawBackground(self, canvas):
        underkant = 5.0/6.0 * inch
        # a4 format spec:
        # http://www.cl.cam.ac.uk/~mgk25/iso-paper.html
        # 210 x 297
        # faktura spek:
        # Norsk Standard Skjema F60-1
        # url: http://code.google.com/p/finfaktura/issues/detail?id=38
        canvas.saveState()
        canvas.setFillColor(yellow)

        # Yellow bits; skipping the receipt area.
        # Lag de gule feltene
        #canvas.rect(0*mm, 101*mm, 210*mm, 21*mm, stroke=0, fill=1)
        canvas.rect(0*mm, 33*mm, 210*mm, 9*mm, stroke=0, fill=1)
        canvas.rect(0*mm, 14*mm, 210*mm, 2*mm, stroke=0, fill=1)

        canvas.setFillColor(white)
        # Legg de hvite feltene oppå for "gjennomsiktighet"
        canvas.rect(80*mm, 103*mm, 36*mm, 9*mm, stroke=0, fill=1) # beløp
        canvas.rect(126*mm, 103*mm, 40*mm, 9*mm, stroke=0, fill=1) # betalerens kontonummer
        canvas.rect(170*mm, 103*mm, 31*mm, 9*mm, stroke=0, fill=1) # blankettnummer
        canvas.restoreState()

        # skillelinjer for KID
        canvas.lines([(9*mm, 16*mm, 9*mm, 30*mm), (80*mm, 16*mm, 80*mm, 30*mm)])
        # blankettnummer
        #canvas.setFont("Courier", 10)
        #blankettnr = "xxxxxxx"
        #canvas.drawString(173*mm, 105*mm, blankettnr)
        #canvas.drawString(173*mm, underkant, blankettnr)

        # Lag klammer for kontrollsiffer til sum.
        canvas.drawString(115*mm, underkant, "<")
        canvas.drawString(125*mm, underkant, ">")
        # Lag tekst som beskriver feltene.
        canvas.setFont("Helvetica-Bold", 6)
        canvas.drawString(15*mm, 98*mm, "Betalingsinformasjon")
        canvas.drawString(10*mm,30*mm,"Kundeidentifikasjon (KID)")
        canvas.drawString(82*mm,30*mm,"Kroner")
        canvas.drawString(107*mm,30*mm,"Øre")
        canvas.drawString(133*mm,30*mm,"Til konto")
        canvas.drawString(172*mm,30*mm,"Blankettnummer")
        canvas.drawString(150*mm,98*mm,"Betalings-")
        canvas.drawString(150*mm,95*mm,"frist")

        # Lag hjørneklammer rundt alle tekstfelt
        self.markField(canvas, 12*mm,64*mm, 86*mm, -21*mm, "Betalt av")
        self.markField(canvas, 110*mm,64*mm, 86*mm, -21*mm, "Betalt til")
        self.markField(canvas, 110*mm,89*mm, 86*mm, -19*mm, "Underskrift ved girering")
        self.markField(canvas, 166*mm,99*mm, 30*mm, -6*mm)    # Betalingsfrist.

        # Add the all-important "GIRO" text. It seems to do wonders for the recognition.
        canvas.setFont('Helvetica-Bold', 14)
        canvas.drawString(110*mm, 98*mm, "GIRO")

 def func(canvas, doc):
     width, height = letter
     margin = 0.66 * 72
     canvas.saveState()
     canvas.setFillColor('gray')
     #canvas.setFont('OpenSans',12)
     canvas.drawString(margin, height - margin, "CONFIDENTIAL")
     canvas.drawRightString(width - margin, height - margin, localtime(timezone.now()).strftime(date_format))
     if recipient:
         canvas.drawString(margin, margin, "Intended for: Title IX Coordinator %s" % recipient)
     canvas.restoreState()

 def render(self, canvas):
     if len(self.words) == 1:
         canvas.setFillColor(self.words[0]['color'])
         canvas.drawString(self.coords[0], self.coords[1], self.words[0]['txt'])
     elif len(self.words)>1:
         txt = canvas.beginText()
         txt.setTextOrigin(self.coords[0], self.coords[1])
         for elt in self.words:
             txt.setFillColor(elt['color'])
             txt.textOut(elt['txt'])
         canvas.drawText(txt)

 def render(self, canvas, context):
     canvas.rect(self.left_margin, self.bottom_margin,
                 self.box_width, self.box_height,
                 stroke=0, fill=1)
     canvas.setFillColor(colors.black)
     canvas.drawString(
         self.left_margin + 2 * mm, self.bottom_margin + 2 * mm,
         'ID: {}'.format(context['student']['id']))
     canvas.drawRightString(
         self.left_margin + self.box_width - 2 * mm,
         self.bottom_margin + 2 * mm,
         '(Seite {})'.format(context['page_num']))

def labeller(cName, cLen, canvas, Y_map) :
    """Label baselines with genome/contig name and size."""
    canvas.setFillColor(black)
    y0 = Y_map
    x0 = -pNsize                # retreat into the left margin to write out name and size
    y1 = y0 + ck_vsp/10         # bump name up a bit from BL level
    y2 = y0 - ck_vsp            # bump size down a bit from BL level
    pLenStr = str(float(cLen)/1000) # converts number to suitable form
    canvas.setFont(bFont,LfSize)
    canvas.drawString(x0,y1,cName)
    canvas.setFont(rFont,NfSize)
    canvas.drawString(x0,y2,pLenStr+' kb')

 def _add_registration_details(self, canvas):
     start_posn = self.start_posn
     reg_detail_dict = {t[0]:t[1] for t in REG_STATUS_OPTIONS}
     canvas.setFillColor(colors.blue)
     canvas.setFont('Helvetica', 10)
     canvas.drawString(0.5*inch, start_posn,
                       'Section D: Registration Details')
     canvas.setLineWidth(1)
     canvas.setFillColor(colors.black)
     canvas.rect(0.5*inch, start_posn-1.3*inch,
                 PAGE_WIDTH-inch, 1.2*inch)
     canvas.line(2.5*inch, start_posn-1.3*inch,
                 2.5*inch, start_posn-0.1*inch)
     canvas.drawString(0.7*inch, start_posn-0.3*inch,
                       'Registration Status:')
     canvas.drawString(2.7*inch, start_posn-0.3*inch,
                       reg_detail_dict[self.details['registration_status']])
     canvas.line(0.5*inch, start_posn-0.4*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-0.4*inch)
     canvas.drawString(0.7*inch, start_posn-0.6*inch, 'Pre-Tax Price:')
     try:
         price = float(self.details['pre_tax_price'])
         gst, hst, qst, inv_total = self._calculate_tax_total(price)
         price = '${:0,.2f}'.format(price)
     except ValueError:
         if self.details['pre_tax_price'] == '':
             price = gst = hst = qst = inv_total = '$0.00'
         else:
             price = 'ERROR: Price Entered Incorrectly'
             gst = hst = qst = inv_total = '?????'
     canvas.drawString(2.7*inch, start_posn-0.6*inch, price)
     canvas.line(0.5*inch, start_posn-0.7*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-0.7*inch)
     canvas.drawString(0.7*inch, start_posn-0.9*inch, 'Taxes:')
     tax_info = ''
     if self.event.gst_charged:
         tax_info += 'GST: ' + gst + ' / '
     if self.event.hst_charged:
         tax_info += 'HST: ' + hst + ' / '
     if self.event.qst_charged:
         tax_info += 'QST: ' + qst + ' / '
     if len(tax_info) > 0:
         tax_info = tax_info[:-3]
     else:
         tax_info = 'No tax charged'
     canvas.drawString(2.7*inch, start_posn-0.9*inch, tax_info)
     canvas.line(0.5*inch, start_posn-1.0*inch,
                 PAGE_WIDTH-0.5*inch, start_posn-1.0*inch)
     canvas.setFont('Helvetica-Bold', 10)
     canvas.drawString(0.7*inch, start_posn-1.2*inch, 'Total Invoice:')
     canvas.drawString(2.7*inch, start_posn-1.2*inch, inv_total)
     self.start_posn = start_posn - 1.55 * inch