def main():
""" Main function. """
if len(sys.argv) < 3:
sys.stderr.write("Usage: %s <figfont file> <word>\n" \
% os.path.basename(sys.argv[0]))
sys.exit(2)
try:
cv = Canvas(0, 0)
except CanvasError as err:
sys.stderr.write("%s\n" % err)
sys.exit(2)
if cv.set_figfont(sys.argv[1]):
sys.stderr.write("Could not open font...\n")
sys.exit(2)
if sys.version_info[0:2] >= (3,0):
word = sys.argv[2]
else:
word = codecs.decode(sys.argv[2], "utf8")
for c in word:
cv.put_figchar(c)
sys.stderr.write(cv.export_to_memory("utf8"))
def test_create(self):
""" module canvas: Canvas.__init__()
"""
self.assertTrue(isinstance(Canvas(), Canvas))
self.assertTrue(isinstance(Canvas(10, 10), Canvas))
self.assertRaises(CanvasError, Canvas, "a", 12)
self.assertRaises(CanvasError, Canvas, 12, "a")
def test_remove_dirty_rect(self):
""" module canvas: Canvas.remove_dirty_rect()
"""
cv = Canvas(10, 10)
cv.add_dirty_rect(4, 4, 2, 2)
self.assertEqual(0, cv.remove_dirty_rect(4, 4, 2, 2))
self.assertRaises(CanvasError, cv.remove_dirty_rect, 11, 11, 20, 20)
def test_fill_box(self):
""" module canvas: Canvas.fill_box()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_box(0, 0, 2, 2, '#'))
self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, '#', '#')
self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, 2, 0)
def test_fill_ellipse(self):
""" module canvas: Canvas.fill_ellipse()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_ellipse(5, 5, 3, 3, '#'))
self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, '#', '#')
self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, 3, 0)
def test_enable_dirty_rect(self):
""" module canvas: Canvas.enable_dirty_rect()
"""
cv = Canvas()
self.assertRaises(CanvasError, cv.enable_dirty_rect)
cv.disable_dirty_rect()
self.assertEqual(0, cv.enable_dirty_rect())
def test_draw_thin_triangle(self):
""" module canvas: Canvas.draw_thin_triangle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.draw_thin_triangle(0, 0, 2, 2, 4, 0))
self.assertRaises(CanvasError, cv.draw_thin_triangle, 0, 0, 2, 2, 4,
'#')
def test_fill_ellipse(self):
""" module canvas: Canvas.fill_ellipse()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_ellipse(5, 5, 3, 3, '#'))
self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, '#', '#')
self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, 3, 0)
def test_draw_thin_line(self):
""" module canvas: Canvas.draw_thin_line()
"""
cv = Canvas(10, 1)
cv.draw_thin_line(0, 0, 10, 1)
self.assertEqual("-" * 10, cv.export_to_memory("utf8").strip('\n'))
self.assertRaises(CanvasError, cv.draw_thin_line, 0, "a", 10, 1)
def test_draw_circle(self):
""" module canvas: Canvas.draw_circle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.draw_circle(5, 5, 3, '#'))
self.assertRaises(CanvasError, cv.draw_circle, 0, 0, '#', '#')
self.assertRaises(CanvasError, cv.draw_circle, 0, 0, 3, 0)
def test_draw_thin_line(self):
""" module canvas: Canvas.draw_thin_line()
"""
cv = Canvas(10, 1)
cv.draw_thin_line(0, 0, 10, 1)
self.assertEqual("-" * 10, cv.export_to_memory("utf8").strip('\n'))
self.assertRaises(CanvasError, cv.draw_thin_line, 0, "a", 10, 1)
def test_draw_circle(self):
""" module canvas: Canvas.draw_circle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.draw_circle(5, 5, 3, '#'))
self.assertRaises(CanvasError, cv.draw_circle, 0, 0, '#', '#')
self.assertRaises(CanvasError, cv.draw_circle, 0, 0, 3, 0)
def test_remove_dirty_rect(self):
""" module canvas: Canvas.remove_dirty_rect()
"""
cv = Canvas(10, 10)
cv.add_dirty_rect(4, 4, 2, 2)
self.assertEqual(0, cv.remove_dirty_rect(4, 4, 2, 2))
self.assertRaises(CanvasError, cv.remove_dirty_rect, 11, 11, 20, 20)
def test_enable_dirty_rect(self):
""" module canvas: Canvas.enable_dirty_rect()
"""
cv = Canvas()
self.assertRaises(CanvasError, cv.enable_dirty_rect)
cv.disable_dirty_rect()
self.assertEqual(0, cv.enable_dirty_rect())
def test_fill_box(self):
""" module canvas: Canvas.fill_box()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_box(0, 0, 2, 2, '#'))
self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, '#', '#')
self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, 2, 0)
def test_draw_thin_triangle(self):
""" module canvas: Canvas.draw_thin_triangle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.draw_thin_triangle(0, 0, 2, 2, 4, 0))
self.assertRaises(CanvasError, cv.draw_thin_triangle,
0, 0, 2, 2, 4, '#')
def test_fill_triangle(self):
""" module canvas: Canvas.fill_triangle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_triangle(0, 0, 2, 2, 4, 0, '#'))
self.assertRaises(CanvasError, cv.fill_triangle, 0, 0, 2, 2, 4, '#',
'#')
self.assertRaises(CanvasError, cv.fill_triangle, 0, 0, 2, 2, 4, 0, 0)
def test_set_handle(self):
""" module canvas: Canvas.set_handle()
"""
cv = Canvas(10, 5)
self.assertEqual(0, cv.set_handle(3, 3))
self.assertEqual((3, 3), (cv.get_handle_x(), cv.get_handle_y()))
self.assertRaises(CanvasError, cv.set_handle, "a", 1)
self.assertRaises(CanvasError, cv.set_handle, 1, "a")
def test_set_handle(self):
""" module canvas: Canvas.set_handle()
"""
cv = Canvas(10, 5)
self.assertEqual(0, cv.set_handle(3, 3))
self.assertEqual((3, 3), (cv.get_handle_x(), cv.get_handle_y()))
self.assertRaises(CanvasError, cv.set_handle, "a", 1)
self.assertRaises(CanvasError, cv.set_handle, 1, "a")
def test_draw_thin_polyline(self):
""" module canvas: Canvas.draw_thin_polyline()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.draw_thin_polyline([(0, 0), (2, 2),
(5, 2), (0, 0)]))
self.assertRaises(CanvasError, cv.draw_thin_polyline, [])
self.assertRaises(CanvasError, cv.draw_thin_polyline, [0, 1, 2, 4])
def test_draw_thin_polyline(self):
""" module canvas: Canvas.draw_thin_polyline()
"""
cv = Canvas(10, 10)
self.assertEqual(
0, cv.draw_thin_polyline([(0, 0), (2, 2), (5, 2), (0, 0)]))
self.assertRaises(CanvasError, cv.draw_thin_polyline, [])
self.assertRaises(CanvasError, cv.draw_thin_polyline, [0, 1, 2, 4])
def test_gotoxy(self):
""" module canvas: Canvas.gotoxy()
"""
cv = Canvas(10, 10)
cv.gotoxy(5, 5)
self.assertEqual((5, 5), (cv.wherex(), cv.wherey()))
self.assertRaises(CanvasError, cv.gotoxy, "a", 9)
self.assertRaises(CanvasError, cv.gotoxy, 9, "a")
def test_set_size(self):
""" module canvas: Canvas.set_size()
"""
cv = Canvas(0, 0)
cv.set_size(1234, 1001)
self.assertEqual((1234, 1001), (cv.get_width(), cv.get_height()))
self.assertRaises(CanvasError, cv.set_size, "a", 12)
self.assertRaises(CanvasError, cv.set_size, 12, "a")
def test_fill_triangle(self):
""" module canvas: Canvas.fill_triangle()
"""
cv = Canvas(10, 10)
self.assertEqual(0, cv.fill_triangle(0, 0, 2, 2, 4, 0, '#'))
self.assertRaises(CanvasError, cv.fill_triangle,
0, 0, 2, 2, 4, '#', '#')
self.assertRaises(CanvasError, cv.fill_triangle,
0, 0, 2, 2, 4, 0, 0)
def test_put_char(self):
""" module canvas: Canvas.put_char()
"""
cv = Canvas(10, 1)
self.assertEqual(1, cv.put_char(0, 0, "z"))
self.assertEqual(1, cv.put_char(1, 0, "é"))
self.assertEqual("z", cv.get_char(0, 0))
self.assertEqual("é", cv.get_char(1, 0))
self.assertRaises(CanvasError, cv.put_char, "a", 1, 2)
self.assertRaises(CanvasError, cv.put_char, "a", 1, "b")
def test_put_char(self):
""" module canvas: Canvas.put_char()
"""
cv = Canvas(10, 1)
self.assertEqual(1, cv.put_char(0, 0, "z"))
self.assertEqual(1, cv.put_char(1, 0, "é"))
self.assertEqual("z", cv.get_char(0, 0))
self.assertEqual("é", cv.get_char(1, 0))
self.assertRaises(CanvasError, cv.put_char, "a", 1, 2)
self.assertRaises(CanvasError, cv.put_char, "a", 1, "b")
def main():
""" Main function. """
try:
pig = Canvas(0, 0)
pig.import_from_memory(STRING, "text")
cv = Canvas(pig.get_width() * 2, pig.get_height() * 2)
except CanvasError, err:
sys.stderr.write("%s\n" % err)
sys.exit(2)
def test_put_str(self):
""" module canvas: Canvas.put_str()
"""
cv = Canvas(10, 1)
self.assertEqual(10, cv.put_str(0, 0, "teststring"))
liststring = []
for i in range(0, 10):
liststring.append(cv.get_char(i, 0))
self.assertEqual("teststring", "".join(liststring))
self.assertRaises(CanvasError, cv.put_str, 0, 0, 111)
self.assertRaises(CanvasError, cv.put_str, 0, "z", "abc")
def test_printf(self):
""" module canvas: Canvas.printf()
"""
word1, word2 = "test", "string"
cv = Canvas(10, 1)
self.assertEqual(10, cv.printf(0, 0, "%s%s", word1, word2))
liststring = []
for i in range(0, 10):
liststring.append(cv.get_char(i, 0))
self.assertEqual("teststring", "".join(liststring))
self.assertRaises(CanvasError, cv.printf, 0, 0, 111)
self.assertRaises(CanvasError, cv.printf, 0, "z", "abc %s", "def")
def test_printf(self):
""" module canvas: Canvas.printf()
"""
word1, word2 = "test", "string"
cv = Canvas(10, 1)
self.assertEqual(10, cv.printf(0, 0, "%s%s", word1, word2))
liststring = []
for i in range(0, 10):
liststring.append(cv.get_char(i, 0))
self.assertEqual("teststring", "".join(liststring))
self.assertRaises(CanvasError, cv.printf, 0, 0, 111)
self.assertRaises(CanvasError, cv.printf, 0, "z", "abc %s", "def")
class State:
def __init__(self, settings):
red, green, blue, alpha = settings.masks
self.dit = Dither(settings.bpp, settings.img_size[0],
settings.img_size[1],
settings.depth * settings.img_size[0], red, green,
blue, alpha)
self.dit.set_algorithm(settings.dither.encode('ascii'))
self.dit.set_charset(b"utf8")
self.canvas = Canvas(settings.text_size[0], settings.text_size[1])
self.canvas.set_color_ansi(caca.COLOR_DEFAULT, caca.COLOR_TRANSPARENT)
self.settings = settings
self._buffer = bytearray([0] * (bpc * self.settings.total_chars))
caca_lib.caca_get_canvas_attrs.argtypes = [caca.canvas._Canvas]
caca_lib.caca_get_canvas_attrs.restype = ctypes.POINTER(
ctypes.c_uint32 * settings.total_chars)
caca_lib.caca_get_canvas_chars.argtypes = [caca.canvas._Canvas]
caca_lib.caca_get_canvas_chars.restype = ctypes.POINTER(
(ctypes.c_uint8 * 4) * settings.total_chars)
def add_frame(self, path, display=False):
img = Image.open(path)
if img.mode != self.settings.im_mode:
img = img.convert(self.settings.im_mode)
assert img.size == self.settings.img_size
self.dit.bitmap(self.canvas, 0, 0, self.settings.text_size[0],
self.settings.text_size[1], img.tobytes())
if display:
stderr.write("%s" % self.canvas.export_to_memory("utf8"))
offset = 0
attrs = caca_lib.caca_get_canvas_attrs(self.canvas).contents
chars = caca_lib.caca_get_canvas_chars(self.canvas).contents
for i in range(self.settings.total_chars):
attr = attrs[i]
char = chars[i]
char = bytearray(char).decode('utf-32-le')
info = load_char(attr, char)
encoded = info.save()
assert len(encoded) == bpc
for b in encoded:
self._buffer[offset] = b
offset += 1
self.canvas.clear()
return self._buffer
def __init__(self, app, spec, driver='gl'):
self.app = app
self.spec = spec
self.widgets = []
self.focus_order = None
self.parser = FileParser(self.app)
self.widgets = self.parser.parse(self.spec["widgets"])
self.canvas = Canvas(self.spec["app"]["width"],
self.spec["app"]["height"])
self.display = Display(self.canvas)
self.display.set_driver(driver)
if len(self.widgets) > 0:
self.focused_widget = self.widgets[0]
self.build_focus_order()
def get_canvas(self):
""" Get the canvas attached to a caca graphical context.
"""
_lib.caca_get_canvas.argtypes = [_Display]
_lib.caca_get_canvas.restype = ctypes.POINTER(ctypes.c_char_p)
return Canvas(pointer=_lib.caca_get_canvas(self))
def test_set_boundaries(self):
""" module canvas: Canvas.set_boundaries()
"""
cv = Canvas()
self.assertEqual(0, cv.set_boundaries(0, 0, 10, 10))
self.assertEqual((10, 10), (cv.get_width(), cv.get_height()))
self.assertEqual(0, cv.set_boundaries(0, 0, 5, 5))
self.assertEqual((5, 5), (cv.get_width(), cv.get_height()))
self.assertRaises(CanvasError, cv.set_boundaries, "a", 0, 10, 10)
self.assertRaises(CanvasError, cv.set_boundaries, 0, 0, "abc", 10)
def test_blit(self):
""" module canvas: Canvas.blit()
"""
cv1 = Canvas(10, 1)
cv2 = Canvas(10, 1)
cv2.put_str(0, 0, "teststring")
self.assertEqual(0, cv1.blit(0, 0, cv2))
self.assertEqual("teststring",
cv1.export_to_memory("utf8").strip('\n'))
self.assertRaises(CanvasError, cv1.blit, 0, 0, "abc")
self.assertRaises(CanvasError, cv1.blit, "a", 0, cv2)
def test_clear(self):
""" module canvas: Canvas.clear()
"""
cv = Canvas(5, 1)
cv.put_str(0, 0, "test!")
cv.clear()
data = cv.export_to_memory("utf8").strip('\n')
self.assertEqual(" ", data)
def __init__(self, *args, **kwargs):
"""
"""
KinematicServer.__init__(self, *args, **kwargs)
self.robots = [
r for (name, r) in self.elements.items() if isinstance(r, Robot)
]
self.cv = Canvas()
self.dp = Display(self.cv)
self.ev = Event()
self.quit = False
self.width = self.cv.get_width()
self.height = self.cv.get_height()
self.camera = Camera(self, 640, 480)
self.camera.translation = [3.5, 0, 1]
self.camera.init()
self.fps = -1.0
self.frames = 0
self.last_t = 0
def __init__(self, settings):
red, green, blue, alpha = settings.masks
self.dit = Dither(settings.bpp, settings.img_size[0],
settings.img_size[1],
settings.depth * settings.img_size[0], red, green,
blue, alpha)
self.dit.set_algorithm(settings.dither.encode('ascii'))
self.dit.set_charset(b"utf8")
self.canvas = Canvas(settings.text_size[0], settings.text_size[1])
self.canvas.set_color_ansi(caca.COLOR_DEFAULT, caca.COLOR_TRANSPARENT)
self.settings = settings
self._buffer = bytearray([0] * (bpc * self.settings.total_chars))
caca_lib.caca_get_canvas_attrs.argtypes = [caca.canvas._Canvas]
caca_lib.caca_get_canvas_attrs.restype = ctypes.POINTER(
ctypes.c_uint32 * settings.total_chars)
caca_lib.caca_get_canvas_chars.argtypes = [caca.canvas._Canvas]
caca_lib.caca_get_canvas_chars.restype = ctypes.POINTER(
(ctypes.c_uint8 * 4) * settings.total_chars)
def main():
""" Main function. """
if len(sys.argv) < 3:
sys.stderr.write("Usage: %s <figfont file> <word>\n" \
% os.path.basename(sys.argv[0]))
sys.exit(2)
try:
cv = Canvas(0, 0)
except CanvasError as err:
sys.stderr.write("%s\n" % err)
sys.exit(2)
if cv.set_figfont(sys.argv[1]):
sys.stderr.write("Could not open font...\n")
sys.exit(2)
if sys.version_info[0:2] >= (3, 0):
word = sys.argv[2]
else:
word = codecs.decode(sys.argv[2], "utf8")
for c in word:
cv.put_figchar(c)
sys.stderr.write(cv.export_to_memory("utf8"))
def test_gotoxy(self):
""" module canvas: Canvas.gotoxy()
"""
cv = Canvas(10, 10)
cv.gotoxy(5, 5)
self.assertEqual((5, 5), (cv.wherex(), cv.wherey()))
self.assertRaises(CanvasError, cv.gotoxy, "a", 9)
self.assertRaises(CanvasError, cv.gotoxy, 9, "a")
def test_set_size(self):
""" module canvas: Canvas.set_size()
"""
cv = Canvas(0, 0)
cv.set_size(1234, 1001)
self.assertEqual((1234, 1001), (cv.get_width(), cv.get_height()))
self.assertRaises(CanvasError, cv.set_size, "a", 12)
self.assertRaises(CanvasError, cv.set_size, 12, "a")
def __init__(self, app, spec):
self.app = app
self.initialize_spec_and_state(spec)
self.dirty = False
self.buffer = None
self.width = self.current_state["width"]
self.height = self.current_state["height"]
if self.specifies('name'):
self.name = spec["name"]
else:
self.name = "Unknown"
if self.specifies("height") and self.specifies("width"):
self.canvas = Canvas(spec["width"],
spec["height"])
self.canvas.set_color_ansi(caca.COLOR_WHITE, caca.COLOR_BLACK)
else:
self.canvas = Canvas(0, 0)
self.canvas.set_color_ansi(caca.COLOR_WHITE, caca.COLOR_BLACK)
logging.debug("Spec for widget:")
logging.debug(str(self.spec))
self.build_all()
class TartanDisplay(object):
def __init__(self, app, spec, driver='gl'):
self.app = app
self.spec = spec
self.widgets = []
self.focus_order = None
self.parser = FileParser(self.app)
self.widgets = self.parser.parse(self.spec["widgets"])
self.canvas = Canvas(self.spec["app"]["width"],
self.spec["app"]["height"])
self.display = Display(self.canvas)
self.display.set_driver(driver)
if len(self.widgets) > 0:
self.focused_widget = self.widgets[0]
self.build_focus_order()
def mark_dirty(self):
self.dirty = True
def mark_clean(self):
self.dirty = False
def build_focus_order(self):
self.focus_order = self.widgets
def refresh(self):
self.canvas.clear()
self.build_display()
self.display.refresh()
def blit(self, widget):
self.canvas.blit(widget.anchor[0], widget.anchor[1], widget.canvas)
def build_display(self):
self.canvas.clear()
for widget in self.widgets:
widget.draw()
self.blit(widget)
def main():
""" Main function. """
lst = caca.get_display_driver_list()
cur = 0
try:
cv = Canvas(0, 0)
dp = Display(cv)
except (CanvasError, DisplayError) as err:
sys.stderr.write("%s\n" % err)
sys.exit(127)
cv.set_color_ansi(caca.COLOR_WHITE, caca.COLOR_BLACK)
while True:
cv.put_str(1, 0, "Available drivers:")
cur_driver = dp.get_driver()
n = 0
for driver, desc in lst:
if driver == cur_driver:
cv.put_str(2, n + 2, "%s %s (%s)" % ('*', driver, desc))
else:
cv.put_str(2, n + 2, "%s %s (%s)" % (' ', driver, desc))
n += 1
cv.put_str(2, n + 3, "Switching driver in 5 seconds")
dp.refresh()
if dp.get_event(caca.EVENT_KEY_PRESS, Event(), 5000000):
break
cur += 1
if cur < len(lst) and lst[cur][0] == "raw":
cur += 1
if cur >= len(lst):
cur = 0
dp.set_driver(lst[cur][0])
cv.put_str(0, cv.get_height()-1, "generation: %d, population: %d" % (self.cycle, self.ca.population()))
cv.set_color_ansi(caca.COLOR_DEFAULT, caca.COLOR_BLACK)
posx = (cv.get_height() - self.height) // 2
posy = (cv.get_width() - self.width) // 2
for x in range(0, self.ca.height):
for y in range(0, self.ca.width):
if self.ca.get(x, y):
cv.put_str(posy+y, posx+x, "@")
def zeroCells(self):
for x in range(0, self.ca.height):
for y in range(0, self.ca.width):
self.ca.set(x, y, 0)
if __name__ == "__main__":
cv = Canvas()
dp = Display(cv)
ev = Event()
app = CellApp(80, 20)
app.zeroCells()
while True:
if dp.get_event(caca.EVENT_KEY_PRESS, ev, 2):
ch = ev.get_key_ch()
if ch == ord('q'):
break
elif ch == ord('s'):
app.auto = True
elif ch == ord('n'):
app.nextCycle()
if thin:
self.cv.draw_thin_ellipse(x, y, a, b)
else:
self.cv.draw_ellipse(x, y, a, b, '@')
def do_box(self, thin=False):
if thin:
self.cv.draw_thin_box(0, 0, self.cv.get_width(),
self.cv.get_height())
else:
self.cv.draw_box(0, 0, self.cv.get_width(), self.cv.get_height(),
'#')
if __name__ == "__main__":
cv = Canvas()
dp = Display(cv)
ev = Event()
draw = Drawing(cv)
while True:
cv.clear()
draw.do_menu()
dp.refresh()
if dp.get_event(caca.EVENT_KEY_PRESS, ev, 0):
ch = ev.get_key_ch()
cv.clear()
if ch == ord('q'):
sys.exit()
elif ch == ord('1'):
draw.do_line()
