text: from typing import Any, Optional
  
  from prompt_toolkit.application.current import get_app
  from prompt_toolkit.buffer import Buffer
  from prompt_toolkit.enums import SYSTEM_BUFFER
  from prompt_toolkit.filters import (
      Condition,
      FilterOrBool,
      emacs_mode,
      has_arg,
      has_completions,
      has_focus,
      has_validation_error,
      to_filter,
      vi_mode,
      vi_navigation_mode,
  )
  from prompt_toolkit.formatted_text import (
      AnyFormattedText,
      StyleAndTextTuples,
      fragment_list_len,
      to_formatted_text,
  )
  from prompt_toolkit.key_binding.key_bindings import (
      ConditionalKeyBindings,
      KeyBindings,
      KeyBindingsBase,
      merge_key_bindings,
  )
  from prompt_toolkit.key_binding.key_processor import KeyPressEvent
  from prompt_toolkit.key_binding.vi_state import InputMode
  from prompt_toolkit.keys import Keys
  from prompt_toolkit.layout.containers import ConditionalContainer, Container, Window
  from prompt_toolkit.layout.controls import (
      BufferControl,
      FormattedTextControl,
      SearchBufferControl,
      UIContent,
      UIControl,
  )
  from prompt_toolkit.layout.dimension import Dimension
  from prompt_toolkit.layout.processors import BeforeInput
  from prompt_toolkit.lexers import SimpleLexer
  from prompt_toolkit.search import SearchDirection
  
  __all__ = [
      "ArgToolbar",
      "CompletionsToolbar",
      "FormattedTextToolbar",
      "SearchToolbar",
      "SystemToolbar",
      "ValidationToolbar",
  ]
  
  E = KeyPressEvent
  
  
  class FormattedTextToolbar(Window):
      def __init__(self, text: AnyFormattedText, style: str = "", **kw: Any) -> None:
          # Note: The style needs to be applied to the toolbar as a whole, not
          #       just the `FormattedTextControl`.
          super().__init__(
              FormattedTextControl(text, **kw),
              style=style,
              dont_extend_height=True,
              height=Dimension(min=1),
          )
  
  
  class SystemToolbar:
      """
      Toolbar for a system prompt.
  
      :param prompt: Prompt to be displayed to the user.
      """
  
      def __init__(
          self,
          prompt: AnyFormattedText = "Shell command: ",
          enable_global_bindings: FilterOrBool = True,
      ) -> None:
  
          self.prompt = prompt
          self.enable_global_bindings = to_filter(enable_global_bindings)
  
          self.system_buffer = Buffer(name=SYSTEM_BUFFER)
  
          self._bindings = self._build_key_bindings()
  
          self.buffer_control = BufferControl(
              buffer=self.system_buffer,
              lexer=SimpleLexer(style="class:system-toolbar.text"),
              input_processors=[
                  BeforeInput(lambda: self.prompt, style="class:system-toolbar")
              ],
              key_bindings=self._bindings,
          )
  
          self.window = Window(
              self.buffer_control, height=1, style="class:system-toolbar"
          )
  
          self.container = ConditionalContainer(
              content=self.window, filter=has_focus(self.system_buffer)
          )
  
      def _get_display_before_text(self) -> StyleAndTextTuples:
          return [
              ("class:system-toolbar", "Shell command: "),
              ("class:system-toolbar.text", self.system_buffer.text),
              ("", "\n"),
          ]
  
      def _build_key_bindings(self) -> KeyBindingsBase:
          focused = has_focus(self.system_buffer)
  
          # Emacs
          emacs_bindings = KeyBindings()
          handle = emacs_bindings.add
  
          @handle("escape", filter=focused)
          @handle("c-g", filter=focused)
          @handle("c-c", filter=focused)
          def _cancel(event: E) -> None:
              "Hide system prompt."
              self.system_buffer.reset()
              event.app.layout.focus_last()
  
          @handle("enter", filter=focused)
          async def _accept(event: E) -> None:
              "Run system command."
              await event.app.run_system_command(
                  self.system_buffer.text,
                  display_before_text=self._get_display_before_text(),
              )
              self.system_buffer.reset(append_to_history=True)
              event.app.layout.focus_last()
  
          # Vi.
          vi_bindings = KeyBindings()
          handle = vi_bindings.add
  
          @handle("escape", filter=focused)
          @handle("c-c", filter=focused)
          def _cancel_vi(event: E) -> None:
              "Hide system prompt."
              event.app.vi_state.input_mode = InputMode.NAVIGATION
              self.system_buffer.reset()
              event.app.layout.focus_last()
  
          @handle("enter", filter=focused)
          async def _accept_vi(event: E) -> None:
              "Run system command."
              event.app.vi_state.input_mode = InputMode.NAVIGATION
              await event.app.run_system_command(
                  self.system_buffer.text,
                  display_before_text=self._get_display_before_text(),
              )
              self.system_buffer.reset(append_to_history=True)
              event.app.layout.focus_last()
  
          # Global bindings. (Listen to these bindings, even when this widget is
          # not focussed.)
          global_bindings = KeyBindings()
          handle = global_bindings.add
  
          @handle(Keys.Escape, "!", filter=~focused & emacs_mode, is_global=True)
          def _focus_me(event: E) -> None:
              "M-'!' will focus this user control."
              event.app.layout.focus(self.window)
  
          @handle("!", filter=~focused & vi_mode & vi_navigation_mode, is_global=True)
          def _focus_me_vi(event: E) -> None:
              "Focus."
              event.app.vi_state.input_mode = InputMode.INSERT
              event.app.layout.focus(self.window)
  
          return merge_key_bindings(
              [
                  ConditionalKeyBindings(emacs_bindings, emacs_mode),
                  ConditionalKeyBindings(vi_bindings, vi_mode),
                  ConditionalKeyBindings(global_bindings, self.enable_global_bindings),
              ]
          )
  
      def __pt_container__(self) -> Container:
          return self.container
  
  
  class ArgToolbar:
      def __init__(self) -> None:
          def get_formatted_text() -> StyleAndTextTuples:
              arg = get_app().key_processor.arg or ""
              if arg == "-":
                  arg = "-1"
  
              return [
                  ("class:arg-toolbar", "Repeat: "),
                  ("class:arg-toolbar.text", arg),
              ]
  
          self.window = Window(FormattedTextControl(get_formatted_text), height=1)
  
          self.container = ConditionalContainer(content=self.window, filter=has_arg)
  
      def __pt_container__(self) -> Container:
          return self.container
  
  
  class SearchToolbar:
      """
      :param vi_mode: Display '/' and '?' instead of I-search.
      :param ignore_case: Search case insensitive.
      """
  
      def __init__(
          self,
          search_buffer: Optional[Buffer] = None,
          vi_mode: bool = False,
          text_if_not_searching: AnyFormattedText = "",
          forward_search_prompt: AnyFormattedText = "I-search: ",
          backward_search_prompt: AnyFormattedText = "I-search backward: ",
          ignore_case: FilterOrBool = False,
      ) -> None:
  
          if search_buffer is None:
              search_buffer = Buffer()
  
          @Condition
          def is_searching() -> bool:
              return self.control in get_app().layout.search_links
  
          def get_before_input() -> AnyFormattedText:
              if not is_searching():
                  return text_if_not_searching
              elif (
                  self.control.searcher_search_state.direction == SearchDirection.BACKWARD
              ):
                  return "?" if vi_mode else backward_search_prompt
              else:
                  return "/" if vi_mode else forward_search_prompt
  
          self.search_buffer = search_buffer
  
          self.control = SearchBufferControl(
              buffer=search_buffer,
              input_processors=[
                  BeforeInput(get_before_input, style="class:search-toolbar.prompt")
              ],
              lexer=SimpleLexer(style="class:search-toolbar.text"),
              ignore_case=ignore_case,
          )
  
          self.container = ConditionalContainer(
              content=Window(self.control, height=1, style="class:search-toolbar"),
              filter=is_searching,
          )
  
      def __pt_container__(self) -> Container:
          return self.container
  
  
  class _CompletionsToolbarControl(UIControl):
      def create_content(self, width: int, height: int) -> UIContent:
          all_fragments: StyleAndTextTuples = []
  
          complete_state = get_app().current_buffer.complete_state
          if complete_state:
              completions = complete_state.completions
              index = complete_state.complete_index  # Can be None!
  
              # Width of the completions without the left/right arrows in the margins.
              content_width = width - 6
  
              # Booleans indicating whether we stripped from the left/right
              cut_left = False
              cut_right = False
  
              # Create Menu content.
              fragments: StyleAndTextTuples = []
  
              for i, c in enumerate(completions):
                  # When there is no more place for the next completion
                  if fragment_list_len(fragments) + len(c.display_text) >= content_width:
                      # If the current one was not yet displayed, page to the next sequence.
                      if i <= (index or 0):
                          fragments = []
                          cut_left = True
                      # If the current one is visible, stop here.
                      else:
                          cut_right = True
                          break
  
                  fragments.extend(
                      to_formatted_text(
                          c.display_text,
                          style=(
                              "class:completion-toolbar.completion.current"
                              if i == index
                              else "class:completion-toolbar.completion"
                          ),
                      )
                  )
                  fragments.append(("", " "))
  
              # Extend/strip until the content width.
              fragments.append(("", " " * (content_width - fragment_list_len(fragments))))
              fragments = fragments[:content_width]
  
              # Return fragments
              all_fragments.append(("", " "))
              all_fragments.append(
                  ("class:completion-toolbar.arrow", "<" if cut_left else " ")
              )
              all_fragments.append(("", " "))
  
              all_fragments.extend(fragments)
  
              all_fragments.append(("", " "))
              all_fragments.append(
                  ("class:completion-toolbar.arrow", ">" if cut_right else " ")
              )
              all_fragments.append(("", " "))
  
          def get_line(i: int) -> StyleAndTextTuples:
              return all_fragments
  
          return UIContent(get_line=get_line, line_count=1)
  
  
  class CompletionsToolbar:
      def __init__(self) -> None:
          self.container = ConditionalContainer(
              content=Window(
                  _CompletionsToolbarControl(), height=1, style="class:completion-toolbar"
              ),
              filter=has_completions,
          )
  
      def __pt_container__(self) -> Container:
          return self.container
  
  
  class ValidationToolbar:
      def __init__(self, show_position: bool = False) -> None:
          def get_formatted_text() -> StyleAndTextTuples:
              buff = get_app().current_buffer
  
              if buff.validation_error:
                  row, column = buff.document.translate_index_to_position(
                      buff.validation_error.cursor_position
                  )
  
                  if show_position:
                      text = "{} (line={} column={})".format(
                          buff.validation_error.message,
                          row + 1,
                          column + 1,
                      )
                  else:
                      text = buff.validation_error.message
  
                  return [("class:validation-toolbar", text)]
              else:
                  return []
  
          self.control = FormattedTextControl(get_formatted_text)
  
          self.container = ConditionalContainer(
              content=Window(self.control, height=1), filter=has_validation_error
          )
  
      def __pt_container__(self) -> Container:
          return self.container
  