def paint_last_events(rows, columns, names):
if not names:
return fsarray([])
width = min(max(len(name) for name in names), columns-2)
output_lines = []
output_lines.append(u'┌'+u'─'*width+u'┐')
for name in names[-(rows-2):]:
output_lines.append(u'│'+name[:width].center(width)+u'│')
output_lines.append(u'└'+u'─'*width+u'┘')
return fsarray(output_lines)
def test_len_of_unicode(self):
self.assertEqual(len(fmtstr(u'┌─')), 2)
lines = [u'┌─', 'an', u'┌─']
r = fsarray(lines)
self.assertEqual(r.shape, (3, 2))
self.assertEqual(len(fmtstr(fmtstr(u'┌─'))), len(fmtstr(u'┌─')))
self.assertEqual(fmtstr(fmtstr(u'┌─')), fmtstr(u'┌─'))
def fit(fs_array, fs_arrays, border=True):
if border:
fs_arrays = [fsarray(['+'+'-'*fsa.width+'+'] +
['|'+line+'|' for line in fsa.rows] +
['+'+'-'*fsa.width+'+'])
for fsa in fs_arrays]
for fsa in fs_arrays:
if fsa.width > fs_array.width:
raise ValueError("input array won't fit inside composite array")
top_free = [0] * fs_array.width
def fits(fsa, row, col):
if fsa.width > len(top_free) - col: return False
return all(top_free[col] <= r for r in range(row, row+fsa.width))
cur_fsa = fs_arrays.pop(0)
for row, col in ((row, col) for row in xrange(1000000) for col in range(fs_array.width)):
if fits(cur_fsa, row, col):
fs_array[row:row+cur_fsa.height, col:col+cur_fsa.width] = cur_fsa
for col in range(col, col+cur_fsa.width):
top_free[col] += cur_fsa.height
if not fs_arrays:
return
cur_fsa = fs_arrays.pop(0)
def paint_history(rows, columns, display_lines):
lines = []
for r, line in zip(range(rows), display_lines[-rows:]):
lines.append(fmtstr(line[:columns]))
r = fsarray(lines, width=columns)
assert r.shape[0] <= rows, repr(r.shape)+' '+repr(rows)
assert r.shape[1] <= columns, repr(r.shape)+' '+repr(columns)
return r
def paint_infobox(rows, columns, matches, argspec, match, docstring, config):
"""Returns painted completions, argspec, match, docstring etc."""
if not (rows and columns):
return fsarray(0, 0)
width = columns - 4
lines = ((formatted_argspec(argspec, width, config) if argspec else []) +
(matches_lines(rows, width, matches, match, config) if matches else []) +
(formatted_docstring(docstring, width, config) if docstring else []))
output_lines = []
border_color = func_for_letter(config.color_scheme['main'])
output_lines.append(border_color(u'┌─'+u'─'*width+u'─┐'))
for line in lines:
output_lines.append(border_color(u'│ ')+((line+' '*(width - len(line)))[:width])+border_color(u' │'))
output_lines.append(border_color(u'└─'+u'─'*width+u'─┘'))
r = fsarray(output_lines[:min(rows-1, len(output_lines)-1)] + output_lines[-1:])
return r
def get_array(self, path=[]):
h_space = 2
v_space = 1
line = lambda p1, p2: p1 in path and p2 in path and abs(path.index(p1) - path.index(p2)) == 1
def color(num): return lambda s: bold([magenta, blue, red, green, yellow][num](s))
lines = [''] * v_space
for y, row in enumerate(self.rows):
lines.append(' '*h_space)
space = ' '*h_space
for x, dot in enumerate(row):
lines[-1] += color(dot)(u'\u25cf')
if line((x, y), (x+1, y)):
lines[-1] += color(dot)('--')
else:
lines[-1] += (' ')
if line((x, y), (x, y+1)):
space += color(dot)('|'+' '*h_space)
else:
space += ' '*(1+h_space)
[lines.append(space) for _ in range(v_space)]
return fsarray(lines)
def paint_current_line(rows, columns, current_display_line):
lines = display_linize(current_display_line, columns, True)
return fsarray(lines, width=columns)
def paint_statusbar(rows, columns, msg, config):
return fsarray([func_for_letter(config.color_scheme['main'])(msg.ljust(columns))[:columns]])
def display(self):
colored = {' ':' ', 'x':blue(bold('x')), 'o':red(bold('o'))}
s = ('\n'+green('-')*(len(self.columns)*2-1) + '\n').join([green('|').join(colored[mark] for mark in row) for row in self._rows])
a = fsarray([bold(green('enter a number, 0-8' if self.whose_turn == 'x' else 'wait for computer...'))] + s.split('\n'))
return a
