# -*- coding: utf-8 -*- """This module implements a multi line editing text box""" from __future__ import division from __future__ import absolute_import from __future__ import print_function from __future__ import unicode_literals from builtins import chr from builtins import str from copy import copy from logging import getLogger from asciimatics.event import KeyboardEvent, MouseEvent from asciimatics.screen import Screen from asciimatics.strings import ColouredText from asciimatics.widgets.widget import Widget from asciimatics.widgets.utilities import _find_min_start, _enforce_width, _get_offset # Logging logger = getLogger(__name__) class TextBox(Widget): """ A TextBox is a widget for multi-line text editing. It consists of a framed box with option label. """ __slots__ = ["_label", "_line", "_column", "_start_line", "_start_column", "_required_height", "_as_string", "_line_wrap", "_on_change", "_reflowed_text_cache", "_parser", "_readonly", "_hide_cursor", "_auto_scroll"] def __init__(self, height, label=None, name=None, as_string=False, line_wrap=False, parser=None, on_change=None, readonly=False, **kwargs): """ :param height: The required number of input lines for this TextBox. :param label: An optional label for the widget. :param name: The name for the TextBox. :param as_string: Use string with newline separator instead of a list for the value of this widget. :param line_wrap: Whether to wrap at the end of the line. :param parser: Optional parser to colour text. :param on_change: Optional function to call when text changes. :param readonly: Whether the widget prevents user input to change values. Default is False. Also see the common keyword arguments in :py:obj:`.Widget`. """ super(TextBox, self).__init__(name, **kwargs) self._label = label self._line = 0 self._column = 0 self._start_line = 0 self._start_column = 0 self._required_height = height self._as_string = as_string self._line_wrap = line_wrap self._parser = parser self._on_change = on_change self._reflowed_text_cache = None self._readonly = readonly self._hide_cursor = False self._auto_scroll = True def update(self, frame_no): self._draw_label() # Calculate new visible limits if needed. height = self._h if not self._line_wrap: self._start_column = min(self._start_column, self._column) self._start_column += _find_min_start( str(self._value[self._line][self._start_column:self._column + 1]), self.width, self._frame.canvas.unicode_aware, self._column >= self.string_len(str(self._value[self._line]))) # Clear out the existing box content (colour, attr, background) = self._pick_colours("readonly" if self._readonly else "edit_text") self._frame.canvas.clear_buffer( colour, attr, background, self._x + self._offset, self._y, self.width, height) # Convert value offset to display offsets # NOTE: _start_column is always in display coordinates. display_text = self._reflowed_text display_start_column = self._start_column display_line, display_column = 0, 0 for i, (_, line, col) in enumerate(display_text): if line < self._line or (line == self._line and col <= self._column): display_line = i display_column = self._column - col # Restrict to visible/valid content. self._start_line = max(0, max(display_line - height + 1, min(self._start_line, display_line))) # Render visible portion of the text. for line, (text, _, _) in enumerate(display_text): if self._start_line <= line < self._start_line + height: paint_text = _enforce_width( text[display_start_column:], self.width, self._frame.canvas.unicode_aware) self._frame.canvas.paint( str(paint_text), self._x + self._offset, self._y + line - self._start_line, colour, attr, background, colour_map=paint_text.colour_map if hasattr(paint_text, "colour_map") else None) # Since we switch off the standard cursor, we need to emulate our own # if we have the input focus. if self._has_focus and not self._hide_cursor: line = str(display_text[display_line][0]) logger.debug("Cursor: %d,%d", display_start_column, display_column) text_width = self.string_len(line[display_start_column:display_column]) self._draw_cursor( " " if display_column >= len(line) else line[display_column], frame_no, self._x + self._offset + text_width, self._y + display_line - self._start_line) def reset(self): # Reset to original data and move to end of the text. self._start_line = 0 self._start_column = 0 if self._auto_scroll or self._line > len(self._value) - 1: self._line = len(self._value) - 1 self._column = 0 if self._is_disabled else len(self._value[self._line]) self._reflowed_text_cache = None def _change_line(self, delta): """ Move the cursor up/down the specified number of lines. :param delta: The number of lines to move (-ve is up, +ve is down). """ # Ensure new line is within limits self._line = min(max(0, self._line + delta), len(self._value) - 1) # Fix up column if the new line is shorter than before. if self._column >= len(self._value[self._line]): self._column = len(self._value[self._line]) def process_event(self, event): def _join(a, b): if self._parser: return ColouredText(a, self._parser, colour=b[0].first_colour).join(b) return a.join(b) if isinstance(event, KeyboardEvent): old_value = copy(self._value) if event.key_code in [10, 13] and not self._readonly: # Split and insert line on CR or LF. self._value.insert(self._line + 1, self._value[self._line][self._column:]) self._value[self._line] = self._value[self._line][:self._column] self._line += 1 self._column = 0 elif event.key_code == Screen.KEY_BACK and not self._readonly: if self._column > 0: # Delete character in front of cursor. self._value[self._line] = _join( "", [self._value[self._line][:self._column - 1], self._value[self._line][self._column:]]) self._column -= 1 else: if self._line > 0: # Join this line with previous self._line -= 1 self._column = len(self._value[self._line]) self._value[self._line] += \ self._value.pop(self._line + 1) elif event.key_code == Screen.KEY_DELETE and not self._readonly: if self._column < len(self._value[self._line]): self._value[self._line] = _join( "", [self._value[self._line][:self._column], self._value[self._line][self._column + 1:]]) else: if self._line < len(self._value) - 1: # Join this line with next self._value[self._line] += \ self._value.pop(self._line + 1) elif event.key_code == Screen.KEY_PAGE_UP: self._change_line(-self._h) elif event.key_code == Screen.KEY_PAGE_DOWN: self._change_line(self._h) elif event.key_code == Screen.KEY_UP: self._change_line(-1) elif event.key_code == Screen.KEY_DOWN: self._change_line(1) elif event.key_code == Screen.KEY_LEFT: # Move left one char, wrapping to previous line if needed. self._column -= 1 if self._column < 0: if self._line > 0: self._line -= 1 self._column = len(self._value[self._line]) else: self._column = 0 elif event.key_code == Screen.KEY_RIGHT: # Move right one char, wrapping to next line if needed. self._column += 1 if self._column > len(self._value[self._line]): if self._line < len(self._value) - 1: self._line += 1 self._column = 0 else: self._column = len(self._value[self._line]) elif event.key_code == Screen.KEY_HOME: # Go to the start of this line self._column = 0 elif event.key_code == Screen.KEY_END: # Go to the end of this line self._column = len(self._value[self._line]) elif event.key_code >= 32 and not self._readonly: # Insert any visible text at the current cursor position. self._value[self._line] = _join( chr(event.key_code), [self._value[self._line][:self._column], self._value[self._line][self._column:]]) self._column += 1 else: # Ignore any other key press. return event # If we got here we might have changed the value... if old_value != self._value: self._reflowed_text_cache = None if self._on_change: self._on_change() elif isinstance(event, MouseEvent): # Mouse event - rebase coordinates to Frame context. if event.buttons != 0: if self.is_mouse_over(event, include_label=False): # Find the line first. clicked_line = event.y - self._y + self._start_line if self._line_wrap: # Line-wrapped text needs to be mapped to visible lines display_text = self._reflowed_text clicked_line = min(clicked_line, len(display_text) - 1) text_line = display_text[clicked_line][1] text_col = display_text[clicked_line][2] else: # non-wrapped just needs a little end protection text_line = max(0, clicked_line) text_col = 0 self._line = min(len(self._value) - 1, text_line) # Now figure out location in text based on width of each glyph. self._column = (self._start_column + text_col + _get_offset( str(self._value[self._line][self._start_column + text_col:]), event.x - self._x - self._offset, self._frame.canvas.unicode_aware)) self._column = min(len(self._value[self._line]), self._column) self._column = max(0, self._column) return None # Ignore other mouse events. return event else: # Ignore other events return event # If we got here, we processed the event - swallow it. return None def required_height(self, offset, width): return self._required_height @property def _reflowed_text(self): """ The text as should be formatted on the screen. This is an array of tuples of the form (text, value line, value column offset) where the line and column offsets are indeces into the value (not displayed glyph coordinates). """ if self._reflowed_text_cache is None: if self._line_wrap: self._reflowed_text_cache = [] limit = self._w - self._offset for i, line in enumerate(self._value): column = 0 while self.string_len(str(line)) >= limit: sub_string = _enforce_width( line, limit, self._frame.canvas.unicode_aware) self._reflowed_text_cache.append((sub_string, i, column)) line = line[len(sub_string):] column += len(sub_string) self._reflowed_text_cache.append((line, i, column)) else: self._reflowed_text_cache = [(x, i, 0) for i, x in enumerate(self._value)] return self._reflowed_text_cache @property def hide_cursor(self): """ Set to True to stop the cursor from showing. Defaults to False. """ return self._hide_cursor @hide_cursor.setter def hide_cursor(self, new_value): self._hide_cursor = new_value @property def auto_scroll(self): """ When set to True the TextBox will scroll to the bottom when created or next text is added. When set to False, the current scroll position will remain even if the contents are changed. Defaults to True. """ return self._auto_scroll @auto_scroll.setter def auto_scroll(self, new_value): self._auto_scroll = new_value @property def value(self): """ The current value for this TextBox. """ if self._value is None: self._value = [""] return "\n".join([str(x) for x in self._value]) if self._as_string else self._value @value.setter def value(self, new_value): # Convert to the internal format old_value = self._value if new_value is None: new_value = [""] elif self._as_string: new_value = new_value.split("\n") self._value = new_value # TODO: Sort out speed of this code if self._parser: new_value = [] last_colour = None for line in self._value: if hasattr(line, "raw_text"): value = line else: value = ColouredText(line, self._parser, colour=last_colour) new_value.append(value) last_colour = value.last_colour self._value = new_value self.reset() # Only trigger the notification after we've changed the value. if old_value != self._value and self._on_change: self._on_change() @property def readonly(self): """ Whether this widget is readonly or not. """ return self._readonly @readonly.setter def readonly(self, new_value): self._readonly = new_value @property def frame_update_count(self): # Force refresh for cursor if needed. if self._has_focus and not self._frame.reduce_cpu and not self._hide_cursor: return 5 return 0