textbringer 1.0.1 → 1.1.0

data/lib/textbringer/commands/isearch.rb

@@ -1,6 +1,6 @@
 module Textbringer
   module Commands
-    ISEARCH_MODE_MAP = Keymap.new
+    define_keymap :ISEARCH_MODE_MAP
     (?\x20..?\x7e).each do |c|
       ISEARCH_MODE_MAP.define_key(c, :isearch_printing_char)
     end
@@ -14,11 +14,14 @@ module Commands
     end
     ISEARCH_MODE_MAP.define_key(:backspace, :isearch_delete_char)
     ISEARCH_MODE_MAP.define_key(?\C-h, :isearch_delete_char)
+    ISEARCH_MODE_MAP.define_key(?\C-?, :isearch_delete_char)
     ISEARCH_MODE_MAP.define_key(?\C-s, :isearch_repeat_forward)
     ISEARCH_MODE_MAP.define_key(?\C-r, :isearch_repeat_backward)
     ISEARCH_MODE_MAP.define_key(?\C-w, :isearch_yank_word_or_char)
     ISEARCH_MODE_MAP.define_key(?\C-m, :isearch_exit)
     ISEARCH_MODE_MAP.define_key(?\C-g, :isearch_abort)
+    ISEARCH_MODE_MAP.define_key(?\C-q, :isearch_quoted_insert)
+    ISEARCH_MODE_MAP.define_key(?\C-\\, :isearch_toggle_input_method)
 
     ISEARCH_STATUS = {
       forward: true,
@@ -55,6 +58,10 @@ def isearch_mode(forward, recursive_edit: false)
       end
     end
 
+    def isearch_mode?
+      Controller.current.overriding_map == ISEARCH_MODE_MAP
+    end
+
     def isearch_prompt
       if ISEARCH_STATUS[:forward]
         "I-search: "
@@ -114,6 +121,14 @@ def isearch_done
       end
     end
 
+    define_command(:isearch_quoted_insert, doc: <<~EOD) do
+        Read a character, and add it to the search string and search.
+      EOD
+      c = Controller.current.read_event
+      ISEARCH_STATUS[:string].concat(c)
+      isearch_search
+    end
+
     def isearch_search
       forward = ISEARCH_STATUS[:forward]
       options = if /\A[A-Z]/.match?(ISEARCH_STATUS[:string])
@@ -124,7 +139,7 @@ def isearch_search
       re = Regexp.new(Regexp.quote(ISEARCH_STATUS[:string]), options)
       last_pos = ISEARCH_STATUS[:last_pos]
       offset = forward ? last_pos : last_pos - ISEARCH_STATUS[:string].bytesize
-      if Buffer.current.byteindex(forward, re, offset)
+      if offset >= 0 && Buffer.current.byteindex(forward, re, offset)
         if Buffer.current != Buffer.minibuffer
           message(isearch_prompt + ISEARCH_STATUS[:string], log: false)
         end
@@ -155,5 +170,11 @@ def isearch_repeat(forward)
       end
       isearch_search
     end
+
+    define_command(:isearch_toggle_input_method,
+                   doc: "Toggle input method.") do
+      toggle_input_method
+      message(isearch_prompt + ISEARCH_STATUS[:string], log: false)
+    end
   end
 end

data/lib/textbringer/commands/misc.rb

@@ -6,7 +6,12 @@ module Commands
     end
 
     define_command(:exit_textbringer) do |status = 0|
-      if Buffer.any? { |buffer| /\A\*/ !~ buffer.name && buffer.modified? }
+      unsaved_buffers = Buffer.filter { |buffer|
+        /\A\*/ !~ buffer.name && buffer.modified?
+      }
+      if !unsaved_buffers.empty?
+        list_buffers(unsaved_buffers)
+        Window.redisplay
         return unless yes_or_no?("Unsaved buffers exist; exit anyway?")
       end
       exit(status)
@@ -139,7 +144,7 @@ def complete_minibuffer_with_string(s)
       end
     end
 
-    UNIVERSAL_ARGUMENT_MAP = Keymap.new
+    define_keymap :UNIVERSAL_ARGUMENT_MAP
     (?0..?9).each do |c|
       UNIVERSAL_ARGUMENT_MAP.define_key(c, :digit_argument)
       GLOBAL_MAP.define_key("\e#{c}", :digit_argument)
@@ -276,7 +281,7 @@ def goto_global_mark
       Window.redisplay
       signals = [:INT, :TERM, :KILL]
       begin
-        opts = /mswin32|mingw32/ =~ RUBY_PLATFORM ? {} : {pgroup: true}
+        opts = /mswin|mingw/ =~ RUBY_PLATFORM ? {} : {pgroup: true}
         if CONFIG[:shell_file_name]
           cmd = [CONFIG[:shell_file_name], CONFIG[:shell_command_switch], cmd]
         end

data/lib/textbringer/commands/windows.rb

@@ -69,9 +69,13 @@ module Commands
     define_command(:switch_to_buffer, doc: <<~EOD) do
         Display buffer in the current window.
       EOD
-      |buffer = read_buffer("Switch to buffer: ")|
+      |buffer = read_buffer("Switch to buffer: "), arg = current_prefix_arg|
       if buffer.is_a?(String)
-        buffer = Buffer[buffer]
+        if arg
+          buffer = Buffer.find_or_new(buffer)
+        else
+          buffer = Buffer[buffer]
+        end
       end
       if buffer
         Window.current.buffer = Buffer.current = buffer
@@ -80,7 +84,7 @@ module Commands
       end
     end
 
-    define_command(:list_buffers, doc: <<~EOD) do
+    define_command(:list_buffers, doc: <<~EOD) do |buffers = Buffer.list|
         List the existing buffers.
       EOD
       buffer = Buffer.find_or_new("*Buffer List*",
@@ -88,7 +92,7 @@ module Commands
       buffer.apply_mode(BufferListMode)
       buffer.read_only_edit do
         buffer.clear
-        buffer.insert(Buffer.list.map(&:name).join("\n"))
+        buffer.insert(buffers.map(&:name).join("\n"))
         buffer.beginning_of_buffer
       end
       switch_to_buffer(buffer)

data/lib/textbringer/config.rb

@@ -15,6 +15,7 @@ module Textbringer
     shell_file_name: ENV["SHELL"],
     shell_command_switch: "-c",
     grep_command: "grep -nH -e",
-    fill_column: 70
+    fill_column: 70,
+    default_input_method: "t_code"
   }
 end

data/lib/textbringer/controller.rb

@@ -264,7 +264,13 @@ def read_event_with_keyboard_macro(read_event_method)
     end
 
     def call_read_event_method(read_event_method)
-      Window.current.send(read_event_method)
+      Window.current.send(read_event_method)&.then { |event|
+        if @key_sequence.empty?
+          Buffer.current.filter_event(event)
+        else
+          event
+        end
+      }
     end
   end
 end

data/lib/textbringer/input_method.rb

@@ -0,0 +1,63 @@
+module Textbringer
+  class InputMethod
+    extend Commands
+    include Commands
+
+    @@list = []
+
+    def self.inherited(subclass)
+      name = subclass.name.sub(/Textbringer::/, "").sub(/InputMethod/, "").
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        downcase
+      @@list.push(name)
+    end
+
+    def self.list
+      @@list
+    end
+
+    def self.find(name)
+      class_name = name.split(/_/).map(&:capitalize).join + "InputMethod"
+      Textbringer.const_get(class_name).new
+    rescue NameError
+      raise EditorError, "No such input method: #{name}"
+    end
+
+    def initialize
+      @enabled = false
+      @skip_next_event = false
+    end
+
+    def toggle
+      @enabled = !@enabled
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def filter_event(event)
+      if @enabled
+        if event == "\e"
+          @skip_next_event = true
+          event
+        elsif @skip_next_event
+          @skip_next_event = false
+          event
+        else
+          handle_event(event)
+        end
+      else
+        event
+      end
+    end
+
+    def handle_event(event)
+      raise EditorError, "subclass must override InputMethod#handle_event"
+    end
+  end
+end

data/lib/textbringer/input_methods/hiragana_input_method.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class HiraganaInputMethod < InputMethod
+    HIRAGANA_TABLE = {
+      "a" => "あ", "i" => "い", "u" => "う", "e" => "え", "o" => "お",
+      "ka" => "か", "ki" => "き", "ku" => "く", "ke" => "け", "ko" => "こ",
+      "ga" => "が", "gi" => "ぎ", "gu" => "ぐ", "ge" => "げ", "go" => "ご",
+      "sa" => "さ", "si" => "し", "su" => "す", "se" => "せ", "so" => "そ",
+      "za" => "ざ", "zi" => "じ", "zu" => "ず", "ze" => "ぜ", "zo" => "ぞ",
+      "sha" => "しゃ", "shi" => "し", "shu" => "しゅ", "she" => "しぇ", "sho" => "しょ",
+      "ja" => "じゃ", "ji" => "じ", "ju" => "じゅ", "je" => "じぇ", "jo" => "じょ",
+      "ta" => "た", "ti" => "ち", "tu" => "つ", "te" => "て", "to" => "と",
+      "da" => "だ", "di" => "ぢ", "du" => "づ", "de" => "で", "do" => "ど",
+      "cha" => "ちゃ", "chi" => "ち", "chu" => "ちゅ", "che" => "ちぇ", "cho" => "ちょ",
+      "na" => "な", "ni" => "に", "nu" => "ぬ", "ne" => "ね", "no" => "の",
+      "ha" => "は", "hi" => "ひ", "hu" => "ふ", "he" => "へ", "ho" => "ほ",
+      "ba" => "ば", "bi" => "び", "bu" => "ぶ", "be" => "べ", "bo" => "ぼ",
+      "pa" => "ぱ", "pi" => "ぴ", "pu" => "ぷ", "pe" => "ぺ", "po" => "ぽ",
+      "ma" => "ま", "mi" => "み", "mu" => "む", "me" => "め", "mo" => "も",
+      "ya" => "や", "yi" => "い", "yu" => "ゆ", "ye" => "いぇ", "yo" => "よ",
+      "ra" => "ら", "ri" => "り", "ru" => "る", "re" => "れ", "ro" => "ろ",
+      "wa" => "わ", "wi" => "ゐ", "wu" => "う", "we" => "ゑ", "wo" => "を",
+      "nn" => "ん"
+    }
+    HIRAGANA_PREFIXES = HIRAGANA_TABLE.keys.flat_map { |s|
+      (s.size - 1).times.map { |i| s[0, i + 1] }
+    }.uniq
+
+    def initialize
+      super
+      @input_buffer = +""
+    end
+
+    def status
+      "あ"
+    end
+
+    def handle_event(event)
+      if !event.is_a?(String)
+        if !@input_buffer.empty?
+          @input_buffer = +""
+        end
+        return event
+      end
+      @input_buffer << event
+      s = HIRAGANA_TABLE[@input_buffer]
+      if s
+        return flush(s)
+      end
+      if HIRAGANA_PREFIXES.include?(@input_buffer)
+        return nil
+      end
+      flush(@input_buffer)
+    end
+
+    def flush(s)
+      if !@input_buffer.empty?
+        @input_buffer = +""
+      end
+      if s.size == 1
+        s
+      else
+        Buffer.current.insert(s)
+        Window.redisplay
+        nil
+      end
+    end
+  end
+end

data/lib/textbringer/input_methods/t_code_input_method.rb

@@ -0,0 +1,458 @@
+module Textbringer
+  class TCodeInputMethod < InputMethod
+    require_relative "t_code_input_method/tables"
+
+    data_dir = File.expand_path("t_code_input_method", __dir__)
+    BUSHU_PATH = File.expand_path("bushu.rev", data_dir)
+    BUSHU_DIC = {} unless defined?(BUSHU_DIC)
+    MAZEGAKI_PATH = File.expand_path("mazegaki.dic", data_dir)
+    MAZEGAKI_DIC = {} unless defined?(MAZEGAKI_DIC)
+    MAZEGAKI_MAX_WORD_LEN = 12 # じょうほうしょりがっかい
+    MAZEGAKI_MAX_SUFFIX_LEN = 4
+
+    def initialize
+      super
+      @prev_key_index = nil
+      @mazegaki_start_pos = nil
+      @mazegaki_candidates = nil
+      @delete_help_window = false
+      @help_window = nil
+      @prev_buffer = nil
+      setup_dictionaries
+    end
+
+    def setup_dictionaries
+      data_dir = CONFIG[:t_code_data_dir] ||
+        File.expand_path("~/.textbringer/tcode")
+      bushu_path = File.join(data_dir, "bushu.rev")
+      mazegaki_path = File.join(data_dir, "mazegaki.dic")
+      if BUSHU_DIC.empty?
+        File.open(bushu_path) do |f|
+          f.each_line do |line|
+            x, *xs = line.chomp.chars
+            BUSHU_DIC[xs.sort.join] = x
+          end
+        end
+      end
+      if MAZEGAKI_DIC.empty?
+        File.open(mazegaki_path) do |f|
+          f.each_line do |line|
+            x, y = line.split
+            MAZEGAKI_DIC[x] = y
+          end
+        end
+      end
+    end
+
+    def status
+      "漢"
+    end
+
+    def handle_event(event)
+      key_index = KEY_TABLE[event]
+      if @mazegaki_start_pos
+        if process_mazegaki_conversion(event, key_index)
+          return nil
+        end
+      end
+      if key_index.nil?
+        @prev_key_index = nil
+        return event
+      end
+      if @prev_key_index.nil?
+        @prev_key_index = key_index
+        nil
+      else
+        c = KANJI_TABLE[key_index][@prev_key_index]
+        @prev_key_index = nil
+        case c
+        when ?■
+          nil
+        when ?◆
+          bushu_compose
+        when ?◇
+          start_mazegaki_conversion(false)
+        when ?◈
+          start_mazegaki_conversion(true)
+        when ?⑤
+          show_stroke
+        else
+          c
+        end
+      end
+    end
+
+    def with_target_buffer(&block)
+      if isearch_mode?
+        @isearch_buffer ||= Buffer.new
+        if @isearch_buffer.to_s != ISEARCH_STATUS[:string]
+          @isearch_buffer.replace(ISEARCH_STATUS[:string])
+        end
+        block.call(@isearch_buffer)
+        ISEARCH_STATUS[:string] = @isearch_buffer.to_s
+        if Buffer.current != Buffer.minibuffer
+          message(isearch_prompt + ISEARCH_STATUS[:string], log: false)
+          Window.redisplay
+        end
+      else
+        block.call(Buffer.current)
+      end
+    end
+
+    def bushu_compose
+      with_target_buffer do |buffer|
+        pos = buffer.point
+        s = 2.times.map {
+          buffer.backward_char
+          buffer.char_after
+        }.sort.join
+        c = BUSHU_DIC[s]
+        if c
+          buffer.replace(c, start: buffer.point, end: pos)
+        else
+          buffer.goto_char(pos)
+        end
+      end
+      isearch_search if isearch_mode?
+      Window.redisplay
+      nil
+    end
+
+    def start_mazegaki_conversion(with_inflection = false)
+      @mazegaki_convert_with_inflection = with_inflection
+      pos, yomi = find_mazegaki_start_pos(with_inflection)
+      if pos.nil?
+        raise EditorError, "No mazegaki conversion candidate"
+      end
+      mazegaki_convert(pos, yomi)
+    end
+
+    def mazegaki_convert(pos, yomi)
+      with_target_buffer do |buffer|
+        candidates = mazegaki_lookup_candidates(yomi)
+        if candidates
+          @mazegaki_yomi = yomi
+          @mazegaki_suffix = buffer.substring(pos + yomi.bytesize,
+                                              buffer.point)
+          case candidates.size
+          when 1
+            buffer.composite_edit do
+              buffer.delete_region(pos, buffer.point)
+              buffer.insert("△" + candidates[0] + @mazegaki_suffix)
+            end
+          when 2
+            buffer.composite_edit do
+              buffer.delete_region(pos, buffer.point)
+              buffer.insert("△{" + candidates.join(",") + "}" +
+                            @mazegaki_suffix)
+            end
+          else
+            buffer.save_excursion do
+              buffer.goto_char(pos)
+              buffer.insert("△")
+            end
+          end
+          @mazegaki_start_pos = pos
+          @mazegaki_candidates = candidates
+          @mazegaki_candidates_page = 0
+          if candidates.size > 2
+            show_mazegaki_candidates
+          end
+        end
+        Window.redisplay
+        nil
+      end
+    end
+
+    def mazegaki_lookup_yomi(s, with_inflectin)
+      if !with_inflectin
+        return MAZEGAKI_DIC.key?(s) ? s : nil
+      end
+      yomi = s.sub(/\p{hiragana}\z/, "")
+      (MAZEGAKI_MAX_SUFFIX_LEN + 1).times do
+        return yomi if MAZEGAKI_DIC.key?(yomi + "—")
+        break if !yomi.sub!(/\p{hiragana}\z/, "")
+      end
+      nil
+    end
+
+    def mazegaki_lookup_candidates(yomi)
+      if @mazegaki_convert_with_inflection
+        s = yomi + "—"
+      else
+        s = yomi
+      end
+      c = MAZEGAKI_DIC[s]
+      return nil if c.nil?
+      candidates = c.split("/").map { |i|
+        i.sub(/;.*/, "")
+      }.reject(&:empty?)
+      return nil if candidates.empty?
+      candidates
+    end
+
+    def find_mazegaki_start_pos(with_inflection)
+      with_target_buffer do |buffer|
+        buffer.save_excursion do
+          pos = buffer.point
+          start_pos = nil
+          yomi = nil
+          MAZEGAKI_MAX_WORD_LEN.times do
+            break if buffer.beginning_of_buffer?
+            buffer.backward_char
+            s = buffer.substring(buffer.point, pos)
+            y = mazegaki_lookup_yomi(s, with_inflection)
+            if y
+              start_pos = buffer.point
+              yomi = y
+            end
+          end
+          return start_pos, yomi
+        end
+      end
+    end
+
+    def process_mazegaki_conversion(event, key_index)
+      case event
+      when " "
+        mazegaki_next_page
+        return true
+      when "<"
+        mazegaki_relimit_left
+        return true
+      when ">"
+        mazegaki_relimit_right
+        return true
+      end
+      begin
+        if @mazegaki_candidates.size == 1
+          if event == "\C-m"
+            mazegaki_finish(@mazegaki_candidates[0])
+            return true
+          elsif key_index
+            mazegaki_finish(@mazegaki_candidates[0])
+            return false
+          end
+        elsif key_index
+          mazegaki_limit = MAZEGAKI_STROKE_PRIORITY_LIST.size
+          i = MAZEGAKI_STROKE_PRIORITY_LIST.index(key_index)
+          if i
+            offset = @mazegaki_candidates_page * mazegaki_limit + i
+            c = @mazegaki_candidates[offset]
+            if c
+              mazegaki_finish(c)
+              return true
+            end
+          end
+        end
+        mazegaki_reset
+        true
+      ensure
+        @mazegaki_start_pos = nil
+        @mazegaki_candidates = nil
+        Window.redisplay
+      end
+    end
+
+    def mazegaki_reset
+      with_target_buffer do |buffer|
+        buffer.undo
+        pos = @mazegaki_start_pos +
+          @mazegaki_yomi.bytesize + @mazegaki_suffix.bytesize
+        buffer.goto_char(pos)
+        hide_help_window
+      end
+    end
+
+    def mazegaki_finish(s)
+      mazegaki_reset
+      with_target_buffer do |buffer|
+        buffer.composite_edit do
+          buffer.delete_region(@mazegaki_start_pos, buffer.point)
+          buffer.insert(s + @mazegaki_suffix)
+        end
+      end
+      isearch_search if isearch_mode?
+    end
+
+    def hide_help_window
+      if @delete_help_window
+        Window.delete_window(@help_window)
+      elsif @prev_buffer
+        @help_window.buffer = @prev_buffer
+      end
+      @delete_help_window = false
+      @help_window = nil
+      @prev_buffer = nil
+    end
+
+    def mazegaki_next_page
+      if @mazegaki_candidates.size <= mazegaki_limit
+        return
+      end
+      @mazegaki_candidates_page += 1
+      if @mazegaki_candidates_page * mazegaki_limit >
+          @mazegaki_candidates.size
+        @mazegaki_candidates_page = 0
+      end
+      show_mazegaki_candidates
+      Window.redisplay
+    end
+
+    def mazegaki_relimit_left
+      with_target_buffer do |buffer|
+        yomi = nil
+        start_pos = nil
+        mazegaki_reset
+        buffer.save_excursion do
+          pos = buffer.point
+          buffer.goto_char(@mazegaki_start_pos)
+          s = buffer.substring(buffer.point, pos)
+          (MAZEGAKI_MAX_WORD_LEN - s.size).times do
+            break if buffer.beginning_of_buffer?
+            buffer.backward_char
+            s = buffer.substring(buffer.point, pos)
+            yomi = mazegaki_lookup_yomi(s, @mazegaki_convert_with_inflection)
+            if yomi
+              start_pos = buffer.point
+              break
+            end
+          end
+          if start_pos.nil?
+            message("Can't relimit left")
+            start_pos = @mazegaki_start_pos
+            yomi = @mazegaki_yomi
+          end
+        end
+        mazegaki_convert(start_pos, yomi)
+        Window.redisplay
+      end
+    end
+
+    def mazegaki_relimit_right
+      with_target_buffer do |buffer|
+        start_pos = nil
+        yomi = nil
+        mazegaki_reset
+        buffer.save_excursion do
+          pos = buffer.point
+          buffer.goto_char(@mazegaki_start_pos)
+          if @mazegaki_convert_with_inflection && @mazegaki_yomi &&
+              (yomi = mazegaki_lookup_yomi(@mazegaki_yomi, true))
+            start_pos = @mazegaki_start_pos
+          else
+            loop do
+              break if buffer.point >= pos
+              buffer.forward_char
+              s = buffer.substring(buffer.point, pos)
+              yomi = mazegaki_lookup_yomi(s, @mazegaki_convert_with_inflection)
+              if yomi
+                start_pos = buffer.point
+                break
+              end
+            end
+          end
+        end
+        if start_pos.nil?
+          if !@mazegaki_convert_with_inflection
+            start_pos, yomi = find_mazegaki_start_pos(true)
+            if start_pos
+              @mazegaki_convert_with_inflection = true
+            end
+          end
+          if start_pos.nil?
+            message("Can't relimit right")
+            start_pos = @mazegaki_start_pos
+            yomi = @mazegaki_yomi
+          end
+        end
+        mazegaki_convert(start_pos, yomi)
+        Window.redisplay
+      end
+    end
+
+    def show_mazegaki_candidates
+      offset = @mazegaki_candidates_page * mazegaki_limit
+      candidates = @mazegaki_candidates[offset, mazegaki_limit]
+      xs = Array.new(40, "-")
+      candidates.each_with_index do |s, i|
+        xs[MAZEGAKI_STROKE_PRIORITY_LIST[i]] = s
+      end
+      max_width = candidates.map { |s|
+        Buffer.display_width(s)
+      }.max
+      page = @mazegaki_candidates_page + 1
+      page_count =
+        (@mazegaki_candidates.size.to_f / mazegaki_limit).ceil
+      message = xs.map.with_index { |s, i|
+        space = " " * (max_width - Buffer.display_width(s))
+        if i % 10 < 5
+          s + space
+        else
+          space + s
+        end
+      }.each_slice(10).map.with_index { |ys, i|
+        if i == 0
+          " " + ys[0, 4].join(" ") + "  " + ys[4, 2].join("  ") + "  " +
+            ys[6, 4].join(" ")
+        else
+          "[" + ys[0, 4].join(" ") + "] " + ys[4, 2].join("  ") + " [" +
+            ys[6, 4].join(" ") + "]"
+        end
+      }.join("\n") + "   (#{page}/#{page_count})"
+      show_help(message)
+    end
+
+    def mazegaki_limit
+      MAZEGAKI_STROKE_PRIORITY_LIST.size
+    end
+
+    def show_stroke
+      c = Buffer.current.char_after
+      x, y = KANJI_TABLE.find.with_index { |row, i|
+        j = row.index(c)
+        if j
+          break [j, i]
+        else
+          false
+        end
+      }
+      if x.nil?
+        raise EditorError, "Stroke not found"
+      end
+      s = "　" * 10 + "・・・・　　・・・・" * 3
+      s[x] = "１"
+      s[y] = "２"
+      message = s.gsub(/.{10}/, "\\&\n").gsub(/　/, "  ")
+      show_help(message)
+      Window.redisplay
+      nil
+    end
+
+    def show_help(message)
+      buffer = Buffer.find_or_new("*T-Code Help*",
+                                  undo_limit: 0, read_only: true)
+      buffer.read_only_edit do
+        buffer.clear
+        buffer.insert(message)
+        buffer.beginning_of_buffer
+      end
+      if Window.list.size == 1
+        Window.list.first.split(message.lines.size + 1)
+        @delete_help_window = true
+      end
+      if Window.current.echo_area?
+        window = Window.list.last
+      else
+        windows = Window.list
+        i = (windows.index(Window.current) + 1) % windows.size
+        window = windows[i]
+      end
+      @help_window = window
+      if window.buffer != buffer
+        @prev_buffer = window.buffer
+        window.buffer = buffer
+      end
+    end
+  end
+end