diff options
Diffstat (limited to 'src/windows')
| -rw-r--r-- | src/windows/__init__.py | 17 | ||||
| -rw-r--r-- | src/windows/base_wins.py | 168 | ||||
| -rw-r--r-- | src/windows/funcs.py | 56 | ||||
| -rw-r--r-- | src/windows/info_bar.py | 109 | ||||
| -rw-r--r-- | src/windows/info_wins.py | 301 | ||||
| -rw-r--r-- | src/windows/input_placeholders.py | 78 | ||||
| -rw-r--r-- | src/windows/inputs.py | 764 | ||||
| -rw-r--r-- | src/windows/list.py | 237 | ||||
| -rw-r--r-- | src/windows/misc.py | 61 | ||||
| -rw-r--r-- | src/windows/muc.py | 127 | ||||
| -rw-r--r-- | src/windows/roster_win.py | 385 | ||||
| -rw-r--r-- | src/windows/text_win.py | 438 |
12 files changed, 2741 insertions, 0 deletions
diff --git a/src/windows/__init__.py b/src/windows/__init__.py new file mode 100644 index 00000000..9d7172c5 --- /dev/null +++ b/src/windows/__init__.py @@ -0,0 +1,17 @@ +""" +Module exporting all the Windows, which are wrappers around curses wins +used to display information on the screen +""" +from . base_wins import Win, g_lock +from . info_bar import GlobalInfoBar, VerticalGlobalInfoBar +from . info_wins import InfoWin, XMLInfoWin, PrivateInfoWin, MucListInfoWin, \ + ConversationInfoWin, DynamicConversationInfoWin, MucInfoWin, \ + ConversationStatusMessageWin +from . input_placeholders import HelpText, YesNoInput +from . inputs import Input, HistoryInput, MessageInput, CommandInput +from . list import ListWin, ColumnHeaderWin +from . misc import VerticalSeparator +from . muc import UserList, Topic +from . roster_win import RosterWin, ContactInfoWin +from . text_win import TextWin + diff --git a/src/windows/base_wins.py b/src/windows/base_wins.py new file mode 100644 index 00000000..44c62e91 --- /dev/null +++ b/src/windows/base_wins.py @@ -0,0 +1,168 @@ +""" +Define the base window object and the constants/"globals" used +by the file of this module. + +A window is a little part of the screen, for example the input window, +the text window, the roster window, etc. +A Tab (see the src/tabs module) is composed of multiple Windows +""" + +import logging +log = logging.getLogger(__name__) + +import collections +import curses +import string +from threading import RLock + +import core +import singleton +from theming import to_curses_attr, read_tuple + +FORMAT_CHAR = '\x19' +# These are non-printable chars, so they should never appear in the input, +# I guess. But maybe we can find better chars that are even less risky. +format_chars = ['\x0E', '\x0F', '\x10', '\x11', '\x12', '\x13', + '\x14', '\x15', '\x16', '\x17', '\x18'] + +# different colors allowed in the input +allowed_color_digits = ('0', '1', '2', '3', '4', '5', '6', '7') + +# msg is a reference to the corresponding Message tuple. text_start and +# text_end are the position delimiting the text in this line. +Line = collections.namedtuple('Line', 'msg start_pos end_pos prepend') + +g_lock = RLock() + +LINES_NB_LIMIT = 4096 + +class DummyWin(object): + def __getattribute__(self, name): + if name != '__bool__': + return lambda *args, **kwargs: (0, 0) + else: + return object.__getattribute__(self, name) + + def __bool__(self): + return False + +class Win(object): + _win_core = None + _tab_win = None + def __init__(self): + self._win = None + self.height, self.width = 0, 0 + + def _resize(self, height, width, y, x): + if height == 0 or width == 0: + self.height, self.width = height, width + return + self.height, self.width, self.x, self.y = height, width, x, y + try: + self._win = Win._tab_win.derwin(height, width, y, x) + except: + log.debug('DEBUG: mvwin returned ERR. Please investigate') + if self._win is None: + self._win = DummyWin() + + def resize(self, height, width, y, x): + """ + Override if something has to be done on resize + """ + with g_lock: + self._resize(height, width, y, x) + + def _refresh(self): + self._win.noutrefresh() + + def addnstr(self, *args): + """ + Safe call to addnstr + """ + try: + self._win.addnstr(*args) + except: + # this actually mostly returns ERR, but works. + # more specifically, when the added string reaches the end + # of the screen. + pass + + def addstr(self, *args): + """ + Safe call to addstr + """ + try: + self._win.addstr(*args) + except: + pass + + def move(self, y, x): + try: + self._win.move(y, x) + except: + self._win.move(0, 0) + + def addstr_colored(self, text, y=None, x=None): + """ + Write a string on the window, setting the + attributes as they are in the string. + For example: + \x19bhello → hello in bold + \x191}Bonj\x192}our → 'Bonj' in red and 'our' in green + next_attr_char is the \x19 delimiter + attr_char is the char following it, it can be + one of 'u', 'b', 'c[0-9]' + """ + if y is not None and x is not None: + self.move(y, x) + next_attr_char = text.find(FORMAT_CHAR) + while next_attr_char != -1 and text: + if next_attr_char + 1 < len(text): + attr_char = text[next_attr_char+1].lower() + else: + attr_char = str() + if next_attr_char != 0: + self.addstr(text[:next_attr_char]) + if attr_char == 'o': + self._win.attrset(0) + elif attr_char == 'u': + self._win.attron(curses.A_UNDERLINE) + elif attr_char == 'b': + self._win.attron(curses.A_BOLD) + if (attr_char in string.digits or attr_char == '-') and attr_char != '': + color_str = text[next_attr_char+1:text.find('}', next_attr_char)] + if ',' in color_str: + tup, char = read_tuple(color_str) + self._win.attron(to_curses_attr(tup)) + if char: + if char == 'o': + self._win.attrset(0) + elif char == 'u': + self._win.attron(curses.A_UNDERLINE) + elif char == 'b': + self._win.attron(curses.A_BOLD) + elif color_str: + self._win.attron(to_curses_attr((int(color_str), -1))) + text = text[next_attr_char+len(color_str)+2:] + else: + text = text[next_attr_char+2:] + next_attr_char = text.find(FORMAT_CHAR) + self.addstr(text) + + def finish_line(self, color=None): + """ + Write colored spaces until the end of line + """ + (y, x) = self._win.getyx() + size = self.width - x + if color: + self.addnstr(' '*size, size, to_curses_attr(color)) + else: + self.addnstr(' '*size, size) + + @property + def core(self): + if not Win._win_core: + Win._win_core = singleton.Singleton(core.Core) + return Win._win_core + diff --git a/src/windows/funcs.py b/src/windows/funcs.py new file mode 100644 index 00000000..47011faf --- /dev/null +++ b/src/windows/funcs.py @@ -0,0 +1,56 @@ +""" +Standalone functions used by the modules +""" + +import string + +from config import config +from . base_wins import FORMAT_CHAR, format_chars + +def find_first_format_char(text, chars=None): + if chars is None: + chars = format_chars + pos = -1 + for char in chars: + p = text.find(char) + if p == -1: + continue + if pos == -1 or p < pos: + pos = p + return pos + +def truncate_nick(nick, size=None): + size = size or config.get('max_nick_length', 25) + if size < 1: + size = 1 + if nick and len(nick) > size: + return nick[:size]+'…' + return nick + +def parse_attrs(text, previous=None): + next_attr_char = text.find(FORMAT_CHAR) + if previous: + attrs = previous + else: + attrs = [] + while next_attr_char != -1 and text: + if next_attr_char + 1 < len(text): + attr_char = text[next_attr_char+1].lower() + else: + attr_char = str() + if attr_char == 'o': + attrs = [] + elif attr_char == 'u': + attrs.append('u') + elif attr_char == 'b': + attrs.append('b') + if attr_char in string.digits and attr_char != '': + color_str = text[next_attr_char+1:text.find('}', next_attr_char)] + if color_str: + attrs.append(color_str + '}') + text = text[next_attr_char+len(color_str)+2:] + else: + text = text[next_attr_char+2:] + next_attr_char = text.find(FORMAT_CHAR) + return attrs + diff --git a/src/windows/info_bar.py b/src/windows/info_bar.py new file mode 100644 index 00000000..9917fa6a --- /dev/null +++ b/src/windows/info_bar.py @@ -0,0 +1,109 @@ +""" +Module defining the global info bar + +This window is the one listing the current opened tabs in poezio. +The GlobalInfoBar can be either horizontal or vertical +(VerticalGlobalInfoBar). +""" +import logging +log = logging.getLogger(__name__) + +import curses + + +from config import config +from . import Win, g_lock +from theming import get_theme, to_curses_attr + +class GlobalInfoBar(Win): + def __init__(self): + Win.__init__(self) + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + self.addstr(0, 0, "[", to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + create_gaps = config.get('create_gaps', False) + show_names = config.get('show_tab_names', False) + show_nums = config.get('show_tab_numbers', True) + use_nicks = config.get('use_tab_nicks', True) + # ignore any remaining gap tabs if the feature is not enabled + if create_gaps: + sorted_tabs = self.core.tabs[:] + else: + sorted_tabs = [tab for tab in self.core.tabs if tab] + + for nb, tab in enumerate(sorted_tabs): + if not tab: continue + color = tab.color + if not config.get('show_inactive_tabs', True) and\ + color is get_theme().COLOR_TAB_NORMAL: + continue + try: + if show_nums or not show_names: + self.addstr("%s" % str(nb), to_curses_attr(color)) + if show_names: + self.addstr(' ', to_curses_attr(color)) + if show_names: + if use_nicks: + self.addstr("%s" % str(tab.get_nick()), to_curses_attr(color)) + else: + self.addstr("%s" % tab.name, to_curses_attr(color)) + self.addstr("|", to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + except: # end of line + break + (y, x) = self._win.getyx() + self.addstr(y, x-1, '] ', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + (y, x) = self._win.getyx() + remaining_size = self.width - x + self.addnstr(' '*remaining_size, remaining_size, + to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self._refresh() + +class VerticalGlobalInfoBar(Win): + def __init__(self, scr): + Win.__init__(self) + self._win = scr + + def refresh(self): + with g_lock: + height, width = self._win.getmaxyx() + self._win.erase() + sorted_tabs = [tab for tab in self.core.tabs if tab] + if not config.get('show_inactive_tabs', True): + sorted_tabs = [tab for tab in sorted_tabs if\ + tab.vertical_color != get_theme().COLOR_VERTICAL_TAB_NORMAL] + nb_tabs = len(sorted_tabs) + use_nicks = config.get('use_tab_nicks', True) + if nb_tabs >= height: + for y, tab in enumerate(sorted_tabs): + if tab.vertical_color == get_theme().COLOR_VERTICAL_TAB_CURRENT: + pos = y + break + # center the current tab as much as possible + if pos < height//2: + sorted_tabs = sorted_tabs[:height] + elif nb_tabs - pos <= height//2: + sorted_tabs = sorted_tabs[-height:] + else: + sorted_tabs = sorted_tabs[pos-height//2 : pos+height//2] + for y, tab in enumerate(sorted_tabs): + color = tab.vertical_color + + if not config.get('vertical_tab_list_sort', 'desc') != 'asc': + y = height - y - 1 + self.addstr(y, 0, "%2d" % tab.nb, + to_curses_attr(get_theme().COLOR_VERTICAL_TAB_NUMBER)) + self.addstr('.') + if use_nicks: + self.addnstr("%s" % tab.get_nick(), width - 4, to_curses_attr(color)) + else: + self.addnstr("%s" % tab.name, width - 4, to_curses_attr(color)) + separator = to_curses_attr(get_theme().COLOR_VERTICAL_SEPARATOR) + self._win.attron(separator) + self._win.vline(0, width-1, curses.ACS_VLINE, height) + self._win.attroff(separator) + self._refresh() + diff --git a/src/windows/info_wins.py b/src/windows/info_wins.py new file mode 100644 index 00000000..7c659a6c --- /dev/null +++ b/src/windows/info_wins.py @@ -0,0 +1,301 @@ +""" +Module defining all the "info wins", ie the bar which is on top of the +info buffer in normal tabs +""" + +import logging +log = logging.getLogger(__name__) + +from common import safeJID + +from . import Win, g_lock +from . funcs import truncate_nick +from theming import get_theme, to_curses_attr + +class InfoWin(Win): + """ + Base class for all the *InfoWin, used in various tabs. For example + MucInfoWin, etc. Provides some useful methods. + """ + def __init__(self): + Win.__init__(self) + + def print_scroll_position(self, window): + """ + Print, like in Weechat, a -MORE(n)- where n + is the number of available lines to scroll + down + """ + if window.pos > 0: + plus = ' -MORE(%s)-' % window.pos + self.addstr(plus, to_curses_attr(get_theme().COLOR_SCROLLABLE_NUMBER)) + +class XMLInfoWin(InfoWin): + """ + Info about the latest xml filter used and the state of the buffer. + """ + def __init__(self): + InfoWin.__init__(self) + + def refresh(self, filter_t='', filter='', window=None): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + bar = to_curses_attr(get_theme().COLOR_INFORMATION_BAR) + if not filter_t: + self.addstr('[No filter]', bar) + else: + info = '[%s] %s' % (filter_t, filter) + self.addstr(info, bar) + self.print_scroll_position(window) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + +class PrivateInfoWin(InfoWin): + """ + The line above the information window, displaying informations + about the MUC user we are talking to + """ + def __init__(self): + InfoWin.__init__(self) + + def refresh(self, name, window, chatstate, informations): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + self.write_room_name(name) + self.print_scroll_position(window) + self.write_chatstate(chatstate) + self.write_additional_informations(informations, name) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + + def write_additional_informations(self, informations, jid): + """ + Write all informations added by plugins by getting the + value returned by the callbacks. + """ + for key in informations: + self.addstr(informations[key](jid), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_room_name(self, name): + jid = safeJID(name) + room_name, nick = jid.bare, jid.resource + self.addstr(nick, to_curses_attr(get_theme().COLOR_PRIVATE_NAME)) + txt = ' from room %s' % room_name + self.addstr(txt, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_chatstate(self, state): + if state: + self.addstr(' %s' % (state,), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + +class MucListInfoWin(InfoWin): + """ + The live above the information window, displaying informations + about the muc server being listed + """ + def __init__(self, message=''): + InfoWin.__init__(self) + self.message = message + + def refresh(self, name=None, window=None): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + if name: + self.addstr(name, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + else: + self.addstr(self.message, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + if window: + self.print_scroll_position(window) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + +class ConversationInfoWin(InfoWin): + """ + The line above the information window, displaying informations + about the user we are talking to + """ + + def __init__(self): + InfoWin.__init__(self) + + def refresh(self, jid, contact, window, chatstate, informations): + # contact can be None, if we receive a message + # from someone not in our roster. In this case, we display + # only the maximum information from the message we can get. + log.debug('Refresh: %s', self.__class__.__name__) + jid = safeJID(jid) + if contact: + if jid.resource: + resource = contact[jid.full] + else: + resource = contact.get_highest_priority_resource() + else: + resource = None + # if contact is None, then resource is None too: + # user is not in the roster so we know almost nothing about it + # If contact is a Contact, then + # resource can now be a Resource: user is in the roster and online + # or resource is None: user is in the roster but offline + with g_lock: + self._win.erase() + self.write_contact_jid(jid) + self.write_contact_informations(contact) + self.write_resource_information(resource) + self.print_scroll_position(window) + self.write_chatstate(chatstate) + self.write_additional_informations(informations, jid) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + + def write_additional_informations(self, informations, jid): + """ + Write all informations added by plugins by getting the + value returned by the callbacks. + """ + for key in informations: + self.addstr(informations[key](jid), + to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_resource_information(self, resource): + """ + Write the informations about the resource + """ + if not resource: + presence = "unavailable" + else: + presence = resource.presence + color = get_theme().color_show(presence) + self.addstr('[', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.addstr(get_theme().CHAR_STATUS, to_curses_attr(color)) + self.addstr(']', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_contact_informations(self, contact): + """ + Write the informations about the contact + """ + if not contact: + self.addstr("(contact not in roster)", to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + return + display_name = contact.name + if display_name: + self.addstr('%s '%(display_name), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_contact_jid(self, jid): + """ + Just write the jid that we are talking to + """ + self.addstr('[', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.addstr(jid.full, to_curses_attr(get_theme().COLOR_CONVERSATION_NAME)) + self.addstr('] ', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_chatstate(self, state): + if state: + self.addstr(' %s' % (state,), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + +class DynamicConversationInfoWin(ConversationInfoWin): + def write_contact_jid(self, jid): + """ + Just displays the resource in an other color + """ + log.debug("write_contact_jid DynamicConversationInfoWin, jid: %s", + jid.resource) + self.addstr('[', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.addstr(jid.bare, to_curses_attr(get_theme().COLOR_CONVERSATION_NAME)) + if jid.resource: + self.addstr("/%s" % (jid.resource,), to_curses_attr(get_theme().COLOR_CONVERSATION_RESOURCE)) + self.addstr('] ', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + +class MucInfoWin(InfoWin): + """ + The line just above the information window, displaying informations + about the MUC we are viewing + """ + def __init__(self): + InfoWin.__init__(self) + + def refresh(self, room, window=None): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + self.write_room_name(room) + self.write_participants_number(room) + self.write_own_nick(room) + self.write_disconnected(room) + self.write_role(room) + if window: + self.print_scroll_position(window) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + + def write_room_name(self, room): + self.addstr('[', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.addstr(room.name, to_curses_attr(get_theme().COLOR_GROUPCHAT_NAME)) + self.addstr(']', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_participants_number(self, room): + self.addstr('{', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.addstr(str(len(room.users)), to_curses_attr(get_theme().COLOR_GROUPCHAT_NAME)) + self.addstr('} ', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_disconnected(self, room): + """ + Shows a message if the room is not joined + """ + if not room.joined: + self.addstr(' -!- Not connected ', to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_own_nick(self, room): + """ + Write our own nick in the info bar + """ + nick = room.own_nick + if not nick: + return + self.addstr(truncate_nick(nick, 13), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + + def write_role(self, room): + """ + Write our own role and affiliation + """ + own_user = None + for user in room.users: + if user.nick == room.own_nick: + own_user = user + break + if not own_user: + return + txt = ' (' + if own_user.affiliation != 'none': + txt += own_user.affiliation+', ' + txt += own_user.role+')' + self.addstr(txt, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + +class ConversationStatusMessageWin(InfoWin): + """ + The upper bar displaying the status message of the contact + """ + def __init__(self): + InfoWin.__init__(self) + + def refresh(self, jid, contact): + log.debug('Refresh: %s', self.__class__.__name__) + jid = safeJID(jid) + if contact: + if jid.resource: + resource = contact[jid.full] + else: + resource = contact.get_highest_priority_resource() + else: + resource = None + with g_lock: + self._win.erase() + if resource: + self.write_status_message(resource) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + + def write_status_message(self, resource): + self.addstr(resource.status, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + diff --git a/src/windows/input_placeholders.py b/src/windows/input_placeholders.py new file mode 100644 index 00000000..796cf0ad --- /dev/null +++ b/src/windows/input_placeholders.py @@ -0,0 +1,78 @@ +""" +Classes used to replace the input in some tabs or special situations, +but which are not inputs. +""" + +import logging +log = logging.getLogger(__name__) + + +from . import Win, g_lock +from theming import get_theme, to_curses_attr + + +class HelpText(Win): + """ + A Window just displaying a read-only message. + Usually used to replace an Input when the tab is in + command mode. + """ + def __init__(self, text=''): + Win.__init__(self) + self.txt = text + + def refresh(self, txt=None): + log.debug('Refresh: %s', self.__class__.__name__) + if txt: + self.txt = txt + with g_lock: + self._win.erase() + self.addstr(0, 0, self.txt[:self.width-1], to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + self._refresh() + + def do_command(self, key, raw=False): + return False + +class YesNoInput(Win): + """ + A Window just displaying a Yes/No input + Used to ask a confirmation + """ + def __init__(self, text=''): + Win.__init__(self) + self.key_func = { + 'y' : self.on_yes, + 'n' : self.on_no, + } + self.txt = text + self.value = None + + def on_yes(self): + self.value = True + + def on_no(self): + self.value = False + + def refresh(self, txt=None): + log.debug('Refresh: %s', self.__class__.__name__) + if txt: + self.txt = txt + with g_lock: + self._win.erase() + self.addstr(0, 0, self.txt[:self.width-1], to_curses_attr(get_theme().COLOR_WARNING_PROMPT)) + self.finish_line(get_theme().COLOR_WARNING_PROMPT) + self._refresh() + + def do_command(self, key, raw=False): + if key.lower() in self.key_func: + self.key_func[key]() + + def prompt(self): + """Monopolizes the input while waiting for a recognized keypress""" + cl = [] + while self.value is None: + if len(cl) == 1 and cl[0] in self.key_func: + self.key_func[cl[0]]() + cl = self.core.read_keyboard() + diff --git a/src/windows/inputs.py b/src/windows/inputs.py new file mode 100644 index 00000000..8c2f2e2e --- /dev/null +++ b/src/windows/inputs.py @@ -0,0 +1,764 @@ +""" +Text inputs. +""" + +import logging +log = logging.getLogger(__name__) + +import curses +import string + +import common +import poopt +from . import Win, g_lock +from . base_wins import format_chars +from . funcs import find_first_format_char +from config import config +from theming import to_curses_attr + + +class Input(Win): + """ + The simplest Input possible, provides just a way to edit a single line + of text. It also has a clipboard, common to all Inputs. + Doesn't have any history. + It doesn't do anything when enter is pressed either. + This should be herited for all kinds of Inputs, for example MessageInput + or the little inputs in dataforms, etc, adding specific features (completion etc) + It features two kinds of completion, but they have to be called from outside (the Tab), + passing the list of items that can be used to complete. The completion can be used + in a very flexible way. + """ + text_attributes = ['b', 'o', 'u', '1', '2', '3', '4', '5', '6', '7', 't'] + clipboard = '' # A common clipboard for all the inputs, this makes + # it easy cut and paste text between various input + def __init__(self): + self.key_func = { + "KEY_LEFT": self.key_left, + "KEY_RIGHT": self.key_right, + "KEY_END": self.key_end, + "KEY_HOME": self.key_home, + "KEY_DC": self.key_dc, + '^D': self.key_dc, + 'M-b': self.jump_word_left, + "M-[1;5D": self.jump_word_left, + '^W': self.delete_word, + 'M-d': self.delete_next_word, + '^K': self.delete_end_of_line, + '^U': self.delete_begining_of_line, + '^Y': self.paste_clipboard, + '^A': self.key_home, + '^E': self.key_end, + 'M-f': self.jump_word_right, + "M-[1;5C": self.jump_word_right, + "KEY_BACKSPACE": self.key_backspace, + "M-KEY_BACKSPACE": self.delete_word, + '^?': self.key_backspace, + "M-^?": self.delete_word, + # '^J': self.add_line_break, + } + Win.__init__(self) + self.text = '' + self.pos = 0 # The position of the “cursor” in the text + # (not only in the view) + self.view_pos = 0 # The position (in the text) of the + # first character displayed on the + # screen + self.on_input = None # callback called on any key pressed + self.color = None # use this color on addstr + + def on_delete(self): + """ + Remove all references kept to a tab, so that the tab + can be garbage collected + """ + del self.key_func + + def set_color(self, color): + self.color = color + self.rewrite_text() + + def is_empty(self): + if self.text: + return False + return True + + def is_cursor_at_end(self): + """ + Whether or not the cursor is at the end of the text. + """ + assert len(self.text) >= self.pos + if len(self.text) == self.pos: + return True + return False + + def jump_word_left(self): + """ + Move the cursor one word to the left + """ + if self.pos == 0: + return True + separators = string.punctuation+' ' + while self.pos > 0 and self.text[self.pos-1] in separators: + self.key_left() + while self.pos > 0 and self.text[self.pos-1] not in separators: + self.key_left() + return True + + def jump_word_right(self): + """ + Move the cursor one word to the right + """ + if self.is_cursor_at_end(): + return True + separators = string.punctuation+' ' + while not self.is_cursor_at_end() and self.text[self.pos] in separators: + self.key_right() + while not self.is_cursor_at_end() and self.text[self.pos] not in separators: + self.key_right() + return True + + def delete_word(self): + """ + Delete the word just before the cursor + """ + separators = string.punctuation+' ' + while self.pos > 0 and self.text[self.pos-1] in separators: + self.key_backspace() + while self.pos > 0 and self.text[self.pos-1] not in separators: + self.key_backspace() + return True + + def delete_next_word(self): + """ + Delete the word just after the cursor + """ + separators = string.punctuation+' ' + while not self.is_cursor_at_end() and self.text[self.pos] in separators: + self.key_dc() + while not self.is_cursor_at_end() and self.text[self.pos] not in separators: + self.key_dc() + return True + + def delete_end_of_line(self): + """ + Cut the text from cursor to the end of line + """ + if self.is_cursor_at_end(): + return False + Input.clipboard = self.text[self.pos:] + self.text = self.text[:self.pos] + self.key_end() + return True + + def delete_begining_of_line(self): + """ + Cut the text from cursor to the begining of line + """ + if self.pos == 0: + return True + Input.clipboard = self.text[:self.pos] + self.text = self.text[self.pos:] + self.key_home() + return True + + def paste_clipboard(self): + """ + Insert what is in the clipboard at the cursor position + """ + if not Input.clipboard: + return True + for letter in Input.clipboard: + self.do_command(letter, False) + self.rewrite_text() + return True + + def key_dc(self): + """ + delete char just after the cursor + """ + self.reset_completion() + if self.is_cursor_at_end(): + return True # end of line, nothing to delete + self.text = self.text[:self.pos]+self.text[self.pos+1:] + self.rewrite_text() + return True + + def key_home(self): + """ + Go to the begining of line + """ + self.reset_completion() + self.pos = 0 + self.rewrite_text() + return True + + def key_end(self, reset=False): + """ + Go to the end of line + """ + if reset: + self.reset_completion() + self.pos = len(self.text) + assert self.is_cursor_at_end() + self.rewrite_text() + return True + + def key_left(self, jump=True, reset=True): + """ + Move the cursor one char to the left + """ + if reset: + self.reset_completion() + if self.pos == 0: + return True + self.pos -= 1 + if reset: + self.rewrite_text() + return True + + def key_right(self, jump=True, reset=True): + """ + Move the cursor one char to the right + """ + if reset: + self.reset_completion() + if self.is_cursor_at_end(): + return True + self.pos += 1 + if reset: + self.rewrite_text() + return True + + def key_backspace(self, reset=True): + """ + Delete the char just before the cursor + """ + self.reset_completion() + if self.pos == 0: + return + self.key_left() + self.key_dc() + return True + + def auto_completion(self, word_list, add_after='', quotify=True): + """ + Complete the input, from a list of words + if add_after is None, we use the value defined in completion + plus a space, after the completion. If it's a string, we use it after the + completion (with no additional space) + """ + if quotify: + for i, word in enumerate(word_list[:]): + word_list[i] = '"' + word + '"' + self.normal_completion(word_list, add_after) + return True + + def new_completion(self, word_list, argument_position=-1, add_after='', quotify=True, override=False): + """ + Complete the argument at position ``argument_postion`` in the input. + If ``quotify`` is ``True``, then the completion will operate on block of words + (e.g. "toto titi") whereas if it is ``False``, it will operate on words (e.g + "toto", "titi"). + + The completions may modify other parts of the input when completing an argument, + for example removing useless double quotes around single-words, or setting the + space between each argument to only one space. + + The case where we complete the first argument is special, because we complete + the command, and we do not want to modify anything else in the input. + + This method is the one that should be used if the command being completed + has several arguments. + """ + if argument_position == 0: + self._new_completion_first(word_list) + else: + self._new_completion_args(word_list, argument_position, add_after, quotify, override) + self.rewrite_text() + return True + + def _new_completion_args(self, word_list, argument_position=-1, add_after='', quoted=True, override=False): + """ + Case for completing arguments with position ≠ 0 + """ + if quoted: + words = common.shell_split(self.text) + else: + words = self.text.split() + if argument_position >= len(words): + current = '' + else: + current = words[argument_position] + + if quoted: + split_words = words[1:] + words = [words[0]] + for word in split_words: + if ' ' in word or '\\' in word: + words.append('"' + word + '"') + else: + words.append(word) + current_l = current.lower() + if self.last_completion is not None: + self.hit_list.append(self.hit_list.pop(0)) + else: + if override: + hit_list = word_list + else: + hit_list = [] + for word in word_list: + if word.lower().startswith(current_l): + hit_list.append(word) + if not hit_list: + return + self.hit_list = hit_list + + if argument_position >= len(words): + if quoted and ' ' in self.hit_list[0]: + words.append('"'+self.hit_list[0]+'"') + else: + words.append(self.hit_list[0]) + else: + if quoted and ' ' in self.hit_list[0]: + words[argument_position] = '"'+self.hit_list[0]+'"' + else: + words[argument_position] = self.hit_list[0] + + new_pos = -1 + for i, word in enumerate(words): + if argument_position >= i: + new_pos += len(word) + 1 + + self.last_completion = self.hit_list[0] + self.text = words[0] + ' ' + ' '.join(words[1:]) + self.pos = new_pos + + def _new_completion_first(self, word_list): + """ + Special case of completing the command itself: + we don’t want to change anything to the input doing that + """ + space_pos = self.text.find(' ') + if space_pos != -1: + current, follow = self.text[:space_pos], self.text[space_pos:] + else: + current, follow = self.text, '' + + if self.last_completion: + self.hit_list.append(self.hit_list.pop(0)) + else: + hit_list = [] + for word in word_list: + if word.lower().startswith(current): + hit_list.append(word) + if not hit_list: + return + self.hit_list = hit_list + + self.last_completion = self.hit_list[0] + self.text = self.hit_list[0] + follow + self.pos = len(self.hit_list[0]) + + def get_argument_position(self, quoted=True): + """ + Get the argument number at the current position + """ + command_stop = self.text.find(' ') + if command_stop == -1 or self.pos <= command_stop: + return 0 + text = self.text[command_stop+1:] + pos = self.pos - len(self.text) + len(text) - 1 + val = common.find_argument(pos, text, quoted=quoted) + 1 + return val + + def reset_completion(self): + """ + Reset the completion list (called on ALL keys except tab) + """ + self.hit_list = [] + self.last_completion = None + + def normal_completion(self, word_list, after): + """ + Normal completion + """ + pos = self.pos + if pos < len(self.text) and after.endswith(' ') and self.text[pos] == ' ': + after = after[:-1] # remove the last space if we are already on a space + if not self.last_completion: + space_before_cursor = self.text.rfind(' ', 0, pos) + if space_before_cursor != -1: + begin = self.text[space_before_cursor+1:pos] + else: + begin = self.text[:pos] + hit_list = [] # list of matching hits + for word in word_list: + if word.lower().startswith(begin.lower()): + hit_list.append(word) + elif word.startswith('"') and word.lower()[1:].startswith(begin.lower()): + hit_list.append(word) + if len(hit_list) == 0: + return + self.hit_list = hit_list + end = len(begin) + else: + begin = self.last_completion + end = len(begin) + len(after) + self.hit_list.append(self.hit_list.pop(0)) # rotate list + + self.text = self.text[:pos-end] + self.text[pos:] + pos -= end + hit = self.hit_list[0] # take the first hit + self.text = self.text[:pos] + hit + after + self.text[pos:] + for _ in range(end): + try: + self.key_left(reset=False) + except: + pass + for _ in range(len(hit) + len(after)): + self.key_right(reset=False) + + self.rewrite_text() + self.last_completion = hit + + def do_command(self, key, reset=True, raw=False): + if key in self.key_func: + res = self.key_func[key]() + if not raw and self.on_input: + self.on_input(self.get_text()) + return res + if not raw and (not key or len(key) > 1): + return False # ignore non-handled keyboard shortcuts + if reset: + self.reset_completion() + # Insert the char at the cursor position + self.text = self.text[:self.pos]+key+self.text[self.pos:] + self.pos += len(key) + if reset: + self.rewrite_text() + if self.on_input: + self.on_input(self.get_text()) + + return True + + def add_line_break(self): + """ + Add a (real) \n to the line + """ + self.do_command('\n') + + def get_text(self): + """ + Return the text entered so far + """ + return self.text + + def addstr_colored_lite(self, text, y=None, x=None): + """ + Just like addstr_colored, with the single-char attributes + (\x0E to \x19 instead of \x19 + attr). We do not use any } + char in this version + """ + chars = format_chars[:] + chars.append('\n') + if y is not None and x is not None: + self.move(y, x) + format_char = find_first_format_char(text, chars) + while format_char != -1: + if text[format_char] == '\n': + attr_char = '|' + else: + attr_char = self.text_attributes[ + format_chars.index(text[format_char])] + self.addstr(text[:format_char]) + self.addstr(attr_char, curses.A_REVERSE) + text = text[format_char+1:] + if attr_char == 'o': + self._win.attrset(0) + elif attr_char == 'u': + self._win.attron(curses.A_UNDERLINE) + elif attr_char == 'b': + self._win.attron(curses.A_BOLD) + elif attr_char in string.digits and attr_char != '': + self._win.attron(to_curses_attr((int(attr_char), -1))) + format_char = find_first_format_char(text, chars) + self.addstr(text) + + def rewrite_text(self): + """ + Refresh the line onscreen, but first, always adjust the + view_pos. Also, each FORMAT_CHAR+attr_char count only take + one screen column (this is done in addstr_colored_lite), we + have to do some special calculations to find the correct + length of text to display, and the position of the cursor. + """ + self.adjust_view_pos() + with g_lock: + text = self.text + self._win.erase() + if self.color: + self._win.attron(to_curses_attr(self.color)) + displayed_text = text[self.view_pos:self.view_pos+self.width-1].replace('\t', '\x18') + self._win.attrset(0) + self.addstr_colored_lite(displayed_text) + # Fill the rest of the line with the input color + if self.color: + (_, x) = self._win.getyx() + size = self.width - x + self.addnstr(' ' * size, size, to_curses_attr(self.color)) + self.addstr(0, + poopt.wcswidth(displayed_text[:self.pos-self.view_pos]), '') + if self.color: + self._win.attroff(to_curses_attr(self.color)) + curses.curs_set(1) + self._refresh() + + def adjust_view_pos(self): + """ + Adjust the position of the View, if needed (for example if the + cursor moved and would now be out of the view, we adapt the + view_pos so that we can always see our cursor) + """ + # start of the input + if self.pos == 0: + self.view_pos = 0 + return + # cursor outside of the screen (left) + if self.pos < self.view_pos: + self.view_pos = self.pos - max(1 * self.width // 3, 1) + # cursor outside of the screen (right) + elif self.pos >= self.view_pos + self.width - 1: + self.view_pos = self.pos - max(2 * self.width // 3, 2) + + if self.view_pos < 0: + self.view_pos = 0 + + + assert(self.pos > self.view_pos and + self.pos < self.view_pos + max(self.width, 3)) + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + self.rewrite_text() + + def clear_text(self): + self.text = '' + self.pos = 0 + self.rewrite_text() + + def key_enter(self): + txt = self.get_text() + self.clear_text() + return txt + +class HistoryInput(Input): + """ + An input with colors and stuff, plus an history + ^R allows to search inside the history (as in a shell) + """ + history = list() + + def __init__(self): + Input.__init__(self) + self.help_message = '' + self.current_completed = '' + self.key_func['^R'] = self.toggle_search + self.search = False + if config.get('separate_history', False): + self.history = list() + + def toggle_search(self): + if self.help_message: + return + self.search = not self.search + self.refresh() + + def update_completed(self): + """ + Find a match for the current text + """ + if not self.text: + return + for i in self.history: + if self.text in i: + self.current_completed = i + return + self.current_completed = '' + + def history_enter(self): + """ + Enter was pressed, set the text to the + current completion and disable history + search + """ + if self.search: + self.search = False + if self.current_completed: + self.text = self.current_completed + self.current_completed = '' + self.refresh() + return True + self.refresh() + return False + + def key_up(self): + """ + Get the previous line in the history + """ + self.reset_completion() + if self.histo_pos == -1 and self.get_text(): + if not self.history or self.history[0] != self.get_text(): + # add the message to history, we do not want to lose it + self.history.insert(0, self.get_text()) + self.histo_pos += 1 + if self.histo_pos < len(self.history) - 1: + self.histo_pos += 1 + self.text = self.history[self.histo_pos] + self.key_end() + return True + + def key_down(self): + """ + Get the next line in the history + """ + self.reset_completion() + if self.histo_pos > 0: + self.histo_pos -= 1 + self.text = self.history[self.histo_pos] + elif self.histo_pos <= 0 and self.get_text(): + if not self.history or self.history[0] != self.get_text(): + # add the message to history, we do not want to lose it + self.history.insert(0, self.get_text()) + self.text = '' + self.histo_pos = -1 + self.key_end() + return True + +class MessageInput(HistoryInput): + """ + The input featuring history and that is being used in + Conversation, Muc and Private tabs + Also letting the user enter colors or other text markups + """ + history = list() # The history is common to all MessageInput + + def __init__(self): + HistoryInput.__init__(self) + self.last_completion = None + self.histo_pos = -1 + self.key_func["KEY_UP"] = self.key_up + self.key_func["M-A"] = self.key_up + self.key_func["KEY_DOWN"] = self.key_down + self.key_func["M-B"] = self.key_down + self.key_func['^C'] = self.enter_attrib + + def enter_attrib(self): + """ + Read one more char (c), add the corresponding char from formats_char to the text string + """ + attr_char = self.core.read_keyboard()[0] + if attr_char in self.text_attributes: + char = format_chars[self.text_attributes.index(attr_char)] + self.do_command(char, False) + self.rewrite_text() + + def key_enter(self): + if self.history_enter(): + return + + txt = self.get_text() + if len(txt) != 0: + if not self.history or self.history[0] != txt: + # add the message to history, but avoid duplicates + self.history.insert(0, txt) + self.histo_pos = -1 + self.clear_text() + return txt + +class CommandInput(HistoryInput): + """ + An input with an help message in the left, with three given callbacks: + one when when successfully 'execute' the command and when we abort it. + The last callback is optional and is called on any input key + This input is used, for example, in the RosterTab when, to replace the + HelpMessage when a command is started + The on_input callback + """ + history = list() + + def __init__(self, help_message, on_abort, on_success, on_input=None): + HistoryInput.__init__(self) + self.on_abort = on_abort + self.on_success = on_success + self.on_input = on_input + self.help_message = help_message + self.key_func['^M'] = self.success + self.key_func['^G'] = self.abort + self.key_func['^C'] = self.abort + self.key_func["KEY_UP"] = self.key_up + self.key_func["M-A"] = self.key_up + self.key_func["KEY_DOWN"] = self.key_down + self.key_func["M-B"] = self.key_down + self.histo_pos = -1 + + def do_command(self, key, refresh=True, raw=False): + res = Input.do_command(self, key, refresh, raw) + if self.on_input: + self.on_input(self.get_text()) + return res + + def disable_history(self): + """ + Disable the history (up/down) keys + """ + if 'KEY_UP' in self.key_func: + del self.key_func['KEY_UP'] + if 'KEY_DOWN' in self.key_func: + del self.key_func['KEY_DOWN'] + + @property + def history_disabled(self): + return 'KEY_UP' not in self.key_func and 'KEY_DOWN' not in self.key_func + + def success(self): + """ + call the success callback, passing the text as argument + """ + self.on_input = None + if self.search: + self.history_enter() + res = self.on_success(self.get_text()) + return res + + def abort(self): + """ + Call the abort callback, passing the text as argument + """ + self.on_input = None + return self.on_abort(self.get_text()) + + def on_delete(self): + """ + SERIOUSLY BIG WTF. + + I can do + self.key_func.clear() + + but not + del self.key_func + because that would raise an AttributeError exception. WTF. + """ + self.on_abort = None + self.on_success = None + self.on_input = None + self.key_func.clear() + + def key_enter(self): + txt = self.get_text() + if len(txt) != 0: + if not self.history or self.history[0] != txt: + # add the message to history, but avoid duplicates + self.history.insert(0, txt) + self.histo_pos = -1 + diff --git a/src/windows/list.py b/src/windows/list.py new file mode 100644 index 00000000..3cfb8af5 --- /dev/null +++ b/src/windows/list.py @@ -0,0 +1,237 @@ +""" +Windows relevant for the listing tabs, not much else +""" + +import logging +log = logging.getLogger(__name__) + +import curses + +from . import Win, g_lock +from theming import to_curses_attr, get_theme + + +class ListWin(Win): + """ + A list (with no depth, so not for the roster) that can be + scrolled up and down, with one selected line at a time + """ + def __init__(self, columns, with_headers=True): + Win.__init__(self) + self._columns = columns # a dict {'column_name': tuple_index} + self._columns_sizes = {} # a dict {'column_name': size} + self.sorted_by = (None, None) # for example: ('name', '↑') + self.lines = [] # a list of dicts + self._selected_row = 0 + self._starting_pos = 0 # The column number from which we start the refresh + + @property + def pos(self): + if len(self.lines) > self.height: + return len(self.lines) + else: + return 0 + + def empty(self): + """ + emtpy the list and reset some important values as well + """ + self.lines = [] + self._selected_row = 0 + self._starting_pos = 0 + + def resize_columns(self, dic): + """ + Resize the width of the columns + """ + self._columns_sizes = dic + + def sort_by_column(self, col_name, asc=True): + """ + Sort the list by the given column, ascendant or descendant + """ + if not col_name: + return + elif asc: + self.lines.sort(key=lambda x: x[self._columns[col_name]]) + else: + self.lines.sort(key=lambda x: x[self._columns[col_name]], + reverse=True) + self.refresh() + curses.doupdate() + + def add_lines(self, lines): + """ + Append some lines at the end of the list + """ + if not lines: + return + self.lines.extend(lines) + + def set_lines(self, lines): + """ + Set the lines to another list + """ + if not lines: + return + self.lines = lines + + def get_selected_row(self): + """ + Return the tuple representing the selected row + """ + if self._selected_row is not None and self.lines: + return self.lines[self._selected_row] + return None + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + lines = self.lines[self._starting_pos:self._starting_pos+self.height] + for y, line in enumerate(lines): + x = 0 + for col in self._columns.items(): + try: + txt = line[col[1]] or '' + except KeyError: + txt = '' + size = self._columns_sizes[col[0]] + txt += ' ' * (size-len(txt)) + if not txt: + continue + if line is self.lines[self._selected_row]: + self.addstr(y, x, txt[:size], to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + else: + self.addstr(y, x, txt[:size]) + x += size + self._refresh() + + def move_cursor_down(self): + """ + Move the cursor Down + """ + if not self.lines: + return + if self._selected_row < len(self.lines) - 1: + self._selected_row += 1 + while self._selected_row >= self._starting_pos + self.height: + self._starting_pos += self.height // 2 + if self._starting_pos < 0: + self._starting_pos = 0 + return True + + def move_cursor_up(self): + """ + Move the cursor Up + """ + if not self.lines: + return + if self._selected_row > 0: + self._selected_row -= 1 + while self._selected_row < self._starting_pos: + self._starting_pos -= self.height // 2 + return True + + def scroll_down(self): + if not self.lines: + return + self._selected_row += self.height + if self._selected_row > len(self.lines) - 1: + self._selected_row = len(self.lines) -1 + while self._selected_row >= self._starting_pos + self.height: + self._starting_pos += self.height // 2 + if self._starting_pos < 0: + self._starting_pos = 0 + return True + + def scroll_up(self): + if not self.lines: + return + self._selected_row -= self.height + 1 + if self._selected_row < 0: + self._selected_row = 0 + while self._selected_row < self._starting_pos: + self._starting_pos -= self.height // 2 + return True + +class ColumnHeaderWin(Win): + """ + A class displaying the column's names + """ + def __init__(self, columns): + Win.__init__(self) + self._columns = columns + self._columns_sizes = {} + self._column_sel = '' + self._column_order = '' + self._column_order_asc = False + + def resize_columns(self, dic): + self._columns_sizes = dic + + def get_columns(self): + return self._columns + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + x = 0 + for col in self._columns: + txt = col + if col in self._column_order: + if self._column_order_asc: + txt += get_theme().CHAR_COLUMN_ASC + else: + txt += get_theme().CHAR_COLUMN_DESC + #⇓⇑↑↓⇧⇩▲▼ + size = self._columns_sizes[col] + txt += ' ' * (size-len(txt)) + if col in self._column_sel: + self.addstr(0, x, txt, to_curses_attr(get_theme().COLOR_COLUMN_HEADER_SEL)) + else: + self.addstr(0, x, txt, to_curses_attr(get_theme().COLOR_COLUMN_HEADER)) + x += size + self._refresh() + + def sel_column(self, dic): + self._column_sel = dic + + def get_sel_column(self): + return self._column_sel + + def set_order(self, order): + self._column_order = self._column_sel + self._column_order_asc = order + + def get_order(self): + if self._column_sel == self._column_order: + return self._column_order_asc + else: + return False + + def sel_column_left(self): + if self._column_sel in self._columns: + index = self._columns.index(self._column_sel) + if index > 1: + index = index -1 + else: + index = 0 + else: + index = 0 + self._column_sel = self._columns[index] + self.refresh() + + def sel_column_right(self): + if self._column_sel in self._columns: + index = self._columns.index(self._column_sel) + if index < len(self._columns)-2: + index = index +1 + else: + index = len(self._columns) -1 + else: + index = len(self._columns) - 1 + self._column_sel = self._columns[index] + self.refresh() + diff --git a/src/windows/misc.py b/src/windows/misc.py new file mode 100644 index 00000000..0f6bce59 --- /dev/null +++ b/src/windows/misc.py @@ -0,0 +1,61 @@ +""" +Wins that don’t fit any category +""" + +import logging +log = logging.getLogger(__name__) + +import curses + +from . import Win, g_lock +from theming import get_theme, to_curses_attr + +class VerticalSeparator(Win): + """ + Just a one-column window, with just a line in it, that is + refreshed only on resize, but never on refresh, for efficiency + """ + def __init__(self): + Win.__init__(self) + + def rewrite_line(self): + with g_lock: + self._win.vline(0, 0, curses.ACS_VLINE, self.height, to_curses_attr(get_theme().COLOR_VERTICAL_SEPARATOR)) + self._refresh() + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + self.rewrite_line() + + +class SimpleTextWin(Win): + def __init__(self, text): + Win.__init__(self) + self._text = text + self.built_lines = [] + + def rebuild_text(self): + """ + Transform the text in lines than can then be + displayed without any calculation or anything + at refresh() time + It is basically called on each resize + """ + self.built_lines = [] + for line in self._text.split('\n'): + while len(line) >= self.width: + limit = line[:self.width].rfind(' ') + if limit <= 0: + limit = self.width + self.built_lines.append(line[:limit]) + line = line[limit:] + self.built_lines.append(line) + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + for y, line in enumerate(self.built_lines): + self.addstr_colored(line, y, 0) + self._refresh() + diff --git a/src/windows/muc.py b/src/windows/muc.py new file mode 100644 index 00000000..ce296e26 --- /dev/null +++ b/src/windows/muc.py @@ -0,0 +1,127 @@ +""" +Windows specific to a MUC +""" + +import logging +log = logging.getLogger(__name__) + +import curses + +from . import Win, g_lock + +import poopt +from config import config +from theming import to_curses_attr, get_theme + +class UserList(Win): + def __init__(self): + Win.__init__(self) + self.pos = 0 + + def scroll_up(self): + self.pos += self.height-1 + return True + + def scroll_down(self): + pos = self.pos + self.pos -= self.height-1 + if self.pos < 0: + self.pos = 0 + return self.pos != pos + + def draw_plus(self, y): + self.addstr(y, self.width-2, '++', to_curses_attr(get_theme().COLOR_MORE_INDICATOR)) + + def refresh(self, users): + log.debug('Refresh: %s', self.__class__.__name__) + if config.get("hide_user_list", False): + return # do not refresh if this win is hidden. + with g_lock: + self._win.erase() + if config.get('user_list_sort', 'desc').lower() == 'asc': + y, x = self._win.getmaxyx() + y -= 1 + users = sorted(users) + else: + y = 0 + users = sorted(users) + + if len(users) < self.height: + self.pos = 0 + elif self.pos >= len(users) - self.height and self.pos != 0: + self.pos = len(users) - self.height + for user in users[self.pos:]: + self.draw_role_affiliation(y, user) + self.draw_status_chatstate(y, user) + self.addstr(y, 2, + poopt.cut_by_columns(user.nick, self.width - 2), + to_curses_attr(user.color)) + if config.get('user_list_sort', 'desc').lower() == 'asc': + y -= 1 + else: + y += 1 + if y == self.height: + break + # draw indicators of position in the list + if self.pos > 0: + if config.get('user_list_sort', 'desc').lower() == 'asc': + self.draw_plus(self.height-1) + else: + self.draw_plus(0) + if self.pos + self.height < len(users): + if config.get('user_list_sort', 'desc').lower() == 'asc': + self.draw_plus(0) + else: + self.draw_plus(self.height-1) + self._refresh() + + def draw_role_affiliation(self, y, user): + theme = get_theme() + color = theme.color_role(user.role) + symbol = theme.char_affiliation(user.affiliation) + self.addstr(y, 1, symbol, to_curses_attr(color)) + + def draw_status_chatstate(self, y, user): + show_col = get_theme().color_show(user.show) + if user.chatstate == 'composing': + char = get_theme().CHAR_CHATSTATE_COMPOSING + elif user.chatstate == 'active': + char = get_theme().CHAR_CHATSTATE_ACTIVE + elif user.chatstate == 'paused': + char = get_theme().CHAR_CHATSTATE_PAUSED + else: + char = get_theme().CHAR_STATUS + self.addstr(y, 0, char, to_curses_attr(show_col)) + + def resize(self, height, width, y, x): + with g_lock: + separator = to_curses_attr(get_theme().COLOR_VERTICAL_SEPARATOR) + self._resize(height, width, y, x) + self._win.attron(separator) + self._win.vline(0, 0, curses.ACS_VLINE, self.height) + self._win.attroff(separator) + +class Topic(Win): + def __init__(self): + Win.__init__(self) + self._message = '' + + def refresh(self, topic=None): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + if topic: + msg = topic[:self.width-1] + else: + msg = self._message[:self.width-1] + self.addstr(0, 0, msg, to_curses_attr(get_theme().COLOR_TOPIC_BAR)) + (y, x) = self._win.getyx() + remaining_size = self.width - x + if remaining_size: + self.addnstr(' '*remaining_size, remaining_size, + to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self._refresh() + + def set_message(self, message): + self._message = message + diff --git a/src/windows/roster_win.py b/src/windows/roster_win.py new file mode 100644 index 00000000..d5f6d958 --- /dev/null +++ b/src/windows/roster_win.py @@ -0,0 +1,385 @@ +""" +Windows used with the roster (window displaying the contacts, and the +one showing detailed info on the current selection) +""" +import logging +log = logging.getLogger(__name__) + +from datetime import datetime + +from . import Win, g_lock + +import common +from config import config +from contact import Contact, Resource +from roster import RosterGroup +from theming import get_theme, to_curses_attr + + +class RosterWin(Win): + + def __init__(self): + Win.__init__(self) + self.pos = 0 # cursor position in the contact list + self.start_pos = 1 # position of the start of the display + self.selected_row = None + self.roster_cache = [] + + @property + def roster_len(self): + return len(self.roster_cache) + + def move_cursor_down(self, number=1): + """ + Return True if we scrolled, False otherwise + """ + pos = self.pos + if self.pos < self.roster_len-number: + self.pos += number + else: + self.pos = self.roster_len - 1 + if self.pos >= self.start_pos-1 + self.height-1: + if number == 1: + self.scroll_down(8) + else: + self.scroll_down(self.pos-self.start_pos - self.height // 2) + self.update_pos() + return pos != self.pos + + def move_cursor_up(self, number=1): + """ + Return True if we scrolled, False otherwise + """ + pos = self.pos + if self.pos-number >= 0: + self.pos -= number + else: + self.pos = 0 + if self.pos <= self.start_pos: + if number == 1: + self.scroll_up(8) + else: + self.scroll_up(self.start_pos-self.pos + self.height // 2) + self.update_pos() + return pos != self.pos + + def update_pos(self): + if len(self.roster_cache) > self.pos and self.pos >= 0: + self.selected_row = self.roster_cache[self.pos] + elif self.roster_cache: + self.selected_row = self.roster_cache[-1] + + def scroll_down(self, number=8): + pos = self.start_pos + if self.start_pos + number <= self.roster_len-1: + self.start_pos += number + else: + self.start_pos = self.roster_len-1 + return self.start_pos != pos + + def scroll_up(self, number=8): + pos = self.start_pos + if self.start_pos - number > 0: + self.start_pos -= number + else: + self.start_pos = 1 + return self.start_pos != pos + + def build_roster_cache(self, roster): + """ + Regenerates the roster cache if needed + """ + with g_lock: + if roster.needs_rebuild: + log.debug('The roster has changed, rebuilding the cache…') + # This is a search + if roster.contact_filter: + self.roster_cache = [] + sort = config.get('roster_sort', 'jid:show') or 'jid:show' + for contact in roster.get_contacts_sorted_filtered(sort): + self.roster_cache.append(contact) + else: + show_offline = config.get('roster_show_offline', False) or roster.contact_filter + sort = config.get('roster_sort', 'jid:show') or 'jid:show' + group_sort = config.get('roster_group_sort', 'name') or 'name' + self.roster_cache = [] + # build the cache + for group in roster.get_groups(group_sort): + contacts_filtered = group.get_contacts(roster.contact_filter) + if (not show_offline and group.get_nb_connected_contacts() == 0) or not contacts_filtered: + continue # Ignore empty groups + self.roster_cache.append(group) + if group.folded: + continue # ignore folded groups + for contact in group.get_contacts(roster.contact_filter, sort): + if not show_offline and len(contact) == 0: + continue # ignore offline contacts + self.roster_cache.append(contact) + if not contact.folded(group.name): + for resource in contact.get_resources(): + self.roster_cache.append(resource) + roster.last_built = datetime.now() + if self.selected_row in self.roster_cache: + if self.pos < self.roster_len and self.roster_cache[self.pos] != self.selected_row: + self.pos = self.roster_cache.index(self.selected_row) + + def refresh(self, roster): + """ + We display a number of lines from the roster cache + (and rebuild it if needed) + """ + log.debug('Refresh: %s', self.__class__.__name__) + self.build_roster_cache(roster) + with g_lock: + # make sure we are within bounds + self.move_cursor_up((self.roster_len + self.pos) if self.pos >= self.roster_len else 0) + if not self.roster_cache: + self.selected_row = None + self._win.erase() + self._win.move(0, 0) + self.draw_roster_information(roster) + y = 1 + group = "none" + # scroll down if needed + if self.start_pos+self.height <= self.pos+2: + self.scroll_down(self.pos - self.start_pos - self.height + (self.height//2)) + # draw the roster from the cache + roster_view = self.roster_cache[self.start_pos-1:self.start_pos+self.height] + + for item in roster_view: + draw_selected = False + if y -2 + self.start_pos == self.pos: + draw_selected = True + self.selected_row = item + + if isinstance(item, RosterGroup): + self.draw_group(y, item, draw_selected) + group = item.name + elif isinstance(item, Contact): + self.draw_contact_line(y, item, draw_selected, group) + elif isinstance(item, Resource): + self.draw_resource_line(y, item, draw_selected) + + y += 1 + + if self.start_pos > 1: + self.draw_plus(1) + if self.start_pos + self.height-2 < self.roster_len: + self.draw_plus(self.height-1) + self._refresh() + + + def draw_plus(self, y): + """ + Draw the indicator that shows that + the list is longer than what is displayed + """ + self.addstr(y, self.width-5, '++++', to_curses_attr(get_theme().COLOR_MORE_INDICATOR)) + + def draw_roster_information(self, roster): + """ + The header at the top + """ + self.addstr('Roster: %s/%s contacts' % ( + roster.get_nb_connected_contacts(), + len(roster)), + to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + + def draw_group(self, y, group, colored): + """ + Draw a groupname on a line + """ + if colored: + self._win.attron(to_curses_attr(get_theme().COLOR_SELECTED_ROW)) + if group.folded: + self.addstr(y, 0, '[+] ') + else: + self.addstr(y, 0, '[-] ') + contacts = " (%s/%s)" % (group.get_nb_connected_contacts(), len(group)) + self.addstr(y, 4, self.truncate_name(group.name, len(contacts)+4) + contacts) + if colored: + self._win.attroff(to_curses_attr(get_theme().COLOR_SELECTED_ROW)) + self.finish_line() + + def truncate_name(self, name, added): + if len(name) + added <= self.width: + return name + return name[:self.width - added - 1] + '…' + + def draw_contact_line(self, y, contact, colored, group): + """ + Draw on a line all informations about one contact. + This is basically the highest priority resource's informations + Use 'color' to draw the jid/display_name to show what is + the currently selected contact in the list + """ + + theme = get_theme() + resource = contact.get_highest_priority_resource() + if not resource: + # There's no online resource + presence = 'unavailable' + nb = '' + else: + presence = resource.presence + nb = ' (%s)' % len(contact) + color = theme.color_show(presence) + added = 2 + len(theme.CHAR_STATUS) + len(nb) + + self.addstr(y, 0, ' ') + self.addstr(theme.CHAR_STATUS, to_curses_attr(color)) + + show_roster_sub = config.get('show_roster_subscriptions', '') + + self.addstr(' ') + if resource: + self.addstr('[+] ' if contact.folded(group) else '[-] ') + added += 4 + if contact.ask: + added += len(get_theme().CHAR_ROSTER_ASKED) + if config.get('show_s2s_errors', True) and contact.error: + added += len(get_theme().CHAR_ROSTER_ERROR) + if contact.tune: + added += len(get_theme().CHAR_ROSTER_TUNE) + if contact.mood: + added += len(get_theme().CHAR_ROSTER_MOOD) + if contact.activity: + added += len(get_theme().CHAR_ROSTER_ACTIVITY) + if contact.gaming: + added += len(get_theme().CHAR_ROSTER_GAMING) + if show_roster_sub in ('all', 'incomplete', 'to', 'from', 'both', 'none'): + added += len(theme.char_subscription(contact.subscription, keep=show_roster_sub)) + + if not config.get('show_roster_jids', True) and contact.name: + display_name = '%s' % contact.name + elif contact.name and contact.name != contact.bare_jid: + display_name = '%s (%s)' % (contact.name, contact.bare_jid) + else: + display_name = '%s' % (contact.bare_jid,) + + display_name = self.truncate_name(display_name, added) + nb + + if colored: + self.addstr(display_name, to_curses_attr(get_theme().COLOR_SELECTED_ROW)) + else: + self.addstr(display_name) + + if show_roster_sub in ('all', 'incomplete', 'to', 'from', 'both', 'none'): + self.addstr(theme.char_subscription(contact.subscription, keep=show_roster_sub), to_curses_attr(theme.COLOR_ROSTER_SUBSCRIPTION)) + if contact.ask: + self.addstr(get_theme().CHAR_ROSTER_ASKED, to_curses_attr(get_theme().COLOR_IMPORTANT_TEXT)) + if config.get('show_s2s_errors', True) and contact.error: + self.addstr(get_theme().CHAR_ROSTER_ERROR, to_curses_attr(get_theme().COLOR_ROSTER_ERROR)) + if contact.tune: + self.addstr(get_theme().CHAR_ROSTER_TUNE, to_curses_attr(get_theme().COLOR_ROSTER_TUNE)) + if contact.activity: + self.addstr(get_theme().CHAR_ROSTER_ACTIVITY, to_curses_attr(get_theme().COLOR_ROSTER_ACTIVITY)) + if contact.mood: + self.addstr(get_theme().CHAR_ROSTER_MOOD, to_curses_attr(get_theme().COLOR_ROSTER_MOOD)) + if contact.gaming: + self.addstr(get_theme().CHAR_ROSTER_GAMING, to_curses_attr(get_theme().COLOR_ROSTER_GAMING)) + self.finish_line() + + def draw_resource_line(self, y, resource, colored): + """ + Draw a specific resource line + """ + color = get_theme().color_show(resource.presence) + self.addstr(y, 4, get_theme().CHAR_STATUS, to_curses_attr(color)) + if colored: + self.addstr(y, 6, self.truncate_name(str(resource.jid), 6), to_curses_attr(get_theme().COLOR_SELECTED_ROW)) + else: + self.addstr(y, 6, self.truncate_name(str(resource.jid), 6)) + self.finish_line() + + def get_selected_row(self): + if self.pos >= len(self.roster_cache): + return self.selected_row + if len(self.roster_cache) > 0: + self.selected_row = self.roster_cache[self.pos] + return self.roster_cache[self.pos] + return None + +class ContactInfoWin(Win): + def __init__(self): + Win.__init__(self) + + def draw_contact_info(self, contact): + """ + draw the contact information + """ + resource = contact.get_highest_priority_resource() + if contact: + jid = contact.bare_jid + elif resource: + jid = resource.jid + else: + jid = 'example@example.com' # should never happen + if resource: + presence = resource.presence + else: + presence = 'unavailable' + i = 0 + self.addstr(0, 0, '%s (%s)'%(jid, presence,), to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + i += 1 + self.addstr(i, 0, 'Subscription: %s' % (contact.subscription,)) + self.finish_line() + i += 1 + if contact.ask: + if contact.ask == 'asked': + self.addstr(i, 0, 'Ask: %s' % (contact.ask,), to_curses_attr(get_theme().COLOR_IMPORTANT_TEXT)) + else: + self.addstr(i, 0, 'Ask: %s' % (contact.ask,)) + self.finish_line() + i += 1 + if resource: + self.addstr(i, 0, 'Status: %s' % (resource.status)) + self.finish_line() + i += 1 + + if contact.error: + self.addstr(i, 0, 'Error: %s' % contact.error, to_curses_attr(get_theme().COLOR_ROSTER_ERROR)) + self.finish_line() + i += 1 + + if contact.tune: + self.addstr(i, 0, 'Tune: %s' % common.format_tune_string(contact.tune), to_curses_attr(get_theme().COLOR_NORMAL_TEXT)) + self.finish_line() + i += 1 + + if contact.mood: + self.addstr(i, 0, 'Mood: %s' % contact.mood, to_curses_attr(get_theme().COLOR_NORMAL_TEXT)) + self.finish_line() + i += 1 + + if contact.activity: + self.addstr(i, 0, 'Activity: %s' % contact.activity, to_curses_attr(get_theme().COLOR_NORMAL_TEXT)) + self.finish_line() + i += 1 + + if contact.gaming: + self.addstr(i, 0, 'Game: %s' % common.format_gaming_string(contact.gaming), to_curses_attr(get_theme().COLOR_NORMAL_TEXT)) + self.finish_line() + i += 1 + + def draw_group_info(self, group): + """ + draw the group information + """ + self.addstr(0, 0, group.name, to_curses_attr(get_theme().COLOR_INFORMATION_BAR)) + self.finish_line(get_theme().COLOR_INFORMATION_BAR) + + def refresh(self, selected_row): + log.debug('Refresh: %s', self.__class__.__name__) + with g_lock: + self._win.erase() + if isinstance(selected_row, RosterGroup): + self.draw_group_info(selected_row) + elif isinstance(selected_row, Contact): + self.draw_contact_info(selected_row) + # elif isinstance(selected_row, Resource): + # self.draw_contact_info(None, selected_row) + self._refresh() + diff --git a/src/windows/text_win.py b/src/windows/text_win.py new file mode 100644 index 00000000..de9b0625 --- /dev/null +++ b/src/windows/text_win.py @@ -0,0 +1,438 @@ +""" +TextWin, the window showing the text messages and info messages in poezio. +Can be locked, scrolled, has a separator, etc… +""" + +import logging +log = logging.getLogger(__name__) + +import curses +from math import ceil, log10 + +from . import Win, g_lock +from . base_wins import FORMAT_CHAR, Line +from . funcs import truncate_nick, parse_attrs + +import poopt +from config import config +from theming import to_curses_attr, get_theme, dump_tuple + + +class TextWin(Win): + def __init__(self, lines_nb_limit=config.get('max_lines_in_memory', 2048)): + Win.__init__(self) + self.lines_nb_limit = lines_nb_limit + self.pos = 0 + self.built_lines = [] # Each new message is built and kept here. + # on resize, we rebuild all the messages + + self.lock = False + self.lock_buffer = [] + + # the Lines of the highlights in that buffer + self.highlights = [] + # the current HL position in that list NaN means that we’re not on + # an hl. -1 is a valid position (it's before the first hl of the + # list. i.e the separator, in the case where there’s no hl before + # it.) + self.hl_pos = float('nan') + + # Keep track of the number of hl after the separator. + # This is useful to make “go to next highlight“ work after a “move to separator”. + self.nb_of_highlights_after_separator = 0 + + self.separator_after = None + + def toggle_lock(self): + if self.lock: + self.release_lock() + else: + self.acquire_lock() + return self.lock + + def acquire_lock(self): + self.lock = True + + def release_lock(self): + for line in self.lock_buffer: + self.built_lines.append(line) + self.lock = False + + def next_highlight(self): + """ + Go to the next highlight in the buffer. + (depending on which highlight was selected before) + if the buffer is already positionned on the last, of if there are no + highlights, scroll to the end of the buffer. + """ + log.debug('Going to the next highlight…') + if (not self.highlights or self.hl_pos != self.hl_pos or + self.hl_pos >= len(self.highlights) - 1): + self.hl_pos = float('nan') + self.pos = 0 + return + hl_size = len(self.highlights) - 1 + if self.hl_pos < hl_size: + self.hl_pos += 1 + else: + self.hl_pos = hl_size + log.debug("self.hl_pos = %s", self.hl_pos) + hl = self.highlights[self.hl_pos] + pos = None + while not pos: + try: + pos = self.built_lines.index(hl) + except ValueError: + self.highlights = self.highlights[self.hl_pos+1:] + if not self.highlights: + self.hl_pos = float('nan') + self.pos = 0 + return + self.hl_pos = 0 + hl = self.highlights[0] + self.pos = len(self.built_lines) - pos - self.height + if self.pos < 0 or self.pos >= len(self.built_lines): + self.pos = 0 + + def previous_highlight(self): + """ + Go to the previous highlight in the buffer. + (depending on which highlight was selected before) + if the buffer is already positionned on the first, or if there are no + highlights, scroll to the end of the buffer. + """ + log.debug('Going to the previous highlight…') + if not self.highlights or self.hl_pos <= 0: + self.hl_pos = float('nan') + self.pos = 0 + return + if self.hl_pos != self.hl_pos: + self.hl_pos = len(self.highlights) - 1 + else: + self.hl_pos -= 1 + log.debug("self.hl_pos = %s", self.hl_pos) + hl = self.highlights[self.hl_pos] + pos = None + while not pos: + try: + pos = self.built_lines.index(hl) + except ValueError: + self.highlights = self.highlights[self.hl_pos+1:] + if not self.highlights: + self.hl_pos = float('nan') + self.pos = 0 + return + self.hl_pos = 0 + hl = self.highlights[0] + self.pos = len(self.built_lines) - pos - self.height + if self.pos < 0 or self.pos >= len(self.built_lines): + self.pos = 0 + + def scroll_up(self, dist=14): + pos = self.pos + self.pos += dist + if self.pos + self.height > len(self.built_lines): + self.pos = len(self.built_lines) - self.height + if self.pos < 0: + self.pos = 0 + return self.pos != pos + + def scroll_down(self, dist=14): + pos = self.pos + self.pos -= dist + if self.pos <= 0: + self.pos = 0 + return self.pos != pos + + def scroll_to_separator(self): + """ + Scroll until separator is centered. If no separator is + present, scroll at the top of the window + """ + if None in self.built_lines: + self.pos = len(self.built_lines) - self.built_lines.index(None) - self.height + 1 + if self.pos < 0: + self.pos = 0 + else: + self.pos = len(self.built_lines) - self.height + 1 + # Chose a proper position (not too high) + self.scroll_up(0) + # Make “next highlight” work afterwards. This makes it easy to + # review all the highlights since the separator was placed, in + # the correct order. + self.hl_pos = len(self.highlights) - self.nb_of_highlights_after_separator - 1 + log.debug("self.hl_pos = %s", self.hl_pos) + + def remove_line_separator(self): + """ + Remove the line separator + """ + log.debug('remove_line_separator') + if None in self.built_lines: + self.built_lines.remove(None) + self.separator_after = None + + def add_line_separator(self, room=None): + """ + add a line separator at the end of messages list + room is a textbuffer that is needed to get the previous message + (in case of resize) + """ + if None not in self.built_lines: + self.built_lines.append(None) + self.nb_of_highlights_after_separator = 0 + log.debug("Reseting number of highlights after separator") + if room and room.messages: + self.separator_after = room.messages[-1] + + def build_new_message(self, message, history=None, clean=True, highlight=False, timestamp=False): + """ + Take one message, build it and add it to the list + Return the number of lines that are built for the given + message. + """ + lines = self.build_message(message, timestamp=timestamp) + if self.lock: + self.lock_buffer.extend(lines) + else: + self.built_lines.extend(lines) + if not lines or not lines[0]: + return 0 + if highlight: + self.highlights.append(lines[0]) + self.nb_of_highlights_after_separator += 1 + log.debug("Number of highlights after separator is now %s", + self.nb_of_highlights_after_separator) + if clean: + while len(self.built_lines) > self.lines_nb_limit: + self.built_lines.pop(0) + return len(lines) + + def build_message(self, message, timestamp=False): + """ + Build a list of lines from a message, without adding it + to a list + """ + if message is None: # line separator + return [None] + txt = message.txt + if not txt: + return [] + if len(message.str_time) > 8: + default_color = (FORMAT_CHAR + dump_tuple(get_theme().COLOR_LOG_MSG) + + '}') + else: + default_color = None + ret = [] + nick = truncate_nick(message.nickname) + offset = 0 + if message.ack: + offset += poopt.wcswidth(get_theme().CHAR_ACK_RECEIVED) + 1 + if nick: + offset += poopt.wcswidth(nick) + 2 # + nick + '> ' length + if message.revisions > 0: + offset += ceil(log10(message.revisions + 1)) + if message.me: + offset += 1 # '* ' before and ' ' after + if timestamp: + if message.str_time: + offset += 1 + len(message.str_time) + if get_theme().CHAR_TIME_LEFT and message.str_time: + offset += 1 + if get_theme().CHAR_TIME_RIGHT and message.str_time: + offset += 1 + lines = poopt.cut_text(txt, self.width-offset-1) + prepend = '' + attrs = [] + for line in lines: + saved = Line(msg=message, start_pos=line[0], end_pos=line[1], prepend=prepend) + attrs = parse_attrs(message.txt[line[0]:line[1]], attrs) + if attrs: + prepend = FORMAT_CHAR + FORMAT_CHAR.join(attrs) + else: + if default_color: + prepend = default_color + else: + prepend = '' + ret.append(saved) + return ret + + def refresh(self): + log.debug('Refresh: %s', self.__class__.__name__) + if self.height <= 0: + return + if self.pos == 0: + lines = self.built_lines[-self.height:] + else: + lines = self.built_lines[-self.height-self.pos:-self.pos] + with_timestamps = config.get("show_timestamps", True) + with g_lock: + self._win.move(0, 0) + self._win.erase() + for y, line in enumerate(lines): + if line: + msg = line.msg + if line.start_pos == 0: + if msg.nick_color: + color = msg.nick_color + elif msg.user: + color = msg.user.color + else: + color = None + if with_timestamps: + self.write_time(msg.str_time) + if msg.ack: + self.write_ack() + if msg.me: + self._win.attron(to_curses_attr(get_theme().COLOR_ME_MESSAGE)) + self.addstr('* ') + self.write_nickname(msg.nickname, color, msg.highlight) + if msg.revisions: + self._win.attron(to_curses_attr(get_theme().COLOR_REVISIONS_MESSAGE)) + self.addstr('%d' % msg.revisions) + self._win.attrset(0) + self.addstr(' ') + else: + self.write_nickname(msg.nickname, color, msg.highlight) + if msg.revisions: + self._win.attron(to_curses_attr(get_theme().COLOR_REVISIONS_MESSAGE)) + self.addstr('%d' % msg.revisions) + self._win.attrset(0) + self.addstr('> ') + if y != self.height-1: + self.addstr('\n') + self._win.attrset(0) + for y, line in enumerate(lines): + if not line: + self.write_line_separator(y) + else: + offset = 0 + # Offset for the timestamp (if any) plus a space after it + if with_timestamps: + offset += len(line.msg.str_time) + if offset: + offset += 1 + + # Offset for the nickname (if any) + # plus a space and a > after it + if line.msg.nickname: + offset += poopt.wcswidth( + truncate_nick(line.msg.nickname)) + if line.msg.me: + offset += 3 + else: + offset += 2 + offset += ceil(log10(line.msg.revisions + 1)) + + if line.msg.ack: + offset += 1 + poopt.wcswidth( + get_theme().CHAR_ACK_RECEIVED) + + self.write_text(y, offset, + line.prepend+line.msg.txt[line.start_pos:line.end_pos]) + if y != self.height-1: + self.addstr('\n') + self._win.attrset(0) + self._refresh() + + def write_line_separator(self, y): + char = get_theme().CHAR_NEW_TEXT_SEPARATOR + self.addnstr(y, 0, + char*((self.width//len(char) - 1)), + self.width, + to_curses_attr(get_theme().COLOR_NEW_TEXT_SEPARATOR)) + + def write_text(self, y, x, txt): + """ + write the text of a line. + """ + self.addstr_colored(txt, y, x) + + def write_ack(self): + color = get_theme().COLOR_CHAR_ACK + self._win.attron(to_curses_attr(color)) + self.addstr(get_theme().CHAR_ACK_RECEIVED) + self._win.attroff(to_curses_attr(color)) + self.addstr(' ') + + def write_nickname(self, nickname, color, highlight=False): + """ + Write the nickname, using the user's color + and return the number of written characters + """ + if not nickname: + return + if highlight: + hl_color = get_theme().COLOR_HIGHLIGHT_NICK + if hl_color == "reverse": + self._win.attron(curses.A_REVERSE) + else: + color = hl_color + if color: + self._win.attron(to_curses_attr(color)) + self.addstr(truncate_nick(nickname)) + if color: + self._win.attroff(to_curses_attr(color)) + if highlight and hl_color == "reverse": + self._win.attroff(curses.A_REVERSE) + + def write_time(self, time): + """ + Write the date on the yth line of the window + """ + if time: + self.addstr(time) + self.addstr(' ') + + def resize(self, height, width, y, x, room=None): + with g_lock: + if hasattr(self, 'width'): + old_width = self.width + else: + old_width = None + self._resize(height, width, y, x) + if room and self.width != old_width: + self.rebuild_everything(room) + + # reposition the scrolling after resize + # (see #2450) + buf_size = len(self.built_lines) + if buf_size - self.pos < self.height: + self.pos = buf_size - self.height + if self.pos < 0: + self.pos = 0 + + + def rebuild_everything(self, room): + self.built_lines = [] + with_timestamps = config.get("show_timestamps", True) + for message in room.messages: + self.build_new_message(message, clean=False, timestamp=with_timestamps) + if self.separator_after is message: + self.build_new_message(None) + while len(self.built_lines) > self.lines_nb_limit: + self.built_lines.pop(0) + + def modify_message(self, old_id, message): + """ + Find a message, and replace it with a new one + (instead of rebuilding everything in order to correct a message) + """ + with_timestamps = config.get("show_timestamps", True) + for i in range(len(self.built_lines)-1, -1, -1): + if self.built_lines[i] and self.built_lines[i].msg.identifier == old_id: + index = i + while index >= 0 and self.built_lines[index] and self.built_lines[index].msg.identifier == old_id: + self.built_lines.pop(index) + index -= 1 + index += 1 + lines = self.build_message(message, timestamp=with_timestamps) + for line in lines: + self.built_lines.insert(index, line) + index += 1 + break + + def __del__(self): + log.debug('** TextWin: deleting %s built lines', (len(self.built_lines))) + del self.built_lines + |