Ignore:
Timestamp:
03/23/12 19:40:21 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Fixed font path.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/orng/orngMisc.py

    r9671 r10632  
    11from __future__ import with_statement 
    22import random, types 
    3  
     3import os.path 
     4 
     5from Orange.misc.environ import install_dir 
    46## -> Orange.misc 
    57 
    68def getobjectname(x, default=""): 
    7     if type(x)==types.StringType: 
     9    if type(x) == types.StringType: 
    810        return x 
    9        
     11 
    1012    for i in ["name", "shortDescription", "description", "func_doc", "func_name"]: 
    1113        if getattr(x, i, ""): 
     
    1416    if hasattr(x, "__class__"): 
    1517        r = repr(x.__class__) 
    16         if r[1:5]=="type": 
     18        if r[1:5] == "type": 
    1719            return str(x.__class__)[7:-2] 
    18         elif r[1:6]=="class": 
     20        elif r[1:6] == "class": 
    1921            return str(x.__class__)[8:-2] 
    2022 
     
    2325 
    2426def demangleExamples(x): 
    25     if type(x)==types.TupleType: 
     27    if type(x) == types.TupleType: 
    2628        return x 
    2729    else: 
    2830        return x, 0 
    29      
     31 
    3032 
    3133## -> Orange.misc.counters 
     
    4143    else: 
    4244        return BooleanCounter(self.bits) 
    43      
     45 
    4446  def next(self): 
    4547    if self.state: 
    46       for bit in range(self.bits-1, -1, -1): 
    47         self.state[bit] = (self.state[bit]+1) % 2 
     48      for bit in range(self.bits - 1, -1, -1): 
     49        self.state[bit] = (self.state[bit] + 1) % 2 
    4850        if self.state[bit]: 
    4951          break 
     
    5153        self.state = None 
    5254    else: 
    53       self.state = [0]*self.bits 
     55      self.state = [0] * self.bits 
    5456 
    5557    if not self.state: 
     
    6365    self.limits = limits 
    6466    self.state = None 
    65      
     67 
    6668  def __iter__(self): 
    6769    if self.state: 
     
    7274  def next(self): 
    7375    if self.state: 
    74       i = len(self.limits)-1 
    75       while (i>=0) and (self.state[i]==self.limits[i]-1): 
     76      i = len(self.limits) - 1 
     77      while (i >= 0) and (self.state[i] == self.limits[i] - 1): 
    7678        self.state[i] = 0 
    7779        i -= 1 
    78       if i==-1: 
     80      if i == -1: 
    7981        self.state = None 
    8082      else: 
    8183        self.state[i] += 1 
    8284    else: 
    83       self.state = [0]*len(self.limits) 
    84    
     85      self.state = [0] * len(self.limits) 
     86 
    8587    if not self.state: 
    8688      raise StopIteration, "LimitedCounter: counting finished" 
     
    9395        if m > n: 
    9496            raise TypeError, "Number of selected items exceeds the number of items" 
    95          
     97 
    9698        self.state = None 
    9799        self.m = m 
    98100        self.n = n 
    99          
     101 
    100102    def __iter__(self): 
    101103        if self.state: 
     
    103105        else: 
    104106            return MofNCounter(self.m, self.n) 
    105          
     107 
    106108    def next(self): 
    107109        if self.state: 
    108110            m, n, state = self.m, self.n, self.state 
    109             for place in range(m-1, -1, -1): 
    110                 if state[place] + m-1-place < n-1: 
     111            for place in range(m - 1, -1, -1): 
     112                if state[place] + m - 1 - place < n - 1: 
    111113                    state[place] += 1 
    112                     for place in range(place+1, m): 
    113                         state[place] = state[place-1] + 1 
     114                    for place in range(place + 1, m): 
     115                        state[place] = state[place - 1] + 1 
    114116                    break 
    115117            else: 
     
    118120        else: 
    119121            self.state = range(self.m) 
    120              
     122 
    121123        return self.state[:] 
    122               
     124 
    123125class NondecreasingCounter: 
    124126  def __init__(self, places): 
    125     self.state=None 
    126     self.subcounter=None 
    127     self.places=places 
     127    self.state = None 
     128    self.subcounter = None 
     129    self.places = places 
    128130 
    129131  def __iter__(self): 
     
    135137  def next(self): 
    136138    if not self.subcounter: 
    137       self.subcounter=BooleanCounter(self.places-1) 
     139      self.subcounter = BooleanCounter(self.places - 1) 
    138140    if self.subcounter.next(): 
    139       self.state=[0] 
     141      self.state = [0] 
    140142      for add_one in self.subcounter.state: 
    141         self.state.append(self.state[-1]+add_one) 
     143        self.state.append(self.state[-1] + add_one) 
    142144    else: 
    143       self.state=None 
    144    
     145      self.state = None 
     146 
    145147    if not self.state: 
    146148      raise StopIteration, "NondecreasingCounter: counting finished" 
     
    162164  def next(self): 
    163165    if self.state: 
    164       i = self.places-1 
    165       while (i>0) and (self.state[i]==max(self.state[:i])+1): 
     166      i = self.places - 1 
     167      while (i > 0) and (self.state[i] == max(self.state[:i]) + 1): 
    166168        self.state[i] = 0 
    167169        i -= 1 
     
    169171        self.state[i] += 1 
    170172      else: 
    171         self.state=None 
     173        self.state = None 
    172174    else: 
    173       self.state = [0]*self.places 
     175      self.state = [0] * self.places 
    174176 
    175177    if not self.state: 
    176178      raise StopIteration, "CanonicFuncCounter: counting finished" 
    177      
     179 
    178180    return self.state 
    179181 
     
    184186 
    185187class BestOnTheFly: 
    186     def __init__(self, compare=cmp, seed = 0, callCompareOn1st = False): 
     188    def __init__(self, compare=cmp, seed=0, callCompareOn1st=False): 
    187189        self.randomGenerator = random.Random(seed) 
    188         self.compare=compare 
    189         self.wins=0 
     190        self.compare = compare 
     191        self.wins = 0 
    190192        self.bestIndex, self.index = -1, -1 
    191193        self.best = None 
     
    195197        self.index += 1 
    196198        if not self.wins: 
    197             self.best=x 
    198             self.wins=1 
    199             self.bestIndex=self.index 
     199            self.best = x 
     200            self.wins = 1 
     201            self.bestIndex = self.index 
    200202            return 1 
    201203        else: 
    202204            if self.callCompareOn1st: 
    203                 cmpr=self.compare(x[0], self.best[0]) 
     205                cmpr = self.compare(x[0], self.best[0]) 
    204206            else: 
    205                 cmpr=self.compare(x, self.best) 
    206             if cmpr>0: 
    207                 self.best=x 
    208                 self.wins=1 
    209                 self.bestIndex=self.index 
     207                cmpr = self.compare(x, self.best) 
     208            if cmpr > 0: 
     209                self.best = x 
     210                self.wins = 1 
     211                self.bestIndex = self.index 
    210212                return 1 
    211             elif cmpr==0: 
    212                 self.wins=self.wins+1 
    213                 if not self.randomGenerator.randint(0, self.wins-1): 
    214                     self.best=x 
    215                     self.bestIndex=self.index 
     213            elif cmpr == 0: 
     214                self.wins = self.wins + 1 
     215                if not self.randomGenerator.randint(0, self.wins - 1): 
     216                    self.best = x 
     217                    self.bestIndex = self.index 
    216218                    return 1 
    217219        return 0 
     
    226228            return None 
    227229 
    228 def selectBest(x, compare=cmp, seed = 0, callCompareOn1st = False): 
    229     bs=BestOnTheFly(compare, seed, callCompareOn1st) 
     230def selectBest(x, compare=cmp, seed=0, callCompareOn1st=False): 
     231    bs = BestOnTheFly(compare, seed, callCompareOn1st) 
    230232    for i in x: 
    231233        bs.candidate(i) 
    232234    return bs.winner() 
    233235 
    234 def selectBestIndex(x, compare=cmp, seed = 0, callCompareOn1st = False): 
    235     bs=BestOnTheFly(compare, seed, callCompareOn1st) 
     236def selectBestIndex(x, compare=cmp, seed=0, callCompareOn1st=False): 
     237    bs = BestOnTheFly(compare, seed, callCompareOn1st) 
    236238    for i in x: 
    237239        bs.candidate(i) 
     
    261263def frange(*argw): 
    262264    start, stop, step = 0.0, 1.0, 0.1 
    263     if len(argw)==1: 
    264         start=step=argw[0] 
    265     elif len(argw)==2: 
     265    if len(argw) == 1: 
     266        start = step = argw[0] 
     267    elif len(argw) == 2: 
    266268        stop, step = argw 
    267     elif len(argw)==3: 
     269    elif len(argw) == 3: 
    268270        start, stop, step = argw 
    269     elif len(argw)>3: 
     271    elif len(argw) > 3: 
    270272        raise AttributeError, "1-3 arguments expected" 
    271273 
    272     stop+=1e-10 
    273     i=0 
    274     res=[] 
     274    stop += 1e-10 
     275    i = 0 
     276    res = [] 
    275277    while 1: 
    276         f=start+i*step 
    277         if f>stop: 
     278        f = start + i * step 
     279        if f > stop: 
    278280            break 
    279281        res.append(f) 
    280         i+=1 
     282        i += 1 
    281283    return res 
    282284 
     
    301303        self.output = output 
    302304 
    303     def clear(self, i=-1): 
     305    def clear(self, i= -1): 
    304306        try: 
    305307            if hasattr(self.output, "isatty") and self.output.isatty(): 
     
    335337        self.__call__(100) 
    336338        self.output.write("\n") 
    337          
     339 
    338340def progressBarMilestones(count, iterations=100): 
    339     return set([int(i*count/float(iterations)) for i in range(iterations)]) 
     341    return set([int(i * count / float(iterations)) for i in range(iterations)]) 
    340342 
    341343 
    342344## Odkrij, kdo to uporablja 
    343        
     345 
    344346class ColorPalette(object): 
    345347    def __init__(self, colors, gamma=None, overflow=(255, 255, 255), underflow=(255, 255, 255), unknown=(0, 0, 0)): 
    346348        self.colors = colors 
    347         self.gammaFunc = lambda x, gamma:((math.exp(gamma*math.log(2*x-1)) if x > 0.5 else -math.exp(gamma*math.log(-2*x+1)) if x!=0.5 else 0.0)+1)/2.0 
     349        self.gammaFunc = lambda x, gamma:((math.exp(gamma * math.log(2 * x - 1)) if x > 0.5 else -math.exp(gamma * math.log(-2 * x + 1)) if x != 0.5 else 0.0) + 1) / 2.0 
    348350        self.gamma = gamma 
    349351        self.overflow = overflow 
     
    369371                x = self.gammaFunc(x, gamma) 
    370372            return [(c2 - c1) * x + c1 for c1, c2 in [(red1, red2), (green1, green2), (blue1, blue2)]] 
    371          
     373 
    372374    def __call__(self, val, gamma=None): 
    373375        return self.get_rgb(val, gamma) 
    374      
     376 
    375377import math 
    376378 
    377379#from ColorPalette import ColorPalette 
    378      
     380 
    379381class GeneratorContextManager(object): 
    380382   def __init__(self, gen): 
     
    437439        with contextmanager(disabler)(): 
    438440            return func(*args, **kwargs) 
    439     return wrapper   
     441    return wrapper 
    440442 
    441443 
     
    446448class Renderer(object): 
    447449    render_state_attributes = ["font", "stroke_color", "fill_color", "render_hints", "transform", "gradient", "text_alignment"] 
    448      
     450 
    449451    ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER = range(3) 
    450        
     452 
    451453    def __init__(self, width, height): 
    452454        self.width = width 
     
    463465        self.render_state["render_hints"] = {} 
    464466        self.render_state_stack = [] 
    465          
     467 
    466468    def font(self): 
    467469        return self.render_state["font"] 
    468      
     470 
    469471    def set_font(self, family, size): 
    470472        self.render_state["font"] = family, size 
     
    472474    def fill_color(self): 
    473475        return self.render_state["fill_color"] 
    474      
     476 
    475477    def set_fill_color(self, color): 
    476478        self.render_state["fill_color"] = color 
    477          
     479 
    478480    def set_gradient(self, gradient): 
    479481        self.render_state["gradient"] = gradient 
    480          
     482 
    481483    def gradient(self): 
    482484        return self.render_state["gradient"] 
    483          
     485 
    484486    def stroke_color(self): 
    485487        return self.render_state["stroke_color"] 
    486      
     488 
    487489    def set_stroke_color(self, color): 
    488490        self.render_state["stroke_color"] = color 
    489      
     491 
    490492    def stroke_width(self): 
    491493        return self.render_state["stroke_width"] 
    492      
     494 
    493495    def set_stroke_width(self, width): 
    494496        self.render_state["stroke_width"] = width 
    495          
     497 
    496498    def set_text_alignment(self, align): 
    497499        self.render_state["text_alignment"] = align 
    498          
     500 
    499501    def text_alignment(self): 
    500502        return self.render_state["text_alignment"] 
    501          
     503 
    502504    def transform(self): 
    503505        return self.render_state["transform"] 
    504      
     506 
    505507    def set_transform(self, transform): 
    506508        self.render_state["transform"] = transform 
    507          
     509 
    508510    def render_hints(self): 
    509511        return self.render_state["render_hints"] 
    510      
     512 
    511513    def set_render_hints(self, hints): 
    512514        self.render_state["render_hints"].update(hints) 
    513      
     515 
    514516    def save_render_state(self): 
    515517        import copy 
    516518        self.render_state_stack.append(copy.deepcopy(self.render_state)) 
    517      
     519 
    518520    def restore_render_state(self): 
    519521        self.render_state = self.render_state_stack.pop(-1) 
    520          
     522 
    521523    def apply_transform(self, transform): 
    522524        self.render_state["transform"] = self.render_state["transform"] * transform 
    523           
     525 
    524526    def translate(self, x, y): 
    525527        transform = numpy.eye(3) 
    526528        transform[:, 2] = x, y, 1 
    527529        self.apply_transform(transform) 
    528      
     530 
    529531    def rotate(self, angle): 
    530532        angle *= 2 * math.pi / 360.0 
     
    532534        transform[:2, :2] = [[math.cos(angle), -math.sin(angle)], [math.sin(angle), math.cos(angle)]] 
    533535        self.apply_transform(transform) 
    534      
     536 
    535537    def scale(self, sx, sy): 
    536538        transform = numpy.eye(3) 
    537         transform[(0, 1), (0, 1)] = sx, sy  
     539        transform[(0, 1), (0, 1)] = sx, sy 
    538540        self.apply_transform(transform) 
    539          
     541 
    540542    def skew(self, sx, sy): 
    541543        transform = numpy.eye(3) 
    542544        transform[(1, 0), (0, 1)] = numpy.array([sx, sy]) * 2 * math.pi / 360.0 
    543545        self.apply_transform(transform) 
    544      
     546 
    545547    def draw_line(self, sx, sy, ex, ey, **kwargs): 
    546548        raise NotImplemented 
    547      
     549 
    548550    def draw_lines(self, points, **kwargs): 
    549551        raise NotImplemented 
    550      
     552 
    551553    def draw_rect(self, x, y, w, h, **kwargs): 
    552554        raise NotImplemented 
    553      
     555 
    554556    def draw_polygon(self, vertices, **kwargs): 
    555557        raise NotImplemented 
     
    557559    def draw_arch(self, something, **kwargs): 
    558560        raise NotImplemented 
    559      
     561 
    560562    def draw_text(self, x, y, text, **kwargs): 
    561563        raise NotImplemented 
    562      
     564 
    563565    def string_size_hint(self, text, **kwargs): 
    564566        raise NotImpemented 
    565      
     567 
    566568    @contextmanager 
    567569    def state(self, **kwargs): 
     
    576578        finally: 
    577579            self.restore_render_state() 
    578              
     580 
    579581    def save(self): 
    580582        raise NotImplemented 
    581      
     583 
    582584    def close(self, file): 
    583585        pass 
    584      
     586 
    585587class EPSRenderer(Renderer): 
    586588    EPS_DRAW_RECT = """/draw_rect  
     
    594596 closepath 
    595597} def""" 
    596      
     598 
    597599    EPS_SET_GRADIENT = """<< /PatternType 2 
    598600 /Shading 
     
    642644                                 fill_color=lambda color:"%f %f %f setrgbcolor" % tuple(255.0 / c for c in color), 
    643645                                 stroke_width=lambda w: "%f setlinewidth" % w) 
    644          
     646 
    645647    def set_font(self, family, size): 
    646648        Renderer.set_font(self, family, size) 
    647649        self._eps.write("/%s findfont %f scalefont setfont\n" % self.font()) 
    648          
     650 
    649651    def set_fill_color(self, color): 
    650652        Renderer.set_fill_color(self, color) 
    651         self._eps.write("%f %f %f setrgbcolor\n" % tuple(c/255.0 for c in color)) 
    652          
     653        self._eps.write("%f %f %f setrgbcolor\n" % tuple(c / 255.0 for c in color)) 
     654 
    653655    def set_gradient(self, gradient): 
    654656        Renderer.set_gradient(self, gradient) 
     
    656658        binary = "".join([chr(int(c)) for p, s in samples for c in s]) 
    657659        import binascii 
    658         self._eps.write(self.EPS_SET_GRADIENT % (x1, y1, x2, y2, len(samples), binascii.hexlify(binary)))  
    659          
     660        self._eps.write(self.EPS_SET_GRADIENT % (x1, y1, x2, y2, len(samples), binascii.hexlify(binary))) 
     661 
    660662    def set_stroke_color(self, color): 
    661663        Renderer.set_stroke_color(self, color) 
    662         self._eps.write("%f %f %f setrgbcolor\n" % tuple(c/255.0 for c in color)) 
    663          
     664        self._eps.write("%f %f %f setrgbcolor\n" % tuple(c / 255.0 for c in color)) 
     665 
    664666    def set_stroke_width(self, width): 
    665667        Renderer.set_stroke_width(self, width) 
    666668        self._eps.write("%f setlinewidth\n" % width) 
    667          
     669 
    668670    def set_render_hints(self, hints): 
    669671        Renderer.set_render_hints(self, hints) 
     
    671673            map = {"butt":0, "round":1, "rect":2} 
    672674            self._eps.write("%i setlinecap\n" % (map.get(hints.get("linecap"), 0))) 
    673         
    674     @with_state  
     675 
     676    @with_state 
    675677    def draw_line(self, sx, sy, ex, ey, **kwargs): 
    676678        self._eps.write("newpath\n%f %f moveto %f %f lineto\nstroke\n" % (sx, -sy, ex, -ey)) 
    677          
     679 
    678680    @with_state 
    679681    def draw_rect(self, x, y, w, h, **kwargs): 
    680         self._eps.write("newpath\n%(x)f %(y)f moveto %(w)f 0 rlineto\n0 %(h)f rlineto %(w)f neg 0 rlineto\nclosepath\n" % dict(x=x,y=-y, w=w, h=-h)) 
     682        self._eps.write("newpath\n%(x)f %(y)f moveto %(w)f 0 rlineto\n0 %(h)f rlineto %(w)f neg 0 rlineto\nclosepath\n" % dict(x=x, y= -y, w=w, h= -h)) 
    681683        self._eps.write("gsave\n") 
    682684        if self.gradient(): 
     
    687689        self.set_stroke_color(self.stroke_color()) 
    688690        self._eps.write("stroke\n") 
    689          
     691 
    690692    @with_state 
    691693    def draw_polygon(self, vertices, **kwargs): 
     
    699701        self.set_stroke_color(self.stroke_color()) 
    700702        self._eps.write("stroke\n") 
    701          
     703 
    702704    @with_state 
    703705    def draw_text(self, x, y, text, **kwargs): 
    704706        show = ["show", "right_align_show", "center_align_show"][self.text_alignment()] 
    705707        self._eps.write("%f %f moveto (%s) %s\n" % (x, -y, text, show)) 
    706          
     708 
    707709    def save_render_state(self): 
    708710        Renderer.save_render_state(self) 
    709711        self._eps.write("gsave\n") 
    710          
     712 
    711713    def restore_render_state(self): 
    712714        Renderer.restore_render_state(self) 
    713715        self._eps.write("grestore\n") 
    714          
     716 
    715717    def translate(self, dx, dy): 
    716718        Renderer.translate(self, dx, dy) 
    717719        self._eps.write("%f %f translate\n" % (dx, -dy)) 
    718          
     720 
    719721    def rotate(self, angle): 
    720722        Renderer.rotate(self, angle) 
    721723        self._eps.write("%f rotate\n" % -angle) 
    722          
     724 
    723725    def scale(self, sx, sy): 
    724726        Renderer.scale(self, sx, sy) 
    725727        self._eps.write("%f %f scale\n" % (sx, sy)) 
    726      
     728 
    727729    def skew(self, sx, sy): 
    728730        Renderer.skew(self, sx, sy) 
    729731        self._eps.write("%f %f skew\n" % (sx, sy)) 
    730          
     732 
    731733    def save(self, filename): 
    732734#        self._eps.close() 
    733735        open(filename, "wb").write(self._eps.getvalue()) 
    734          
     736 
    735737    def string_size_hint(self, text, **kwargs): 
    736738        import warnings 
    737739        warnings.warn("EpsRenderer class does not suport exact string width estimation", stacklevel=2) 
    738740        return len(text) * self.font()[1] 
    739          
    740          
     741 
     742 
    741743class PILRenderer(Renderer): 
    742744    def __init__(self, width, height): 
     
    744746        import Image, ImageDraw, ImageFont 
    745747        self._pil_image = Image.new("RGB", (width, height), (255, 255, 255)) 
    746         self._draw =  ImageDraw.Draw(self._pil_image, "RGB") 
     748        self._draw = ImageDraw.Draw(self._pil_image, "RGB") 
    747749        self._pil_font = ImageFont.load_default() 
    748750 
     
    750752        p = self.transform() * [[x], [y], [1]] 
    751753        return p[0, 0], p[1, 0] 
    752      
     754 
    753755    def set_font(self, family, size): 
    754756        Renderer.set_font(self, family, size) 
    755757        import ImageFont 
    756758        try: 
    757             self._pil_font = ImageFont.load(family + ".ttf", size) 
     759            font_file = os.path.join(install_dir, "utils", family + ".ttf") 
     760            if os.path.exists(font_file): 
     761                self._pil_font = ImageFont.truetype(font_file, int(size)) 
     762            else: 
     763                self._pil_font = ImageFont.truetype(family + ".ttf", int(size)) 
    758764        except Exception: 
    759765            import warnings 
    760766            warnings.warn("Could not load %s.ttf font!", stacklevel=2) 
    761767            try: 
    762                 self._pil_font = ImageFont.load("cour.ttf", size) 
     768                self._pil_font = ImageFont.truetype("cour.ttf", int(size)) 
    763769            except Exception: 
    764770                warnings.warn("Could not load the cour.ttf font!! Loading the default", stacklevel=2) 
    765771                self._pil_font = ImageFont.load_default() 
    766          
     772 
    767773    @with_state 
    768774    def draw_line(self, sx, sy, ex, ey, **kwargs): 
     
    775781        x1, y1 = self._transform(x, y) 
    776782        x2, y2 = self._transform(x + w, y + h) 
    777         self._draw.rectangle((x1, y1, x2 ,y2), fill=self.fill_color(), outline=self.stroke_color()) 
    778          
     783        self._draw.rectangle((x1, y1, x2 , y2), fill=self.fill_color(), outline=self.stroke_color()) 
     784 
    779785    @with_state 
    780786    def draw_text(self, x, y, text, **kwargs): 
    781787        x, y = self._transform(x, y - self.font()[1]) 
    782788        self._draw.text((x, y), text, font=self._pil_font, fill=self.stroke_color()) 
    783          
     789 
    784790    def save(self, file): 
    785791        self._pil_image.save(file) 
    786          
     792 
    787793    def string_size_hint(self, text, **kwargs): 
    788794        return self._pil_font.getsize(text)[1] 
     
    804810        self._defs = StringIO.StringIO() 
    805811        self._gradients = {} 
    806          
     812 
    807813    def set_gradient(self, gradient): 
    808814        Renderer.set_gradient(self, gradient) 
     
    812818            (x1, y1, x2, y2), stops = gradient 
    813819            (x1, y1, x2, y2) = (0, 0, 100, 0) 
    814              
     820 
    815821            self._defs.write('<linearGradient id="%s" x1="%f%%" y1="%f%%" x2="%f%%" y2="%f%%">\n' % (id, x1, y1, x2, y2)) 
    816822            for offset, color in stops: 
    817823                self._defs.write('<stop offset="%f" style="stop-color:rgb(%i, %i, %i); stop-opacity:1"/>\n' % ((offset,) + color)) 
    818824            self._defs.write('</linearGradient>\n') 
    819          
     825 
    820826    def get_fill(self): 
    821827        if self.render_state["gradient"]: 
     
    823829        else: 
    824830            return 'fill="rgb(%i %i %i)"' % self.fill_color() 
    825          
     831 
    826832    def get_stroke(self): 
    827833#        if self.render_state["gradient"]: 
     
    829835#        else: 
    830836            return 'stroke="rgb(%i, %i, %i)"' % self.stroke_color() + ' stroke-width="%f"' % self.stroke_width() 
    831          
     837 
    832838    def get_text_alignment(self): 
    833839        return 'text-anchor="%s"' % (["start", "end", "middle"][self.text_alignment()]) 
    834      
     840 
    835841    def get_linecap(self): 
    836842        return 'stroke-linecap="%s"' % self.render_hints().get("linecap", "butt") 
    837          
     843 
    838844    @with_state 
    839845    def draw_line(self, sx, sy, ex, ey): 
    840846        self._svg.write('<line x1="%f" y1="%f" x2="%f" y2="%f" %s %s/>\n' % ((sx, sy, ex, ey) + (self.get_stroke(), self.get_linecap()))) 
    841          
     847 
    842848#    @with_state 
    843849#    def draw_lines(self): 
    844          
     850 
    845851    @with_state 
    846852    def draw_rect(self, x, y, w, h): 
    847853        self._svg.write('<rect x="%f" y="%f" width="%f" height="%f" %s %s/>\n' % ((x, y, w, h) + (self.get_fill(),) + (self.get_stroke(),))) 
    848              
     854 
    849855    @with_state 
    850856    def draw_polygon(self, vertices, **kwargs): 
     
    853859        path += " z" 
    854860        self._svg.write('<path d="%s" %s/>' % ((path,) + (self.get_stroke(),))) 
    855          
     861 
    856862    @with_state 
    857863    def draw_text(self, x, y, text): 
    858         self._svg.write('<text x="%f" y="%f" font-family="%s" font-size="%f" %s>%s</text>\n' % ((x, y) + self.font() +(self.get_text_alignment(), text))) 
    859          
     864        self._svg.write('<text x="%f" y="%f" font-family="%s" font-size="%f" %s>%s</text>\n' % ((x, y) + self.font() + (self.get_text_alignment(), text))) 
     865 
    860866    def translate(self, x, y): 
    861867        self._svg.write('<g transform="translate(%f,%f)">\n' % (x, y)) 
    862868        self.transform_count_stack[-1] = self.transform_count_stack[-1] + 1 
    863          
     869 
    864870    def rotate(self, angle): 
    865871        self._svg.write('<g transform="rotate(%f)">\n' % angle) 
    866872        self.transform_count_stack[-1] = self.transform_count_stack[-1] + 1 
    867          
     873 
    868874    def scale(self, sx, sy): 
    869875        self._svg.write('<g transform="scale(%f,%f)">\n' % (sx, sy)) 
    870876        self.transform_count_stack[-1] = self.transform_count_stack[-1] + 1 
    871          
     877 
    872878    def skew(self, sx, sy): 
    873879        self._svg.write('<g transform="skewX(%f)">' % sx) 
     
    878884        Renderer.save_render_state(self) 
    879885        self.transform_count_stack.append(0) 
    880          
     886 
    881887    def restore_render_state(self): 
    882888        Renderer.restore_render_state(self) 
    883889        count = self.transform_count_stack.pop(-1) 
    884890        self._svg.write('</g>\n' * count) 
    885          
     891 
    886892    def save(self, filename): 
    887893        open(filename, "wb").write(self.SVG_HEADER % (self.height, self.width, self._defs.getvalue(), self._svg.getvalue())) 
    888          
     894 
    889895class CairoRenderer(Renderer): 
    890896    def __init__(self, width, height): 
    891897        Renderer.__init__(self, width, height) 
    892          
     898 
Note: See TracChangeset for help on using the changeset viewer.