font.py

Urwid is a Python library for making text console applications. It has many features including fluid

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Urwid BigText fonts
#    Copyright (C) 2004-2006  Ian Ward
#
#    This library is free software; you can redistribute it and/or
#    modify it under the terms of the GNU Lesser General Public
#    License as published by the Free Software Foundation; either
#    version 2.1 of the License, or (at your option) any later version.
#
#    This library is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#    Lesser General Public License for more details.
#
#    You should have received a copy of the GNU Lesser General Public
#    License along with this library; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# Urwid web site: http://excess.org/urwid/

from __future__ import nested_scopes

import re

from escape import utf8decode, SAFE_ASCII_DEC_SPECIAL_RE
from util import apply_target_encoding, str_util
from canvas import TextCanvas

try: True # old python?
except: False, True = 0, 1

def separate_glyphs(gdata, height):
	"""return (dictionary of glyphs, utf8 required)"""
	gl = gdata.split("\n")
	del gl[0]
	del gl[-1]
	for g in gl:
		assert "\t" not in g
	assert len(gl) == height+1, `gdata`
	key_line = gl[0]
	del gl[0]
	c = None # current character
	key_index = 0 # index into character key line
	end_col = 0 # column position at end of glyph
	start_col = 0 # column position at start of glyph
	jl = [0]*height # indexes into lines of gdata (gl)
	dout = {}
	utf8_required = False
	while True:
		if c is None:
			if key_index >= len(key_line):
				break
			c = key_line[key_index]
		if key_index < len(key_line) and key_line[key_index] == c:
			end_col += str_util.get_width(ord(c))
			key_index += 1
			continue
		out = []
		for k in range(height):
			l = gl[k]
			j = jl[k]
			y = 0
			fill = 0
			while y < end_col - start_col:
				if j >= len(l):
					fill = end_col - start_col - y
					break
				y += str_util.get_width(ord(l[j]))
				j += 1
			assert y + fill == end_col - start_col, \
				`y, fill, end_col`
			
			segment = l[jl[k]:j]
			if not SAFE_ASCII_DEC_SPECIAL_RE.match(segment):
				utf8_required = True
			
			out.append(segment + " " * fill)
			jl[k] = j

		start_col = end_col
		dout[c] = (y + fill, out)
		c = None
	return dout, utf8_required

_all_fonts = []
def get_all_fonts():
	"""
	Return a list of (font name, font class) tuples.
	"""
	return _all_fonts[:]

def add_font(name, cls):
	_all_fonts.append((name, cls))


class Font(object):
	def __init__(self):
		assert self.height
		assert self.data
		self.char = {}
		self.canvas = {}
		self.utf8_required = False
		for gdata in self.data:
			self.add_glyphs(gdata)
		

	def add_glyphs(self, gdata):
		d, utf8_required = separate_glyphs(gdata, self.height)
		self.char.update(d)
		self.utf8_required |= utf8_required

	def characters(self):
		l = self.char.keys()
		l.sort()
		return "".join(l)

	def char_width(self, c):
		if self.char.has_key(c):
			return self.char[c][0]
		return 0
	
	def char_data(self, c):
		return self.char[c][1]

	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
	

		
#safe_palette = utf8decode("鈹樷攼鈹屸敂鈹尖攢鈹溾敜鈹粹敩鈹