예제 #1
0
파일: canvas.py 프로젝트: dlobue/urwid
 def attrrange( start_offs, end_offs, destw ):
     """
     Add attributes based on attributes between
     start_offs and end_offs. 
     """
     if start_offs == end_offs:
         [(at,run)] = arange(start_offs,end_offs)
         rle_append_modify( linea, ( at, destw ))
         return
     if destw == end_offs-start_offs:
         for at, run in arange(start_offs,end_offs):
             rle_append_modify( linea, ( at, run ))
         return
     # encoded version has different width
     o = start_offs
     for at, run in arange(start_offs, end_offs):
         if o+run == end_offs:
             rle_append_modify( linea, ( at, destw ))
             return
         tseg = text[o:o+run]
         tseg, cs = apply_target_encoding( tseg )
         segw = rle_len(cs)
         
         rle_append_modify( linea, ( at, segw ))
         o += run
         destw -= segw
예제 #2
0
파일: canvas.py 프로젝트: dlobue/urwid
 def __init__(self, fill_char, cols, rows):
     Canvas.__init__(self)
     end, col = calc_text_pos(fill_char, 0, len(fill_char), 1)
     assert col == 1, "Invalid fill_char: %r" % fill_char
     self._text, cs = apply_target_encoding(fill_char[:end])
     self._cs = cs[0][0]
     self.size = cols, rows
     self.cursor = None
예제 #3
0
 def render(self, c):
     if c in self.canvas:
         return self.canvas[c]
     width, l = self.char[c]
     tl = []
     csl = []
     for d in l:
         t, cs = apply_target_encoding(d)
         tl.append(t)
         csl.append(cs)
     canv = TextCanvas(tl, None, csl, maxcol=width, check_width=False)
     self.canvas[c] = canv
     return canv
예제 #4
0
파일: font.py 프로젝트: anarchivist/pyflag
	def render(self, c):
		if c in self.canvas:
			return self.canvas[c]
		width, l = self.char[c]
		tl = []
		csl = []
		for d in l:
			t, cs = apply_target_encoding(d)
			tl.append(t)
			csl.append(cs)
		canv = TextCanvas(tl, None, csl, maxcol=width, 
			check_width=False)
		self.canvas[c] = canv
		return canv
예제 #5
0
파일: canvas.py 프로젝트: dlobue/urwid
def apply_text_layout(text, attr, ls, maxcol):
    t = []
    a = []
    c = []
    
    class AttrWalk:
        pass
    aw = AttrWalk
    aw.k = 0 # counter for moving through elements of a
    aw.off = 0 # current offset into text of attr[ak]
    
    def arange( start_offs, end_offs ):
        """Return an attribute list for the range of text specified."""
        if start_offs < aw.off:
            aw.k = 0
            aw.off = 0
        o = []
        while aw.off < end_offs:
            if len(attr)<=aw.k:
                # run out of attributes
                o.append((None,end_offs-max(start_offs,aw.off)))
                break
            at,run = attr[aw.k]
            if aw.off+run <= start_offs:
                # move forward through attr to find start_offs
                aw.k += 1
                aw.off += run
                continue
            if end_offs <= aw.off+run:
                o.append((at, end_offs-max(start_offs,aw.off)))
                break
            o.append((at, aw.off+run-max(start_offs, aw.off)))
            aw.k += 1
            aw.off += run
        return o

    
    for line_layout in ls:
        # trim the line to fit within maxcol
        line_layout = trim_line( line_layout, text, 0, maxcol )
        
        line = []
        linea = []
        linec = []
            
        def attrrange( start_offs, end_offs, destw ):
            """
            Add attributes based on attributes between
            start_offs and end_offs. 
            """
            if start_offs == end_offs:
                [(at,run)] = arange(start_offs,end_offs)
                rle_append_modify( linea, ( at, destw ))
                return
            if destw == end_offs-start_offs:
                for at, run in arange(start_offs,end_offs):
                    rle_append_modify( linea, ( at, run ))
                return
            # encoded version has different width
            o = start_offs
            for at, run in arange(start_offs, end_offs):
                if o+run == end_offs:
                    rle_append_modify( linea, ( at, destw ))
                    return
                tseg = text[o:o+run]
                tseg, cs = apply_target_encoding( tseg )
                segw = rle_len(cs)
                
                rle_append_modify( linea, ( at, segw ))
                o += run
                destw -= segw
            
            
        for seg in line_layout:
            #if seg is None: assert 0, ls
            s = LayoutSegment(seg)
            if s.end:
                tseg, cs = apply_target_encoding(
                    text[s.offs:s.end])
                line.append(tseg)
                attrrange(s.offs, s.end, rle_len(cs))
                rle_join_modify( linec, cs )
            elif s.text:
                tseg, cs = apply_target_encoding( s.text )
                line.append(tseg)
                attrrange( s.offs, s.offs, len(tseg) )
                rle_join_modify( linec, cs )
            elif s.offs:
                if s.sc:
                    line.append(" "*s.sc)
                    attrrange( s.offs, s.offs, s.sc )
            else:
                line.append(" "*s.sc)
                linea.append((None, s.sc))
                linec.append((None, s.sc))
            
        t.append("".join(line))
        a.append(linea)
        c.append(linec)
        
    return TextCanvas(t, a, c, maxcol=maxcol)