import nomadnet
import urwid
import random
import time
from urwid.util import is_mouse_press
from urwid.text_layout import calc_coords
import re
DEFAULT_FG_DARK = "ddd"
DEFAULT_FG_LIGHT = "222"
DEFAULT_BG = "default"
SELECTED_STYLES = None
STYLES_DARK = {
"plain": { "fg": DEFAULT_FG_DARK, "bg": DEFAULT_BG, "bold": False, "underline": False, "italic": False },
"heading1": { "fg": "222", "bg": "bbb", "bold": False, "underline": False, "italic": False },
"heading2": { "fg": "111", "bg": "999", "bold": False, "underline": False, "italic": False },
"heading3": { "fg": "000", "bg": "777", "bold": False, "underline": False, "italic": False },
}
STYLES_LIGHT = {
"plain": { "fg": DEFAULT_FG_LIGHT, "bg": DEFAULT_BG, "bold": False, "underline": False, "italic": False },
"heading1": { "fg": "000", "bg": "777", "bold": False, "underline": False, "italic": False },
"heading2": { "fg": "111", "bg": "aaa", "bold": False, "underline": False, "italic": False },
"heading3": { "fg": "222", "bg": "ccc", "bold": False, "underline": False, "italic": False },
}
SYNTH_STYLES = []
SYNTH_SPECS = {}
SECTION_INDENT = 2
INDENT_RIGHT = 1
def markup_to_attrmaps(markup, url_delegate = None):
global SELECTED_STYLES
if nomadnet.NomadNetworkApp.get_shared_instance().config["textui"]["theme"] == nomadnet.ui.TextUI.THEME_DARK:
SELECTED_STYLES = STYLES_DARK
else:
SELECTED_STYLES = STYLES_LIGHT
attrmaps = []
state = {
"literal": False,
"depth": 0,
"fg_color": SELECTED_STYLES["plain"]["fg"],
"bg_color": DEFAULT_BG,
"formatting": {
"bold": False,
"underline": False,
"italic": False,
"strikethrough": False,
"blink": False,
},
"default_align": "left",
"align": "left",
}
# Split entire document into lines for
# processing.
lines = markup.split("\n");
for line in lines:
if len(line) > 0:
display_widgets = parse_line(line, state, url_delegate)
else:
display_widgets = [urwid.Text("")]
if display_widgets != None and len(display_widgets) != 0:
for display_widget in display_widgets:
attrmap = urwid.AttrMap(display_widget, make_style(state))
attrmaps.append(attrmap)
return attrmaps
def parse_line(line, state, url_delegate):
if len(line) > 0:
first_char = line[0]
# Check for literals
if len(line) == 2 and line == "`=":
state["literal"] ^= True
return None
# Only parse content if not in literal state
if not state["literal"]:
# Check if the command is an escape
if first_char == "\\":
line = line[1:]
# Check for comments
elif first_char == "#":
return None
# Check for section heading reset
elif first_char == "<":
state["depth"] = 0
return parse_line(line[1:], state, url_delegate)
# Check for section headings
elif first_char == ">":
i = 0
while i < len(line) and line[i] == ">":
i += 1
state["depth"] = i
for j in range(1, i+1):
wanted_style = "heading"+str(i)
if wanted_style in SELECTED_STYLES:
style = SELECTED_STYLES[wanted_style]
line = line[state["depth"]:]
if len(line) > 0:
latched_style = state_to_style(state)
style_to_state(style, state)
heading_style = make_style(state)
output = make_output(state, line, url_delegate)
style_to_state(latched_style, state)
if len(output) > 0:
first_style = output[0][0]
heading_style = first_style
output.insert(0, " "*left_indent(state))
return [urwid.AttrMap(urwid.Text(output, align=state["align"]), heading_style)]
else:
return None
else:
return None
# Check for horizontal dividers
elif first_char == "-":
if len(line) == 2:
divider_char = line[1]
else:
divider_char = "\u2500"
if state["depth"] == 0:
return [urwid.Divider(divider_char)]
else:
return [urwid.Padding(urwid.Divider(divider_char), left=left_indent(state), right=right_indent(state))]
output = make_output(state, line, url_delegate)
if output != None:
text_only = True
for o in output:
if not isinstance(o, tuple):
text_only = False
break
if not text_only:
widgets = []
for o in output:
if isinstance(o, tuple):
if url_delegate != None:
tw = LinkableText(o, align=state["align"], delegate=url_delegate)
tw.in_columns = True
else:
tw = urwid.Text(o, align=state["align"])
widgets.append(("pack", tw))
else:
if o["type"] == "field":
fw = o["width"]
fd = o["data"]
fn = o["name"]
fs = o["style"]
fmask = "*" if o["masked"] else None
f = urwid.Edit(caption="", edit_text=fd, align=state["align"], multiline=True, mask=fmask)
f.field_name = fn
fa = urwid.AttrMap(f, fs)
widgets.append((fw, fa))
columns_widget = urwid.Columns(widgets, dividechars=0)
text_widget = columns_widget
# text_widget = urwid.Text("<"+output+">", align=state["align"])
else:
if url_delegate != None:
text_widget = LinkableText(output, align=state["align"], delegate=url_delegate)
else:
text_widget = urwid.Text(output, align=state["align"])
if state["depth"] == 0:
return [text_widget]
else:
return [urwid.Padding(text_widget, left=left_indent(state), right=right_indent(state))]
else:
return None
else:
return None
def left_indent(state):
return (state["depth"]-1)*SECTION_INDENT
def right_indent(state):
return (state["depth"]-1)*SECTION_INDENT
def make_part(state, part):
return (make_style(state), part)
def state_to_style(state):
return { "fg": state["fg_color"], "bg": state["bg_color"], "bold": state["formatting"]["bold"], "underline": state["formatting"]["underline"], "italic": state["formatting"]["italic"] }
def style_to_state(style, state):
if style["fg"] != None:
state["fg_color"] = style["fg"]
if style["bg"] != None:
state["bg_color"] = style["bg"]
if style["bold"] != None:
state["formatting"]["bold"] = style["bold"]
if style["underline"] != None:
state["formatting"]["underline"] = style["underline"]
if style["italic"] != None:
state["formatting"]["italic"] = style["italic"]
def make_style(state):
def mono_color(fg, bg):
return "default"
def low_color(color):
try:
result = "default"
if color == "default":
result = "default"
elif len(color) == 6:
r = str(color[0])
g = str(color[2])
b = str(color[4])
color = r+g+b
if len(color) == 3:
t = 7
if color[0] == "g":
val = int(color[1:2])
if val < 25:
result = "black"
elif val < 50:
result = "dark gray"
elif val < 75:
result = "light gray"
else:
result = "white"
else:
r = int(color[0], 16)
g = int(color[1], 16)
b = int(color[2], 16)
if r == g == b:
val = int(color[0], 16)*6
if val < 12:
result = "black"
elif val < 50:
result = "dark gray"
elif val < 80:
result = "light gray"
else:
result = "white"
else:
if r == b:
if r > g:
if r > t:
result = "light magenta"
else:
result = "dark magenta"
else:
if g > t:
result = "light green"
else:
result = "dark green"
if b == g:
if b > r:
if b > t:
result = "light cyan"
else:
result = "dark cyan"
else:
if r > t:
result = "light red"
else:
result = "dark red"
if g == r:
if g > b:
if g > t:
result = "yellow"
else:
result = "brown"
else:
if b > t:
result = "light blue"
else:
result = "dark blue"
if r > g and r > b:
if r > t:
result = "light red"
else:
result = "dark red"
if g > r and g > b:
if g > t:
result = "light green"
else:
result = "dark green"
if b > g and b > r:
if b > t:
result = "light blue"
else:
result = "dark blue"
except Exception as e:
result = "default"
return result
def high_color(color):
def parseval_hex(char):
return hex(max(0,min(int(char, 16),16)))[2:]
def parseval_dec(char):
return str(max(0,min(int(char), 9)))
if color == "default":
return "default"
else:
if len(color) == 6:
try:
v1 = parseval_hex(color[0])
v2 = parseval_hex(color[1])
v3 = parseval_hex(color[2])
v4 = parseval_hex(color[3])
v5 = parseval_hex(color[4])
v6 = parseval_hex(color[5])
color = "#"+v1+v2+v3+v4+v5+v6
except Exception as e:
return "default"
return color
elif len(color) == 3:
if color[0] == "g":
try:
v1 = parseval_dec(color[1])
v2 = parseval_dec(color[2])
except Exception as e:
return "default"
return "g"+v1+v2
else:
try:
v1 = parseval_hex(color[0])
v2 = parseval_hex(color[1])
v3 = parseval_hex(color[2])
color = v1+v2+v3
except Exception as e:
return "default"
r = color[0]
g = color[1]
b = color[2]
return "#"+r+r+g+g+b+b
bold = state["formatting"]["bold"]
underline = state["formatting"]["underline"]
italic = state["formatting"]["italic"]
fg = state["fg_color"]
bg = state["bg_color"]
format_string = ""
if bold:
format_string += ",bold"
if underline:
format_string += ",underline"
if italic:
format_string += ",italics"
name = "micron_"+fg+"_"+bg+"_"+format_string
if not name in SYNTH_STYLES:
screen = nomadnet.NomadNetworkApp.get_shared_instance().ui.screen
screen.register_palette_entry(name, low_color(fg)+format_string,low_color(bg),mono_color(fg, bg)+format_string,high_color(fg)+format_string,high_color(bg))
synth_spec = screen._palette[name]
SYNTH_STYLES.append(name)
if not name in SYNTH_SPECS:
SYNTH_SPECS[name] = synth_spec
return name
def make_output(state, line, url_delegate):
output = []
if state["literal"]:
if line == "\\`=":
line = "`="
output.append(make_part(state, line))
else:
part = ""
mode = "text"
escape = False
skip = 0
for i in range(0, len(line)):
c = line[i]
if skip > 0:
skip -= 1
else:
if mode == "formatting":
if c == "_":
state["formatting"]["underline"] ^= True
elif c == "!":
state["formatting"]["bold"] ^= True
elif c == "*":
state["formatting"]["italic"] ^= True
elif c == "F":
if len(line) >= i+4:
color = line[i+1:i+4]
state["fg_color"] = color
skip = 3
elif c == "f":
state["fg_color"] = SELECTED_STYLES["plain"]["fg"]
elif c == "B":
if len(line) >= i+4:
color = line[i+1:i+4]
state["bg_color"] = color
skip = 3
elif c == "b":
state["bg_color"] = DEFAULT_BG
elif c == "`":
state["formatting"]["bold"] = False
state["formatting"]["underline"] = False
state["formatting"]["italic"] = False
state["fg_color"] = SELECTED_STYLES["plain"]["fg"]
state["bg_color"] = DEFAULT_BG
state["align"] = state["default_align"]
elif c == "c":
if state["align"] != "center":
state["align"] = "center"
else:
state["align"] = state["default_align"]
elif c == "l":
if state["align"] != "left":
state["align"] = "left"
else:
state["align"] = state["default_align"]
elif c == "r":
if state["align"] != "right":
state["align"] = "right"
else:
state["align"] = state["default_align"]
elif c == "a":
state["align"] = state["default_align"]
elif c == "<":
try:
field_name = None
field_name_end = line[i:].find("`")
if field_name_end == -1:
pass
else:
field_name = line[i+1:i+field_name_end]
field_name_skip = len(field_name)
field_masked = False
field_width = 24
if "|" in field_name:
f_components = field_name.split("|")
field_flags = f_components[0]
field_name = f_components[1]
if "!" in field_flags:
field_flags = field_flags.replace("!", "")
field_masked = True
if len(field_flags) > 0:
field_width = min(int(field_flags), 256)
def sr():
return "@{"+str(random.randint(1000,9999))+"}"
rsg = sr()
while rsg in line[i+field_name_end:]:
rsg = sr()
lr = line[i+field_name_end:].replace("\\>", rsg)
endpos = lr.find(">")
if endpos == -1:
pass
else:
field_data = lr[1:endpos].replace(rsg, "\\>")
skip = len(field_data)+field_name_skip+2
field_data = field_data.replace("\\>", ">")
output.append({
"type":"field",
"name": field_name,
"width": field_width,
"masked": field_masked,
"data": field_data,
"style": make_style(state)
})
except Exception as e:
pass
elif c == "[":
endpos = line[i:].find("]")
if endpos == -1:
pass
else:
link_data = line[i+1:i+endpos]
skip = endpos
link_components = link_data.split("`")
if len(link_components) == 1:
link_label = ""
link_fields = ""
link_url = link_data
elif len(link_components) == 2:
link_label = link_components[0]
link_url = link_components[1]
link_fields = ""
elif len(link_components) == 3:
link_label = link_components[0]
link_url = link_components[1]
link_fields = link_components[2]
else:
link_url = ""
link_label = ""
link_fields = ""
if len(link_url) != 0:
if link_label == "":
link_label = link_url
# First generate output until now
if len(part) > 0:
output.append(make_part(state, part))
cm = nomadnet.NomadNetworkApp.get_shared_instance().ui.colormode
specname = make_style(state)
speclist = SYNTH_SPECS[specname]
if cm == 1:
orig_spec = speclist[0]
elif cm == 16:
orig_spec = speclist[1]
elif cm == 88:
orig_spec = speclist[2]
elif cm == 256:
orig_spec = speclist[3]
elif cm == 2**24:
orig_spec = speclist[4]
if url_delegate != None:
linkspec = LinkSpec(link_url, orig_spec)
if link_fields != "":
lf = link_fields.split("|")
if len(lf) > 0:
linkspec.link_fields = lf
output.append((linkspec, link_label))
else:
output.append(make_part(state, link_label))
mode = "text"
if len(part) > 0:
output.append(make_part(state, part))
elif mode == "text":
if c == "\\":
if escape:
part += c
escape = False
else:
escape = True
elif c == "`":
if escape:
part += c
escape = False
else:
mode = "formatting"
if len(part) > 0:
output.append(make_part(state, part))
part = ""
else:
part += c
if i == len(line)-1:
if len(part) > 0:
output.append(make_part(state, part))
if len(output) > 0:
return output
else:
return None
class LinkSpec(urwid.AttrSpec):
def __init__(self, link_target, orig_spec):
self.link_target = link_target
self.link_fields = None
urwid.AttrSpec.__init__(self, orig_spec.foreground, orig_spec.background)
class LinkableText(urwid.Text):
ignore_focus = False
_selectable = True
signals = ["click", "change"]
def __init__(self, text, align=None, cursor_position=0, delegate=None):
self.__super.__init__(text, align=align)
self.delegate = delegate
self._cursor_position = 0
self.key_timeout = 3
self.in_columns = False
if self.delegate != None:
self.delegate.last_keypress = 0
def handle_link(self, link_target, link_fields):
if self.delegate != None:
self.delegate.handle_link(link_target, link_fields)
def find_next_part_pos(self, pos, part_positions):
for position in part_positions:
if position > pos:
return position
return pos
def find_prev_part_pos(self, pos, part_positions):
nextpos = pos
for position in part_positions:
if position < pos:
nextpos = position
return nextpos
def find_item_at_pos(self, pos):
total = 0
text, parts = self.get_text()
for i, info in enumerate(parts):
style, length = info
if total <= pos < length+total:
return style
total += length
return None
def peek_link(self):
item = self.find_item_at_pos(self._cursor_position)
if item != None:
if isinstance(item, LinkSpec):
if self.delegate != None:
self.delegate.marked_link(item.link_target)
else:
if self.delegate != None:
self.delegate.marked_link(None)
def keypress(self, size, key):
part_positions = [0]
parts = []
total = 0
text, parts = self.get_text()
for i, info in enumerate(parts):
style_name, length = info
part_positions.append(length+total)
total += length
if self.delegate != None:
self.delegate.last_keypress = time.time()
self._invalidate()
nomadnet.NomadNetworkApp.get_shared_instance().ui.loop.set_alarm_in(self.key_timeout, self.kt_event)
if self._command_map[key] == urwid.ACTIVATE:
item = self.find_item_at_pos(self._cursor_position)
if item != None:
if isinstance(item, LinkSpec):
self.handle_link(item.link_target, item.link_fields)
elif key == "up":
self._cursor_position = 0
return key
elif key == "down":
self._cursor_position = 0
return key
elif key == "right":
old = self._cursor_position
self._cursor_position = self.find_next_part_pos(self._cursor_position, part_positions)
if self._cursor_position == old:
if self.in_columns:
return "right"
else:
self._cursor_position = 0
return "down"
self._invalidate()
elif key == "left":
if self._cursor_position > 0:
if self.in_columns:
return "left"
else:
self._cursor_position = self.find_prev_part_pos(self._cursor_position, part_positions)
self._invalidate()
else:
if self.delegate != None:
self.delegate.micron_released_focus()
else:
return key
def kt_event(self, loop, user_data):
self._invalidate()
def render(self, size, focus=False):
now = time.time()
c = self.__super.render(size, focus)
if focus and (self.delegate == None or now < self.delegate.last_keypress+self.key_timeout):
c = urwid.CompositeCanvas(c)
c.cursor = self.get_cursor_coords(size)
if self.delegate != None:
self.peek_link()
return c
def get_cursor_coords(self, size):
if self._cursor_position > len(self.text):
return None
(maxcol,) = size
trans = self.get_line_translation(maxcol)
x, y = calc_coords(self.text, trans, self._cursor_position)
if maxcol <= x:
return None
return x, y
def mouse_event(self, size, event, button, x, y, focus):
if button != 1 or not is_mouse_press(event):
return False
else:
(maxcol,) = size
translation = self.get_line_translation(maxcol)
line_offset = 0
if self.align == "center":
line_offset = translation[y][1][1]-translation[y][0][0]
if x < translation[y][0][0]:
x = translation[y][0][0]
if x > translation[y][1][0]+translation[y][0][0]:
x = translation[y][1][0]+translation[y][0][0]
elif self.align == "right":
line_offset = translation[y][1][1]-translation[y][0][0]
if x < translation[y][0][0]:
x = translation[y][0][0]
else:
line_offset = translation[y][0][1]
if x > translation[y][0][0]:
x = translation[y][0][0]
pos = line_offset+x
self._cursor_position = pos
item = self.find_item_at_pos(self._cursor_position)
if item != None:
if isinstance(item, LinkSpec):
self.handle_link(item.link_target, item.link_fields)
self._invalidate()
self._emit("change")
return True