Restoring authorship annotation for Ivan Blinkov <ivan@blinkov.ru>. Commit 2 of 2.

1 files changed, 387 insertions, 387 deletions

diff --git a/contrib/python/prompt-toolkit/py2/prompt_toolkit/layout/controls.py b/contrib/python/prompt-toolkit/py2/prompt_toolkit/layout/controls.py
index 59107c7e5e..ca74931dbc 100644
--- a/contrib/python/prompt-toolkit/py2/prompt_toolkit/layout/controls.py
+++ b/contrib/python/prompt-toolkit/py2/prompt_toolkit/layout/controls.py
@@ -1,99 +1,99 @@
-""" 
-User interface Controls for the layout. 
-""" 
-from __future__ import unicode_literals 
- 
-from abc import ABCMeta, abstractmethod 
+"""
+User interface Controls for the layout.
+"""
+from __future__ import unicode_literals
+
+from abc import ABCMeta, abstractmethod
 from collections import namedtuple
-from six import with_metaclass 
+from six import with_metaclass
 from six.moves import range
- 
+
 from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER 
-from prompt_toolkit.filters import to_cli_filter 
+from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER
+from prompt_toolkit.filters import to_cli_filter
 from prompt_toolkit.mouse_events import MouseEventType
-from prompt_toolkit.search_state import SearchState 
-from prompt_toolkit.selection import SelectionType 
+from prompt_toolkit.search_state import SearchState
+from prompt_toolkit.selection import SelectionType
 from prompt_toolkit.token import Token
 from prompt_toolkit.utils import get_cwidth
- 
-from .lexers import Lexer, SimpleLexer 
+
+from .lexers import Lexer, SimpleLexer
 from .processors import Processor
 from .screen import Char, Point
 from .utils import token_list_width, split_lines, token_list_to_text
- 
+
 import six
-import time 
- 
-
-__all__ = ( 
-    'BufferControl', 
-    'FillControl', 
-    'TokenListControl', 
-    'UIControl', 
+import time
+
+
+__all__ = (
+    'BufferControl',
+    'FillControl',
+    'TokenListControl',
+    'UIControl',
     'UIContent',
-) 
- 
- 
-class UIControl(with_metaclass(ABCMeta, object)): 
-    """ 
-    Base class for all user interface controls. 
-    """ 
-    def reset(self): 
-        # Default reset. (Doesn't have to be implemented.) 
-        pass 
- 
-    def preferred_width(self, cli, max_available_width): 
-        return None 
- 
+)
+
+
+class UIControl(with_metaclass(ABCMeta, object)):
+    """
+    Base class for all user interface controls.
+    """
+    def reset(self):
+        # Default reset. (Doesn't have to be implemented.)
+        pass
+
+    def preferred_width(self, cli, max_available_width):
+        return None
+
     def preferred_height(self, cli, width, max_available_height, wrap_lines):
-        return None 
- 
-    def has_focus(self, cli): 
-        """ 
-        Return ``True`` when this user control has the focus. 
- 
-        If so, the cursor will be displayed according to the cursor position 
+        return None
+
+    def has_focus(self, cli):
+        """
+        Return ``True`` when this user control has the focus.
+
+        If so, the cursor will be displayed according to the cursor position
         reported by :meth:`.UIControl.create_content`. If the created content
         has the property ``show_cursor=False``, the cursor will be hidden from
         the output.
-        """ 
-        return False 
- 
-    @abstractmethod 
+        """
+        return False
+
+    @abstractmethod
     def create_content(self, cli, width, height):
-        """ 
+        """
         Generate the content for this user control.
- 
+
         Returns a :class:`.UIContent` instance.
-        """ 
- 
-    def mouse_handler(self, cli, mouse_event): 
-        """ 
-        Handle mouse events. 
- 
-        When `NotImplemented` is returned, it means that the given event is not 
-        handled by the `UIControl` itself. The `Window` or key bindings can 
-        decide to handle this event as scrolling or changing focus. 
- 
-        :param cli: `CommandLineInterface` instance. 
-        :param mouse_event: `MouseEvent` instance. 
-        """ 
-        return NotImplemented 
- 
-    def move_cursor_down(self, cli): 
-        """ 
-        Request to move the cursor down. 
-        This happens when scrolling down and the cursor is completely at the 
-        top. 
-        """ 
- 
-    def move_cursor_up(self, cli): 
-        """ 
-        Request to move the cursor up. 
-        """ 
- 
- 
+        """
+
+    def mouse_handler(self, cli, mouse_event):
+        """
+        Handle mouse events.
+
+        When `NotImplemented` is returned, it means that the given event is not
+        handled by the `UIControl` itself. The `Window` or key bindings can
+        decide to handle this event as scrolling or changing focus.
+
+        :param cli: `CommandLineInterface` instance.
+        :param mouse_event: `MouseEvent` instance.
+        """
+        return NotImplemented
+
+    def move_cursor_down(self, cli):
+        """
+        Request to move the cursor down.
+        This happens when scrolling down and the cursor is completely at the
+        top.
+        """
+
+    def move_cursor_up(self, cli):
+        """
+        Request to move the cursor up.
+        """
+
+
 class UIContent(object):
     """
     Content generated by a user control. This content consists of a list of
@@ -166,135 +166,135 @@ class UIContent(object):
             return max(1, quotient)
 
 
-class TokenListControl(UIControl): 
-    """ 
-    Control that displays a list of (Token, text) tuples. 
-    (It's mostly optimized for rather small widgets, like toolbars, menus, etc...) 
- 
-    Mouse support: 
- 
-        The list of tokens can also contain tuples of three items, looking like: 
-        (Token, text, handler). When mouse support is enabled and the user 
-        clicks on this token, then the given handler is called. That handler 
-        should accept two inputs: (CommandLineInterface, MouseEvent) and it 
-        should either handle the event or return `NotImplemented` in case we 
-        want the containing Window to handle this event. 
- 
-    :param get_tokens: Callable that takes a `CommandLineInterface` instance 
-        and returns the list of (Token, text) tuples to be displayed right now. 
-    :param default_char: default :class:`.Char` (character and Token) to use 
-        for the background when there is more space available than `get_tokens` 
-        returns. 
-    :param get_default_char: Like `default_char`, but this is a callable that 
-        takes a :class:`prompt_toolkit.interface.CommandLineInterface` and 
-        returns a :class:`.Char` instance. 
-    :param has_focus: `bool` or `CLIFilter`, when this evaluates to `True`, 
-        this UI control will take the focus. The cursor will be shown in the 
-        upper left corner of this control, unless `get_token` returns a 
-        ``Token.SetCursorPosition`` token somewhere in the token list, then the 
-        cursor will be shown there. 
-    """ 
-    def __init__(self, get_tokens, default_char=None, get_default_char=None, 
+class TokenListControl(UIControl):
+    """
+    Control that displays a list of (Token, text) tuples.
+    (It's mostly optimized for rather small widgets, like toolbars, menus, etc...)
+
+    Mouse support:
+
+        The list of tokens can also contain tuples of three items, looking like:
+        (Token, text, handler). When mouse support is enabled and the user
+        clicks on this token, then the given handler is called. That handler
+        should accept two inputs: (CommandLineInterface, MouseEvent) and it
+        should either handle the event or return `NotImplemented` in case we
+        want the containing Window to handle this event.
+
+    :param get_tokens: Callable that takes a `CommandLineInterface` instance
+        and returns the list of (Token, text) tuples to be displayed right now.
+    :param default_char: default :class:`.Char` (character and Token) to use
+        for the background when there is more space available than `get_tokens`
+        returns.
+    :param get_default_char: Like `default_char`, but this is a callable that
+        takes a :class:`prompt_toolkit.interface.CommandLineInterface` and
+        returns a :class:`.Char` instance.
+    :param has_focus: `bool` or `CLIFilter`, when this evaluates to `True`,
+        this UI control will take the focus. The cursor will be shown in the
+        upper left corner of this control, unless `get_token` returns a
+        ``Token.SetCursorPosition`` token somewhere in the token list, then the
+        cursor will be shown there.
+    """
+    def __init__(self, get_tokens, default_char=None, get_default_char=None,
                  align_right=False, align_center=False, has_focus=False):
         assert callable(get_tokens)
-        assert default_char is None or isinstance(default_char, Char) 
-        assert get_default_char is None or callable(get_default_char) 
-        assert not (default_char and get_default_char) 
- 
-        self.align_right = to_cli_filter(align_right) 
-        self.align_center = to_cli_filter(align_center) 
-        self._has_focus_filter = to_cli_filter(has_focus) 
- 
-        self.get_tokens = get_tokens 
- 
-        # Construct `get_default_char` callable. 
-        if default_char: 
-            get_default_char = lambda _: default_char 
-        elif not get_default_char: 
+        assert default_char is None or isinstance(default_char, Char)
+        assert get_default_char is None or callable(get_default_char)
+        assert not (default_char and get_default_char)
+
+        self.align_right = to_cli_filter(align_right)
+        self.align_center = to_cli_filter(align_center)
+        self._has_focus_filter = to_cli_filter(has_focus)
+
+        self.get_tokens = get_tokens
+
+        # Construct `get_default_char` callable.
+        if default_char:
+            get_default_char = lambda _: default_char
+        elif not get_default_char:
             get_default_char = lambda _: Char(' ', Token.Transparent)
- 
-        self.get_default_char = get_default_char 
- 
+
+        self.get_default_char = get_default_char
+
         #: Cache for the content.
         self._content_cache = SimpleCache(maxsize=18)
         self._token_cache = SimpleCache(maxsize=1)
-            # Only cache one token list. We don't need the previous item. 
- 
-        # Render info for the mouse support. 
+            # Only cache one token list. We don't need the previous item.
+
+        # Render info for the mouse support.
         self._tokens = None
- 
+
     def reset(self):
         self._tokens = None
 
-    def __repr__(self): 
-        return '%s(%r)' % (self.__class__.__name__, self.get_tokens) 
- 
-    def _get_tokens_cached(self, cli): 
-        """ 
-        Get tokens, but only retrieve tokens once during one render run. 
-        (This function is called several times during one rendering, because 
-        we also need those for calculating the dimensions.) 
-        """ 
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.get_tokens)
+
+    def _get_tokens_cached(self, cli):
+        """
+        Get tokens, but only retrieve tokens once during one render run.
+        (This function is called several times during one rendering, because
+        we also need those for calculating the dimensions.)
+        """
         return self._token_cache.get(
-            cli.render_counter, lambda: self.get_tokens(cli)) 
- 
-    def has_focus(self, cli): 
-        return self._has_focus_filter(cli) 
- 
-    def preferred_width(self, cli, max_available_width): 
-        """ 
-        Return the preferred width for this control. 
-        That is the width of the longest line. 
-        """ 
+            cli.render_counter, lambda: self.get_tokens(cli))
+
+    def has_focus(self, cli):
+        return self._has_focus_filter(cli)
+
+    def preferred_width(self, cli, max_available_width):
+        """
+        Return the preferred width for this control.
+        That is the width of the longest line.
+        """
         text = token_list_to_text(self._get_tokens_cached(cli))
-        line_lengths = [get_cwidth(l) for l in text.split('\n')] 
-        return max(line_lengths) 
- 
+        line_lengths = [get_cwidth(l) for l in text.split('\n')]
+        return max(line_lengths)
+
     def preferred_height(self, cli, width, max_available_height, wrap_lines):
         content = self.create_content(cli, width, None)
         return content.line_count
- 
+
     def create_content(self, cli, width, height):
-        # Get tokens 
-        tokens_with_mouse_handlers = self._get_tokens_cached(cli) 
- 
-        default_char = self.get_default_char(cli) 
- 
-        # Wrap/align right/center parameters. 
-        right = self.align_right(cli) 
-        center = self.align_center(cli) 
- 
-        def process_line(line): 
-            " Center or right align a single line. " 
-            used_width = token_list_width(line) 
-            padding = width - used_width 
-            if center: 
-                padding = int(padding / 2) 
+        # Get tokens
+        tokens_with_mouse_handlers = self._get_tokens_cached(cli)
+
+        default_char = self.get_default_char(cli)
+
+        # Wrap/align right/center parameters.
+        right = self.align_right(cli)
+        center = self.align_center(cli)
+
+        def process_line(line):
+            " Center or right align a single line. "
+            used_width = token_list_width(line)
+            padding = width - used_width
+            if center:
+                padding = int(padding / 2)
             return [(default_char.token, default_char.char * padding)] + line
- 
-        if right or center: 
+
+        if right or center:
             token_lines_with_mouse_handlers = []
 
-            for line in split_lines(tokens_with_mouse_handlers): 
+            for line in split_lines(tokens_with_mouse_handlers):
                 token_lines_with_mouse_handlers.append(process_line(line))
         else:
             token_lines_with_mouse_handlers = list(split_lines(tokens_with_mouse_handlers))
- 
-        # Strip mouse handlers from tokens. 
+
+        # Strip mouse handlers from tokens.
         token_lines = [
             [tuple(item[:2]) for item in line]
             for line in token_lines_with_mouse_handlers
         ]
- 
+
         # Keep track of the tokens with mouse handler, for later use in
         # `mouse_handler`.
-        self._tokens = tokens_with_mouse_handlers 
- 
+        self._tokens = tokens_with_mouse_handlers
+
         # If there is a `Token.SetCursorPosition` in the token list, set the
         # cursor position here.
         def get_cursor_position():
             SetCursorPosition = Token.SetCursorPosition
- 
+
             for y, line in enumerate(token_lines):
                 x = 0
                 for token, text in line:
@@ -302,38 +302,38 @@ class TokenListControl(UIControl):
                         return Point(x=x, y=y)
                     x += len(text)
             return None
- 
+
         # Create content, or take it from the cache.
         key = (default_char.char, default_char.token,
                 tuple(tokens_with_mouse_handlers), width, right, center)
- 
+
         def get_content():
             return UIContent(get_line=lambda i: token_lines[i],
                              line_count=len(token_lines),
                              default_char=default_char,
                              cursor_position=get_cursor_position())
- 
+
         return self._content_cache.get(key, get_content)
 
-    @classmethod 
-    def static(cls, tokens): 
-        def get_static_tokens(cli): 
-            return tokens 
-        return cls(get_static_tokens) 
- 
-    def mouse_handler(self, cli, mouse_event): 
-        """ 
-        Handle mouse events. 
- 
-        (When the token list contained mouse handlers and the user clicked on 
-        on any of these, the matching handler is called. This handler can still 
-        return `NotImplemented` in case we want the `Window` to handle this 
-        particular event.) 
-        """ 
+    @classmethod
+    def static(cls, tokens):
+        def get_static_tokens(cli):
+            return tokens
+        return cls(get_static_tokens)
+
+    def mouse_handler(self, cli, mouse_event):
+        """
+        Handle mouse events.
+
+        (When the token list contained mouse handlers and the user clicked on
+        on any of these, the matching handler is called. This handler can still
+        return `NotImplemented` in case we want the `Window` to handle this
+        particular event.)
+        """
         if self._tokens:
             # Read the generator.
             tokens_for_line = list(split_lines(self._tokens))
- 
+
             try:
                 tokens = tokens_for_line[mouse_event.position.y]
             except IndexError:
@@ -342,38 +342,38 @@ class TokenListControl(UIControl):
                 # Find position in the token list.
                 xpos = mouse_event.position.x
 
-                # Find mouse handler for this character. 
-                count = 0 
+                # Find mouse handler for this character.
+                count = 0
                 for item in tokens:
-                    count += len(item[1]) 
+                    count += len(item[1])
                     if count >= xpos:
-                        if len(item) >= 3: 
-                            # Handler found. Call it. 
+                        if len(item) >= 3:
+                            # Handler found. Call it.
                             # (Handler can return NotImplemented, so return
                             # that result.)
-                            handler = item[2] 
+                            handler = item[2]
                             return handler(cli, mouse_event)
-                        else: 
-                            break 
- 
-        # Otherwise, don't handle here. 
-        return NotImplemented 
- 
- 
-class FillControl(UIControl): 
-    """ 
-    Fill whole control with characters with this token. 
-    (Also helpful for debugging.) 
+                        else:
+                            break
+
+        # Otherwise, don't handle here.
+        return NotImplemented
+
+
+class FillControl(UIControl):
+    """
+    Fill whole control with characters with this token.
+    (Also helpful for debugging.)
 
     :param char: :class:`.Char` instance to use for filling.
     :param get_char: A callable that takes a CommandLineInterface and returns a
         :class:`.Char` object.
-    """ 
+    """
     def __init__(self, character=None, token=Token, char=None, get_char=None):  # 'character' and 'token' parameters are deprecated.
         assert char is None or isinstance(char, Char)
         assert get_char is None or callable(get_char)
         assert not (char and get_char)
- 
+
         self.char = char
 
         if character:
@@ -391,110 +391,110 @@ class FillControl(UIControl):
             self.get_char = lambda cli: self.char
             self.char = char
 
-    def __repr__(self): 
+    def __repr__(self):
         if self.char:
             return '%s(char=%r)' % (self.__class__.__name__, self.char)
         else:
             return '%s(get_char=%r)' % (self.__class__.__name__, self.get_char)
- 
-    def reset(self): 
-        pass 
- 
-    def has_focus(self, cli): 
-        return False 
- 
+
+    def reset(self):
+        pass
+
+    def has_focus(self, cli):
+        return False
+
     def create_content(self, cli, width, height):
         def get_line(i):
             return []
- 
+
         return UIContent(
             get_line=get_line,
             line_count=100 ** 100,  # Something very big.
             default_char=self.get_char(cli))
- 
+
 
 _ProcessedLine = namedtuple('_ProcessedLine', 'tokens source_to_display display_to_source')
 
 
-class BufferControl(UIControl): 
-    """ 
-    Control for visualising the content of a `Buffer`. 
- 
-    :param input_processors: list of :class:`~prompt_toolkit.layout.processors.Processor`. 
-    :param lexer: :class:`~prompt_toolkit.layout.lexers.Lexer` instance for syntax highlighting. 
-    :param preview_search: `bool` or `CLIFilter`: Show search while typing. 
-    :param get_search_state: Callable that takes a CommandLineInterface and 
-        returns the SearchState to be used. (If not CommandLineInterface.search_state.) 
-    :param buffer_name: String representing the name of the buffer to display. 
-    :param default_char: :class:`.Char` instance to use to fill the background. This is 
-        transparent by default. 
-    :param focus_on_click: Focus this buffer when it's click, but not yet focussed. 
-    """ 
-    def __init__(self, 
-                 buffer_name=DEFAULT_BUFFER, 
-                 input_processors=None, 
-                 lexer=None, 
-                 preview_search=False, 
-                 search_buffer_name=SEARCH_BUFFER, 
-                 get_search_state=None, 
-                 menu_position=None, 
-                 default_char=None, 
-                 focus_on_click=False): 
-        assert input_processors is None or all(isinstance(i, Processor) for i in input_processors) 
-        assert menu_position is None or callable(menu_position) 
-        assert lexer is None or isinstance(lexer, Lexer) 
-        assert get_search_state is None or callable(get_search_state) 
+class BufferControl(UIControl):
+    """
+    Control for visualising the content of a `Buffer`.
+
+    :param input_processors: list of :class:`~prompt_toolkit.layout.processors.Processor`.
+    :param lexer: :class:`~prompt_toolkit.layout.lexers.Lexer` instance for syntax highlighting.
+    :param preview_search: `bool` or `CLIFilter`: Show search while typing.
+    :param get_search_state: Callable that takes a CommandLineInterface and
+        returns the SearchState to be used. (If not CommandLineInterface.search_state.)
+    :param buffer_name: String representing the name of the buffer to display.
+    :param default_char: :class:`.Char` instance to use to fill the background. This is
+        transparent by default.
+    :param focus_on_click: Focus this buffer when it's click, but not yet focussed.
+    """
+    def __init__(self,
+                 buffer_name=DEFAULT_BUFFER,
+                 input_processors=None,
+                 lexer=None,
+                 preview_search=False,
+                 search_buffer_name=SEARCH_BUFFER,
+                 get_search_state=None,
+                 menu_position=None,
+                 default_char=None,
+                 focus_on_click=False):
+        assert input_processors is None or all(isinstance(i, Processor) for i in input_processors)
+        assert menu_position is None or callable(menu_position)
+        assert lexer is None or isinstance(lexer, Lexer)
+        assert get_search_state is None or callable(get_search_state)
         assert default_char is None or isinstance(default_char, Char)
- 
-        self.preview_search = to_cli_filter(preview_search) 
-        self.get_search_state = get_search_state 
-        self.focus_on_click = to_cli_filter(focus_on_click) 
- 
-        self.input_processors = input_processors or [] 
-        self.buffer_name = buffer_name 
-        self.menu_position = menu_position 
-        self.lexer = lexer or SimpleLexer() 
-        self.default_char = default_char or Char(token=Token.Transparent) 
-        self.search_buffer_name = search_buffer_name 
- 
+
+        self.preview_search = to_cli_filter(preview_search)
+        self.get_search_state = get_search_state
+        self.focus_on_click = to_cli_filter(focus_on_click)
+
+        self.input_processors = input_processors or []
+        self.buffer_name = buffer_name
+        self.menu_position = menu_position
+        self.lexer = lexer or SimpleLexer()
+        self.default_char = default_char or Char(token=Token.Transparent)
+        self.search_buffer_name = search_buffer_name
+
         #: Cache for the lexer.
-        #: Often, due to cursor movement, undo/redo and window resizing 
-        #: operations, it happens that a short time, the same document has to be 
-        #: lexed. This is a faily easy way to cache such an expensive operation. 
+        #: Often, due to cursor movement, undo/redo and window resizing
+        #: operations, it happens that a short time, the same document has to be
+        #: lexed. This is a faily easy way to cache such an expensive operation.
         self._token_cache = SimpleCache(maxsize=8)
- 
-        self._xy_to_cursor_position = None 
-        self._last_click_timestamp = None 
+
+        self._xy_to_cursor_position = None
+        self._last_click_timestamp = None
         self._last_get_processed_line = None
- 
-    def _buffer(self, cli): 
-        """ 
-        The buffer object that contains the 'main' content. 
-        """ 
-        return cli.buffers[self.buffer_name] 
- 
-    def has_focus(self, cli): 
-        # This control gets the focussed if the actual `Buffer` instance has the 
-        # focus or when any of the `InputProcessor` classes tells us that it 
-        # wants the focus. (E.g. in case of a reverse-search, where the actual 
-        # search buffer may not be displayed, but the "reverse-i-search" text 
-        # should get the focus.) 
-        return cli.current_buffer_name == self.buffer_name or \ 
-            any(i.has_focus(cli) for i in self.input_processors) 
- 
-    def preferred_width(self, cli, max_available_width): 
+
+    def _buffer(self, cli):
+        """
+        The buffer object that contains the 'main' content.
+        """
+        return cli.buffers[self.buffer_name]
+
+    def has_focus(self, cli):
+        # This control gets the focussed if the actual `Buffer` instance has the
+        # focus or when any of the `InputProcessor` classes tells us that it
+        # wants the focus. (E.g. in case of a reverse-search, where the actual
+        # search buffer may not be displayed, but the "reverse-i-search" text
+        # should get the focus.)
+        return cli.current_buffer_name == self.buffer_name or \
+            any(i.has_focus(cli) for i in self.input_processors)
+
+    def preferred_width(self, cli, max_available_width):
         """
         This should return the preferred width.
- 
+
         Note: We don't specify a preferred width according to the content,
               because it would be too expensive. Calculating the preferred
               width can be done by calculating the longest line, but this would
               require applying all the processors to each line. This is
               unfeasible for a larger document, and doing it for small
               documents only would result in inconsistent behaviour.
-        """ 
+        """
         return None
- 
+
     def preferred_height(self, cli, width, max_available_height, wrap_lines):
         # Calculate the content height, if it was drawn on a screen with the
         # given width.
@@ -520,15 +520,15 @@ class BufferControl(UIControl):
         return height
 
     def _get_tokens_for_line_func(self, cli, document):
-        """ 
+        """
         Create a function that returns the tokens for a given line.
         """
         # Cache using `document.text`.
         def get_tokens_for_line():
             return self.lexer.lex_document(cli, document)
- 
+
         return self._token_cache.get(document.text, get_tokens_for_line)
- 
+
     def _create_get_processed_line_func(self, cli, document):
         """
         Create a function that takes a line number of the current document and
@@ -537,15 +537,15 @@ class BufferControl(UIControl):
         """
         def transform(lineno, tokens):
             " Transform the tokens for a given line number. "
-            source_to_display_functions = [] 
-            display_to_source_functions = [] 
- 
+            source_to_display_functions = []
+            display_to_source_functions = []
+
             # Get cursor position at this line.
             if document.cursor_position_row == lineno:
                 cursor_column = document.cursor_position_col
             else:
                 cursor_column = None
- 
+
             def source_to_display(i):
                 """ Translate x position from the buffer to the x position in the
                 processed token list. """
@@ -554,28 +554,28 @@ class BufferControl(UIControl):
                 return i
 
             # Apply each processor.
-            for p in self.input_processors: 
+            for p in self.input_processors:
                 transformation = p.apply_transformation(
                     cli, document, lineno, source_to_display, tokens)
-                tokens = transformation.tokens 
- 
+                tokens = transformation.tokens
+
                 if cursor_column:
                     cursor_column = transformation.source_to_display(cursor_column)
- 
+
                 display_to_source_functions.append(transformation.display_to_source)
                 source_to_display_functions.append(transformation.source_to_display)
- 
+
             def display_to_source(i):
-                for f in reversed(display_to_source_functions): 
+                for f in reversed(display_to_source_functions):
                     i = f(i)
                 return i
- 
+
             return _ProcessedLine(tokens, source_to_display, display_to_source)
- 
+
         def create_func():
             get_line = self._get_tokens_for_line_func(cli, document)
             cache = {}
- 
+
             def get_processed_line(i):
                 try:
                     return cache[i]
@@ -584,48 +584,48 @@ class BufferControl(UIControl):
                     cache[i] = processed_line
                     return processed_line
             return get_processed_line
- 
+
         return create_func()
- 
+
     def create_content(self, cli, width, height):
         """
         Create a UIContent.
         """
-        buffer = self._buffer(cli) 
- 
-        # Get the document to be shown. If we are currently searching (the 
-        # search buffer has focus, and the preview_search filter is enabled), 
-        # then use the search document, which has possibly a different 
-        # text/cursor position.) 
-        def preview_now(): 
-            """ True when we should preview a search. """ 
-            return bool(self.preview_search(cli) and 
-                        cli.buffers[self.search_buffer_name].text) 
- 
-        if preview_now(): 
-            if self.get_search_state: 
-                ss = self.get_search_state(cli) 
-            else: 
-                ss = cli.search_state 
- 
-            document = buffer.document_for_search(SearchState( 
-                text=cli.current_buffer.text, 
-                direction=ss.direction, 
-                ignore_case=ss.ignore_case)) 
-        else: 
-            document = buffer.document 
- 
+        buffer = self._buffer(cli)
+
+        # Get the document to be shown. If we are currently searching (the
+        # search buffer has focus, and the preview_search filter is enabled),
+        # then use the search document, which has possibly a different
+        # text/cursor position.)
+        def preview_now():
+            """ True when we should preview a search. """
+            return bool(self.preview_search(cli) and
+                        cli.buffers[self.search_buffer_name].text)
+
+        if preview_now():
+            if self.get_search_state:
+                ss = self.get_search_state(cli)
+            else:
+                ss = cli.search_state
+
+            document = buffer.document_for_search(SearchState(
+                text=cli.current_buffer.text,
+                direction=ss.direction,
+                ignore_case=ss.ignore_case))
+        else:
+            document = buffer.document
+
         get_processed_line = self._create_get_processed_line_func(cli, document)
         self._last_get_processed_line = get_processed_line
- 
+
         def translate_rowcol(row, col):
             " Return the content column for this coordinate. "
             return Point(y=row, x=get_processed_line(row).source_to_display(col))
- 
+
         def get_line(i):
             " Return the tokens for a given line number. "
             tokens = get_processed_line(i).tokens
- 
+
             # Add a space at the end, because that is a possible cursor
             # position. (When inserting after the input.) We should do this on
             # all the lines, not just the line containing the cursor. (Because
@@ -633,60 +633,60 @@ class BufferControl(UIControl):
             # cursor around.)
             tokens = tokens + [(self.default_char.token, ' ')]
             return tokens
- 
+
         content = UIContent(
             get_line=get_line,
             line_count=document.line_count,
             cursor_position=translate_rowcol(document.cursor_position_row,
                                              document.cursor_position_col),
             default_char=self.default_char)
- 
-        # If there is an auto completion going on, use that start point for a 
-        # pop-up menu position. (But only when this buffer has the focus -- 
-        # there is only one place for a menu, determined by the focussed buffer.) 
-        if cli.current_buffer_name == self.buffer_name: 
-            menu_position = self.menu_position(cli) if self.menu_position else None 
-            if menu_position is not None: 
-                assert isinstance(menu_position, int) 
+
+        # If there is an auto completion going on, use that start point for a
+        # pop-up menu position. (But only when this buffer has the focus --
+        # there is only one place for a menu, determined by the focussed buffer.)
+        if cli.current_buffer_name == self.buffer_name:
+            menu_position = self.menu_position(cli) if self.menu_position else None
+            if menu_position is not None:
+                assert isinstance(menu_position, int)
                 menu_row, menu_col = buffer.document.translate_index_to_position(menu_position)
                 content.menu_position = translate_rowcol(menu_row, menu_col)
-            elif buffer.complete_state: 
-                # Position for completion menu. 
-                # Note: We use 'min', because the original cursor position could be 
-                #       behind the input string when the actual completion is for 
-                #       some reason shorter than the text we had before. (A completion 
-                #       can change and shorten the input.) 
+            elif buffer.complete_state:
+                # Position for completion menu.
+                # Note: We use 'min', because the original cursor position could be
+                #       behind the input string when the actual completion is for
+                #       some reason shorter than the text we had before. (A completion
+                #       can change and shorten the input.)
                 menu_row, menu_col = buffer.document.translate_index_to_position(
-                    min(buffer.cursor_position, 
-                        buffer.complete_state.original_document.cursor_position)) 
+                    min(buffer.cursor_position,
+                        buffer.complete_state.original_document.cursor_position))
                 content.menu_position = translate_rowcol(menu_row, menu_col)
-            else: 
+            else:
                 content.menu_position = None
- 
+
         return content
- 
-    def mouse_handler(self, cli, mouse_event): 
-        """ 
-        Mouse handler for this control. 
-        """ 
-        buffer = self._buffer(cli) 
-        position = mouse_event.position 
- 
-        # Focus buffer when clicked. 
-        if self.has_focus(cli): 
+
+    def mouse_handler(self, cli, mouse_event):
+        """
+        Mouse handler for this control.
+        """
+        buffer = self._buffer(cli)
+        position = mouse_event.position
+
+        # Focus buffer when clicked.
+        if self.has_focus(cli):
             if self._last_get_processed_line:
                 processed_line = self._last_get_processed_line(position.y)
 
-                # Translate coordinates back to the cursor position of the 
-                # original input. 
+                # Translate coordinates back to the cursor position of the
+                # original input.
                 xpos = processed_line.display_to_source(position.x)
                 index = buffer.document.translate_row_col_to_index(position.y, xpos)
- 
-                # Set the cursor position. 
+
+                # Set the cursor position.
                 if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
                     buffer.exit_selection()
                     buffer.cursor_position = index
- 
+
                 elif mouse_event.event_type == MouseEventType.MOUSE_UP:
                     # When the cursor was moved to another place, select the text.
                     # (The >1 is actually a small but acceptable workaround for
@@ -696,12 +696,12 @@ class BufferControl(UIControl):
                     if abs(buffer.cursor_position - index) > 1:
                         buffer.start_selection(selection_type=SelectionType.CHARACTERS)
                         buffer.cursor_position = index
- 
+
                     # Select word around cursor on double click.
                     # Two MOUSE_UP events in a short timespan are considered a double click.
                     double_click = self._last_click_timestamp and time.time() - self._last_click_timestamp < .3
                     self._last_click_timestamp = time.time()
- 
+
                     if double_click:
                         start, end = buffer.document.find_boundaries_of_current_word()
                         buffer.cursor_position += start
@@ -710,21 +710,21 @@ class BufferControl(UIControl):
                 else:
                     # Don't handle scroll events here.
                     return NotImplemented
- 
-        # Not focussed, but focussing on click events. 
-        else: 
+
+        # Not focussed, but focussing on click events.
+        else:
             if self.focus_on_click(cli) and mouse_event.event_type == MouseEventType.MOUSE_UP:
-                # Focus happens on mouseup. (If we did this on mousedown, the 
-                # up event will be received at the point where this widget is 
-                # focussed and be handled anyway.) 
-                cli.focus(self.buffer_name) 
-            else: 
-                return NotImplemented 
- 
-    def move_cursor_down(self, cli): 
-        b = self._buffer(cli) 
-        b.cursor_position += b.document.get_cursor_down_position() 
- 
-    def move_cursor_up(self, cli): 
-        b = self._buffer(cli) 
-        b.cursor_position += b.document.get_cursor_up_position() 
+                # Focus happens on mouseup. (If we did this on mousedown, the
+                # up event will be received at the point where this widget is
+                # focussed and be handled anyway.)
+                cli.focus(self.buffer_name)
+            else:
+                return NotImplemented
+
+    def move_cursor_down(self, cli):
+        b = self._buffer(cli)
+        b.cursor_position += b.document.get_cursor_down_position()
+
+    def move_cursor_up(self, cli):
+        b = self._buffer(cli)
+        b.cursor_position += b.document.get_cursor_up_position()