textbringer 27 → 28

data/lib/textbringer/input_methods/skk_input_method.rb

@@ -5,6 +5,7 @@ require "timeout"
 
 module Textbringer
   CONFIG[:skk_dictionary_path] = File.expand_path("~/.textbringer/skk/SKK-JISYO.L")
+  CONFIG[:skk_user_dictionary_path] = File.expand_path("~/.textbringer/skk/skk-jisyo.utf8")
   CONFIG[:skk_server_host] = nil   # nil = disabled (default)
   CONFIG[:skk_server_port] = 1178
 
@@ -123,20 +124,60 @@ module Textbringer
       ascii:            nil,    # nil = reset to terminal default
     }
 
+    # Mirrors ddskk's skk-kakutei-history: the okuri-nasi yomi confirmed in
+    # this session, most recent first, shared by all buffers, and used to
+    # complete an empty yomi (skk-comp-by-history).
+    KAKUTEI_HISTORY_LIMIT = 100 # skk-kakutei-history-limit
+    @@kakutei_history = []
+
+    def self.kakutei_history
+      @@kakutei_history
+    end
+
+    # Mirrors ddskk's skk-get-jisyo-buffer, which reads a dictionary file
+    # into a single buffer shared by every buffer using SKK: the user
+    # dictionary is loaded once per path and shared by all instances, so
+    # that saving from one buffer does not drop what another one learned.
+    @@user_dictionaries = {}
+
+    # A user dictionary candidate like (skk-ignore-dic-word "留守電"),
+    # which ddskk evaluates to hide the quoted words of the system
+    # dictionary (see purge_candidate).
+    IGNORE_DIC_WORD_RE = /\A\(skk-ignore-dic-word((?: +"[^"]*")+)\)\z/
+
     def initialize
       super
       @mode = :hiragana  # :hiragana | :katakana | :hankaku_katakana | :zenkaku_ascii | :ascii
       @phase = :normal   # :normal | :converting | :selecting
       @roman_buffer = +""
+      @okuri_roman = nil       # the consonant that started okurigana (dictionary fallback)
+      @okuri_start_pos = nil   # buffer position of the "*" marker; nil = no okurigana
+      # @yomi/@okuri_kana are snapshots taken when entering the selecting
+      # phase (see start_selecting); during converting they are derived
+      # from the buffer via current_yomi/current_okuri_kana instead.
       @yomi = +""
-      @okuri_roman = nil
       @okuri_kana = nil
       @candidates = []
       @candidate_index = 0
+      @base_candidates = []  # the system dictionary's candidates for @lookup_key
       @marker_pos = nil
+      @lookup_key = nil
+      # Yomi completion state: the yomi it started from, the matching
+      # user-dictionary keys, and the index of the one currently shown.
+      @comp_prefix = nil
+      @comp_candidates = nil
+      @comp_index = nil
+      @comp_message_shown = false
+      # Whether the previous key was TAB/Shift-TAB, standing in for ddskk's
+      # (eq last-command 'skk-comp-do).
+      @last_key_completed = false
       @okuriiari = nil
       @okurinasi = nil
+      @user_okuriiari = nil
+      @user_okurinasi = nil
       @skk_server_socket = nil
+      @prefix_window = nil
+      @prefix_buffer = nil
     end
 
     def toggle
@@ -146,6 +187,7 @@ module Textbringer
       else
         reset_cursor_color
         close_skk_server
+        close_prefix_window
       end
     end
 
@@ -153,6 +195,7 @@ module Textbringer
       super
       reset_cursor_color
       close_skk_server
+      close_prefix_window
     end
 
     def on_activate
@@ -161,6 +204,7 @@ module Textbringer
 
     def on_deactivate
       reset_cursor_color if @enabled
+      close_prefix_window
     end
 
     def status
@@ -168,16 +212,114 @@ module Textbringer
     end
 
     def handle_event(event)
-      case @phase
-      when :normal     then handle_normal(event)
-      when :converting then handle_converting(event)
-      when :selecting  then handle_selecting(event)
-      end
+      # Hidden first, not to be drawn over what the event inserts: cut in
+      # two by it, a wide character would not be shown properly.
+      @prefix_window.hide if @prefix_window&.visible?
+      result =
+        case @phase
+        when :normal     then handle_normal(event)
+        when :converting then handle_converting(event)
+        when :selecting  then handle_selecting(event)
+        end
+      update_prefix_window
+      result
     end
 
     private
 
+    # Mirrors ddskk's skk-insert-prefix, which shows the unconfirmed
+    # romaji at point with an overlay when skk-echo is non-nil (the
+    # default).  Textbringer has no overlays, so it is shown in a
+    # floating window over point instead, which leaves the buffer and
+    # its undo history untouched.  During conversion the romaji is
+    # already in the buffer (see insert_roman_preview).
+    def update_prefix_window
+      if @enabled && @phase == :normal && !@roman_buffer.empty? &&
+          !isearch_mode?
+        show_prefix_window
+      else
+        close_prefix_window
+      end
+    end
+
+    def show_prefix_window
+      window = Window.current
+      width = prefix_window_width(window.buffer)
+      y, x = prefix_window_position(window, width)
+      @prefix_buffer ||= Buffer.new(name: " *skk-prefix*", undo_limit: 0)
+      @prefix_buffer.replace(
+        @roman_buffer + " " * (width - Buffer.display_width(@roman_buffer))
+      )
+      if @prefix_window.nil? || @prefix_window.deleted?
+        # Like ddskk's skk-prefix-*-face; defined here, after the colors
+        # are set up, unless the user has defined it.
+        Face.define(:skk_prefix, underline: true) unless Face[:skk_prefix]
+        @prefix_window = FloatingWindow.new(1, width, y, x,
+                                            buffer: @prefix_buffer,
+                                            face: :skk_prefix)
+      else
+        @prefix_window.resize(1, width) if @prefix_window.columns != width
+        @prefix_window.move_to(y: y, x: x)
+      end
+      @prefix_window.show
+      Window.redisplay
+      # Put the cursor after the romaji, as after characters typed; the
+      # next redisplay puts it back at point.
+      cursor_x = [x - window.x + Buffer.display_width(@roman_buffer),
+                  window.columns - 1].min
+      window.window.setpos(y - window.y, cursor_x)
+      window.window.noutrefresh
+      Window.update
+    end
+
+    # Wide enough to cover the characters after point as a whole: a wide
+    # character cut in two by the window would not be shown properly
+    # again when the window is gone.
+    def prefix_window_width(buffer)
+      width = Buffer.display_width(@roman_buffer)
+      covered = 0
+      buffer.save_excursion do
+        while covered < width && !buffer.end_of_buffer? &&
+            buffer.char_after != "\n"
+          covered += Buffer.display_width(buffer.char_after)
+          buffer.forward_char
+        end
+      end
+      [width, covered].max
+    end
+
+    # A window sticking out of the screen is not drawn at all, so romaji
+    # that does not fit in the rest of the line goes to the beginning of
+    # the next line, where the kana will go.  The echo area has no next
+    # line, so it is moved to the left there instead.
+    def prefix_window_position(window, width)
+      y = window.cursor.y
+      x = window.cursor.x
+      if x + width > window.columns
+        if window.echo_area?
+          x = [window.columns - width, 0].max
+        else
+          y += 1
+          x = 0
+        end
+      end
+      [window.y + y, window.x + x]
+    end
+
+    def close_prefix_window
+      return if @prefix_window.nil?
+      @prefix_window.close
+      @prefix_window = nil
+    end
+
     def handle_normal(event)
+      # Like ddskk's skk-delete-backward-char, backspace erases the
+      # unconfirmed romaji as a whole, leaving the character before it.
+      if backspace_event?(event) && !@roman_buffer.empty?
+        @roman_buffer = +""
+        return nil
+      end
+
       unless event.is_a?(String)
         @roman_buffer = +""
         return event
@@ -257,7 +399,39 @@ module Textbringer
     end
 
     def handle_converting(event)
+      # Like ddskk, any key clears the message a completion left behind.
+      if @comp_message_shown
+        Window.echo_area.clear_message
+        @comp_message_shown = false
+      end
+
+      # Like ddskk's skk-comp-do setting this-command, only TAB/Shift-TAB
+      # keep the flag up for the next key; any other key drops it.
+      after_completion = @last_key_completed
+      @last_key_completed = false
+
+      if backspace_event?(event)
+        backspace_converting
+        return nil
+      end
+
+      # Like skk-insert, "." and "," (skk-next-completion-char and
+      # skk-previous-completion-char) move through the candidates only
+      # right after a completion, and are typed as "。" and "、" otherwise.
+      if event == "\t" || (after_completion && event == ".")
+        complete_yomi(after_completion)
+        @last_key_completed = true
+        return nil
+      end
+
+      if event == :btab || (after_completion && event == ",")
+        complete_yomi_backward(after_completion)
+        @last_key_completed = true
+        return nil
+      end
+
       unless event.is_a?(String)
+        discard_roman_preview
         commit_converting
         return event
       end
@@ -265,22 +439,34 @@ module Textbringer
       # Control characters not handled below: commit conversion and pass through
       if event.bytesize == 1 && (event.ord < 0x20 || event.ord == 0x7f) &&
           event != "\C-g" && event != "\C-j"
+        discard_roman_preview
         commit_converting
         return event
       end
 
       case event
       when "\C-g"
-        cancel_converting
+        discard_roman_preview
+        if after_completion && @comp_prefix
+          cancel_completion
+        else
+          cancel_converting
+        end
         nil
       when "\C-j"
+        discard_roman_preview
         commit_converting
         nil
       when " "
+        discard_roman_preview
         start_selecting
         nil
+      when "q"
+        toggle_yomi_katakana
+        nil
       when /\A[A-Z]\z/
-        if @okuri_roman.nil?
+        if @okuri_start_pos.nil?
+          discard_roman_preview
           start_okurigana(event.downcase)
         else
           process_converting_romaji(event.downcase)
@@ -307,6 +493,9 @@ module Textbringer
       when "x"
         prev_candidate
         nil
+      when "X"
+        purge_candidate
+        nil
       when "\r", "\n"
         confirm_selecting
         nil
@@ -394,36 +583,39 @@ module Textbringer
       nil
     end
 
+    # Mirrors ddskk: the headword and okurigana being composed are just
+    # ordinary buffer text between markers ("▽"/"*"), so a confirmed kana
+    # is always simply inserted here -- there is no need to decide whether
+    # it belongs to the yomi or the okurigana, unlike a design that tracks
+    # them in separate string variables.
     def process_converting_romaji(event)
+      # Remove the preview of the previously buffered, unconfirmed romaji
+      delete_roman_preview
+
       # Special "n" handling: flush "ん" before appending if next char won't extend "n"
       if @roman_buffer == "n" && !%w[n y a i u e o].include?(event)
         @roman_buffer = +""
-        append_yomi_kana("ん")
+        insert_kana(converting_kana_for_mode("ん"))
       end
 
       @roman_buffer << event
 
-      table = hiragana_table_for_converting
-      prefixes = hiragana_prefixes_for_converting
+      # ddskk's romaji rules pair each kana with its katakana form and pick
+      # one by the current mode (skk-katakana), so a katakana-mode headword
+      # is katakana from the first kana onward, not converted afterward.
+      table = converting_table
+      prefixes = HIRAGANA_PREFIXES
 
       kana = table[@roman_buffer]
       if kana
         @roman_buffer = +""
-        if @okuri_roman
-          # Completing okurigana (accumulate in case a vowel kana was already prepended)
-          @okuri_kana = (@okuri_kana || "") + kana
-          with_target_buffer do |buffer|
-            buffer.insert(kana)
-          end
-          Window.redisplay
-          start_selecting
-        else
-          append_yomi_kana(kana)
-        end
+        insert_kana(kana)
+        start_selecting if @okuri_start_pos
         return
       end
 
       if prefixes.include?(@roman_buffer)
+        insert_roman_preview(@roman_buffer)
         return
       end
 
@@ -432,8 +624,9 @@ module Textbringer
         first = @roman_buffer[0]
         rest = @roman_buffer[1..]
         if first == rest[0] && first =~ /[bcdfghjklmnpqrstvwxyz]/
-          append_yomi_kana("っ")
+          insert_kana(converting_kana_for_mode("っ"))
           @roman_buffer = +rest  # Keep the second consonant buffered
+          insert_roman_preview(@roman_buffer)
           return
         end
       end
@@ -442,7 +635,7 @@ module Textbringer
       if @roman_buffer.size == 1
         char = @roman_buffer
         @roman_buffer = +""
-        append_yomi_kana(char)
+        insert_kana(char)
         return
       end
 
@@ -450,31 +643,17 @@ module Textbringer
       first_char = @roman_buffer[0]
       last_char = @roman_buffer[-1]
       @roman_buffer = +""
-      if @okuri_roman && (kana = HIRAGANA_TABLE[first_char])
-        # Vowel starts okurigana: accumulate kana and continue buffering the rest
-        @okuri_kana = (@okuri_kana || "") + kana
-        with_target_buffer { |b| b.insert(kana) }
-        Window.redisplay
-      else
-        append_yomi_kana(first_char)
-      end
+      insert_kana(first_char)
       process_converting_romaji(last_char)
     end
 
-    def append_yomi_kana(kana)
-      @yomi << kana
-      with_target_buffer do |buffer|
-        buffer.insert(kana)
-      end
-      Window.redisplay
-    end
-
     def start_converting(first_char)
       @phase = :converting
-      @yomi = +""
       @okuri_roman = nil
-      @okuri_kana = nil
+      @okuri_start_pos = nil
       @roman_buffer = +""
+      reset_completion
+      @last_key_completed = false
       with_target_buffer do |buffer|
         @marker_pos = buffer.point
         buffer.insert("▽")
@@ -487,36 +666,128 @@ module Textbringer
 
     def start_okurigana(c)
       @okuri_roman = c.dup
-      kana = HIRAGANA_TABLE[c]
+      with_target_buffer do |buffer|
+        @okuri_start_pos = buffer.point
+        buffer.insert("*")
+      end
+      Window.redisplay
+      kana = converting_table[c]
       if kana
-        # Vowel okurigana: insert the kana immediately and record it in @okuri_kana.
+        # Vowel okurigana: insert the kana immediately.
         # (A vowel is never a prefix of a longer romaji sequence, so it's always complete.)
-        @okuri_kana = kana
         @roman_buffer = +""
-        with_target_buffer { |b| b.insert(kana) }
-        Window.redisplay
+        insert_kana(kana)
         start_selecting
       else
         @roman_buffer = c.dup
+        insert_roman_preview(@roman_buffer)
+      end
+    end
+
+    def insert_roman_preview(s)
+      with_target_buffer do |buffer|
+        buffer.insert(s)
+      end
+      Window.redisplay
+    end
+
+    def delete_roman_preview
+      return if @roman_buffer.empty?
+      with_target_buffer do |buffer|
+        buffer.delete_region(buffer.point - @roman_buffer.bytesize, buffer.point)
       end
     end
 
+    def discard_roman_preview
+      delete_roman_preview
+      @roman_buffer = +""
+    end
+
+    def backspace_event?(event)
+      event == :backspace ||
+        (event.is_a?(String) && (event == "\C-h" || event.ord == 0x7f))
+    end
+
+    # Mirrors ddskk, where the headword being composed is ordinary
+    # buffer text, so backspace just deletes its last character one
+    # step at a time: unconfirmed romaji first, then okurigana, then
+    # the confirmed yomi, cancelling the conversion once everything is
+    # gone.
+    def backspace_converting
+      unless @roman_buffer.empty?
+        delete_roman_preview
+        @roman_buffer = @roman_buffer[0..-2]
+        if @roman_buffer.empty?
+          # Only undo entering okurigana entirely (removing the "*" marker)
+          # if no okurigana kana has been confirmed yet -- e.g. after a
+          # geminate consonant already confirmed "っ", erasing the preview
+          # of the following consonant must not discard that "っ" along
+          # with the okurigana marker.
+          if @okuri_start_pos &&
+              with_target_buffer(&:point) == @okuri_start_pos + "*".bytesize
+            undo_okurigana_start
+          end
+          Window.redisplay
+        else
+          insert_roman_preview(@roman_buffer)
+        end
+        return
+      end
+
+      point = with_target_buffer(&:point)
+      boundary = @okuri_start_pos ? @okuri_start_pos + "*".bytesize :
+        @marker_pos + "▽".bytesize
+
+      if point == boundary
+        if @okuri_start_pos
+          undo_okurigana_start
+          Window.redisplay
+        else
+          cancel_converting
+        end
+        return
+      end
+
+      with_target_buffer do |buffer|
+        last = buffer.char_before(buffer.point)
+        buffer.delete_region(buffer.point - last.bytesize, buffer.point)
+      end
+      Window.redisplay
+    end
+
+    # Undoes entering okurigana (removes the "*" marker), as if the
+    # uppercase key that started it had never been pressed.
+    def undo_okurigana_start
+      with_target_buffer do |buffer|
+        buffer.delete_region(@okuri_start_pos, @okuri_start_pos + "*".bytesize)
+      end
+      @okuri_roman = nil
+      @okuri_start_pos = nil
+    end
+
     def cancel_converting
       with_target_buffer do |buffer|
         buffer.delete_region(@marker_pos, buffer.point)
       end
       @phase = :normal
-      @yomi = +""
       @roman_buffer = +""
       @okuri_roman = nil
-      @okuri_kana = nil
+      @okuri_start_pos = nil
       @marker_pos = nil
+      Window.echo_area.clear_message
       Window.redisplay
       update_cursor_color
     end
 
     def commit_converting
+      # skk-kakutei records a yomi confirmed as-is in the ▽ mode.
+      if @okuri_start_pos.nil? && starts_with_hiragana?(current_yomi)
+        record_kakutei_history(current_yomi)
+      end
       with_target_buffer do |buffer|
+        if @okuri_start_pos
+          buffer.delete_region(@okuri_start_pos, @okuri_start_pos + "*".bytesize)
+        end
         # Remove the ▽ marker (3 bytes for ▽ in UTF-8)
         marker_end = @marker_pos + "▽".bytesize
         buffer.delete_region(@marker_pos, marker_end)
@@ -524,29 +795,203 @@ module Textbringer
       @phase = :normal
       @roman_buffer = +""
       @okuri_roman = nil
-      @okuri_kana = nil
+      @okuri_start_pos = nil
       @marker_pos = nil
       Window.redisplay
       update_cursor_color
     end
 
-    def start_selecting
-      lookup_key = if @okuri_roman
-        @yomi + @okuri_roman
+    # Reads the yomi/okurigana straight out of the buffer, the way ddskk's
+    # skk-set-okurigana slices skk-henkan-key out of the region between its
+    # markers, instead of accumulating them in separate variables while
+    # converting.
+    def current_yomi
+      with_target_buffer do |buffer|
+        buffer.substring(@marker_pos + "▽".bytesize, @okuri_start_pos || buffer.point)
+      end
+    end
+
+    def current_okuri_kana
+      return nil unless @okuri_start_pos
+      with_target_buffer do |buffer|
+        buffer.substring(@okuri_start_pos + "*".bytesize, buffer.point)
+      end
+    end
+
+    # Mirrors ddskk's skk-toggle-characters in the "on" (▽) branch: it
+    # converts the yomi to the opposite kana and commits, refusing (as
+    # ddskk's skk-error does) while unconfirmed romaji remains. Since
+    # okurigana always leaves unconfirmed romaji buffered until its first
+    # kana is confirmed (at which point converting phase is left via
+    # start_selecting), this naturally also covers -- by refusing -- the
+    # only okurigana case reachable here.
+    def toggle_yomi_katakana
+      unless @roman_buffer.empty?
+        message("There remains a kana prefix")
+        Window.redisplay
+        return
+      end
+
+      yomi = current_yomi
+      return if yomi.empty?
+
+      # skk-henkan-skk-region-by-func records the yomi before toggling it
+      # (and commit_converting records it after, like its skk-kakutei).
+      record_kakutei_history(yomi) if starts_with_hiragana?(yomi)
+      converted = katakana?(yomi[0]) ? katakana_to_hiragana(yomi) : hiragana_to_katakana(yomi)
+      with_target_buffer do |buffer|
+        buffer.delete_region(@marker_pos + "▽".bytesize, buffer.point)
+        buffer.insert(converted)
+      end
+      commit_converting
+    end
+
+    # Mirrors ddskk's skk-comp (SKK manual section 6.4): completes the yomi
+    # from the user dictionary's okuri-nasi keys only, most recently
+    # confirmed first. Like skk-insert's
+    # (skk-comp (not (eq last-command 'skk-comp-do))), TAB right after
+    # TAB/Shift-TAB advances the completion, and otherwise starts a new one.
+    def complete_yomi(after_completion)
+      return unless @okuri_start_pos.nil?
+
+      # Like skk-comp-do's (skk-kana-cleanup 'force): unconfirmed romaji
+      # that is a kana by itself ("n") is confirmed, and anything else is
+      # dropped. Typing the romaji already broke any run of completions.
+      unless @roman_buffer.empty?
+        pending = @roman_buffer
+        discard_roman_preview
+        insert_kana(converting_kana_for_mode("ん")) if pending == "n"
+      end
+
+      if after_completion && @comp_candidates
+        advance_completion(1, first: false)
       else
-        @yomi
+        @comp_prefix = current_yomi
+        ensure_user_dictionary_loaded
+        # Dictionary keys are always hiragana; like skk-comp-do, search with
+        # the yomi in hiragana and show the candidates back in katakana.
+        key = @mode == :katakana ? katakana_to_hiragana(@comp_prefix) : @comp_prefix
+        candidates =
+          if key.empty?
+            # skk-comp-from-jisyo gives nothing for an empty yomi; only
+            # skk-comp-by-history completes it, from the kakutei history.
+            @@kakutei_history.uniq
+          else
+            # Like skk-comp-search-current-buffer, skip the yomi's own
+            # entry: completing to what is already there would change
+            # nothing.
+            @user_okurinasi.keys.select { |k| k.start_with?(key) && k != key }
+          end
+        @comp_candidates =
+          @mode == :katakana ? candidates.map { |k| hiragana_to_katakana(k) } : candidates
+        @comp_index = -1
+        advance_completion(1, first: true)
       end
+    end
 
-      candidates = if CONFIG[:skk_server_host]
-        skk_server_lookup(lookup_key)
+    def complete_yomi_backward(after_completion)
+      if after_completion && @comp_candidates
+        advance_completion(-1, first: false)
+      else
+        # Drop any completion from before the yomi was edited, so a TAB
+        # right after this starts afresh instead of resuming it.
+        reset_completion
+        Window.beep
+        show_completion_message(
+          "No more previous completions for \"#{current_yomi}\""
+        )
+      end
+    end
+
+    # Mirrors ddskk's skk-henkan-off-by-quit taking the skk-comp-do branch:
+    # C-g right after a completion, even a failed one, only restores the
+    # yomi it started from.
+    def cancel_completion
+      with_target_buffer do |buffer|
+        buffer.delete_region(@marker_pos + "▽".bytesize, buffer.point)
+        buffer.insert(@comp_prefix)
+      end
+      reset_completion
+      Window.redisplay
+    end
+
+    def show_completion_message(text)
+      message(text)
+      @comp_message_shown = true
+      Window.redisplay
+    end
+
+    # Like ddskk's skk-comp-circulate (nil by default), stops at either end
+    # instead of wrapping around. FIRST is skk-comp-do's argument of the
+    # same name, which picks "No completions" over "No more completions".
+    def advance_completion(direction, first:)
+      new_index = @comp_index + direction
+      if new_index < 0 || new_index >= @comp_candidates.size
+        Window.beep
+        show_completion_message(
+          if direction < 0
+            "No more previous completions for \"#{@comp_prefix}\""
+          elsif @comp_prefix.empty?
+            "No more words in history"
+          elsif first
+            "No completions for \"#{@comp_prefix}\""
+          else
+            "No more completions for \"#{@comp_prefix}\""
+          end
+        )
+        return
+      end
+      @comp_index = new_index
+      with_target_buffer do |buffer|
+        buffer.delete_region(@marker_pos + "▽".bytesize, buffer.point)
+        buffer.insert(@comp_candidates[@comp_index])
+      end
+      Window.redisplay
+    end
+
+    def reset_completion
+      @comp_prefix = nil
+      @comp_candidates = nil
+      @comp_index = nil
+    end
+
+    def start_selecting
+      reset_completion
+
+      # Snapshot the yomi/okurigana now: once selecting replaces the
+      # buffer text with a "▼" candidate, the markers no longer delimit them.
+      @yomi = current_yomi
+      @okuri_kana = current_okuri_kana
+
+      # Dictionary keys are always hiragana, even when composing in
+      # katakana mode (mirrors ddskk's skk-katakana-to-hiragana call in
+      # skk-set-okurigana).
+      yomi_key = @mode == :katakana ? katakana_to_hiragana(@yomi) : @yomi
+      @lookup_key = @okuri_roman ? (yomi_key + @okuri_roman) : yomi_key
+
+      ensure_user_dictionary_loaded
+      user_dict = @okuri_roman ? @user_okuriiari : @user_okurinasi
+      user_candidates = user_dict[@lookup_key] || []
+
+      base_candidates = if CONFIG[:skk_server_host]
+        skk_server_lookup(@lookup_key) || []
       else
         ensure_dictionary_loaded
         dict = @okuri_roman ? @okuriiari : @okurinasi
-        dict[lookup_key]
+        dict[@lookup_key] || []
       end
 
-      if candidates.nil? || candidates.empty?
-        message("No conversion: #{@yomi}")
+      @base_candidates = base_candidates
+      # User dictionary candidates are ordered by recency (see
+      # learn_candidate) and take priority, mirroring ddskk's
+      # skk-search-prog-list ordering the private dictionary before the
+      # system one. Words an skk-ignore-dic-word candidate lists are left
+      # out of the system dictionary's candidates.
+      user_words = user_candidates.grep_v(IGNORE_DIC_WORD_RE)
+      candidates = (user_words + (base_candidates - ignored_words(user_candidates))).uniq
+
+      if candidates.empty?
+        register_new_word
         return
       end
 
@@ -562,13 +1007,26 @@ module Textbringer
       update_cursor_color
     end
 
+    # Like ddskk, SPC past the last candidate does not wrap around:
+    # skk-henkan-1 finds no more candidates, so skk-henkan goes on to
+    # skk-henkan-in-minibuff and asks for a new word.
     def next_candidate
-      @candidate_index = (@candidate_index + 1) % @candidates.size
+      if @candidate_index + 1 >= @candidates.size
+        register_new_word
+        return
+      end
+      @candidate_index += 1
       replace_candidate
     end
 
+    # Like skk-previous-candidate with skk-henkan-count 0, "x" on the first
+    # candidate goes back to the yomi instead of wrapping around.
     def prev_candidate
-      @candidate_index = (@candidate_index - 1 + @candidates.size) % @candidates.size
+      if @candidate_index == 0
+        cancel_selecting
+        return
+      end
+      @candidate_index -= 1
       replace_candidate
     end
 
@@ -581,15 +1039,50 @@ module Textbringer
     end
 
     def confirm_selecting
-      candidate = @candidates[@candidate_index]
+      confirm_word(@candidates[@candidate_index])
+    end
+
+    # Shared by confirm_selecting and register_new_word: insert the final
+    # word, learn it into the user dictionary, and leave converting/
+    # selecting entirely.
+    def confirm_word(word)
+      with_target_buffer do |buffer|
+        buffer.delete_region(@marker_pos, buffer.point)
+        buffer.insert(word + (@okuri_kana || ""))
+      end
+      learn_candidate(word)
+      leave_conversion
+    end
+
+    # Mirrors ddskk's skk-purge-from-jisyo: once confirmed with yes-or-no-p,
+    # remove the current candidate from the user dictionary and delete the
+    # ▼ text from the buffer without inserting anything.
+    def purge_candidate
+      word = @candidates[@candidate_index]
+      purge =
+        begin
+          yes_or_no?("Really purge \"#{@lookup_key} /#{word}/ \"?")
+        rescue Quit
+          false
+        end
+      unless purge
+        Window.redisplay
+        return
+      end
+
+      purge_from_user_dictionary(word)
       with_target_buffer do |buffer|
         buffer.delete_region(@marker_pos, buffer.point)
-        buffer.insert(candidate + (@okuri_kana || ""))
       end
+      leave_conversion
+    end
+
+    def leave_conversion
       @phase = :normal
       @yomi = +""
       @roman_buffer = +""
       @okuri_roman = nil
+      @okuri_start_pos = nil
       @okuri_kana = nil
       @candidates = []
       @candidate_index = 0
@@ -598,6 +1091,44 @@ module Textbringer
       update_cursor_color
     end
 
+    # Mirrors ddskk's skk-henkan-in-minibuff: when no candidate is found,
+    # or SPC runs past the last one, read a new word for skk-henkan-key from the minibuffer and register
+    # it. Unlike ddskk, the minibuffer here is not switched into SKK
+    # itself, so entering kanji requires switching input method by hand
+    # (e.g. C-\); nested registration (ddskk lets an unresolved word typed
+    # inside the registration prompt itself trigger another registration)
+    # is left for a follow-up.
+    def register_new_word
+      # EchoArea#redisplay only ever draws @prompt when @message is nil --
+      # otherwise it draws @message instead. A "No conversion: ..." message
+      # left over from a previous registration attempt would otherwise
+      # blank out this new prompt on screen even though @prompt itself
+      # gets set correctly underneath it.
+      Window.echo_area.clear_message
+      prompt = "SKK register #{@yomi}#{@okuri_roman ? "*#{@okuri_roman}" : ""}: "
+      new_word =
+        begin
+          read_from_minibuffer(prompt)
+        rescue Quit
+          +""
+        end
+
+      if new_word.empty?
+        # Registering after the candidates ran out leaves the last one
+        # shown, as skk-henkan-in-minibuff puts it back when given an empty
+        # string; with no candidates at all there is nothing to go back to.
+        message("No conversion: #{@yomi}") unless @phase == :selecting
+        Window.redisplay
+        return
+      end
+
+      confirm_word(new_word)
+    end
+
+    # Mirrors ddskk's skk-previous-candidate: cancelling out of the
+    # candidate list drops the okurigana distinction entirely (the "*"
+    # marker is not restored), so the okurigana text rejoins the yomi as
+    # plain, un-marked headword text.
     def cancel_selecting
       with_target_buffer do |buffer|
         buffer.delete_region(@marker_pos, buffer.point)
@@ -605,6 +1136,8 @@ module Textbringer
       end
       @phase = :converting
       @roman_buffer = +""
+      @okuri_roman = nil
+      @okuri_start_pos = nil
       @candidates = []
       @candidate_index = 0
       Window.redisplay
@@ -614,12 +1147,27 @@ module Textbringer
     def ensure_dictionary_loaded
       return if @okuriiari
 
-      path = CONFIG[:skk_dictionary_path]
-      @okuriiari = {}
-      @okurinasi = {}
+      @okuriiari, @okurinasi =
+        parse_skk_dictionary(CONFIG[:skk_dictionary_path], encoding: "EUC-JP:UTF-8")
+    end
+
+    def ensure_user_dictionary_loaded
+      path = CONFIG[:skk_user_dictionary_path]
+      @user_okuriiari, @user_okurinasi =
+        @@user_dictionaries[path] ||=
+          if path && File.exist?(path)
+            parse_skk_dictionary(path, encoding: "UTF-8")
+          else
+            [{}, {}]
+          end
+    end
+
+    def parse_skk_dictionary(path, encoding:)
+      okuriiari = {}
+      okurinasi = {}
       section = :okuriiari
 
-      File.foreach(path, encoding: "EUC-JP:UTF-8") do |line|
+      File.foreach(path, encoding: encoding) do |line|
         line.chomp!
         if line == ";; okuri-nasi entries."
           section = :okurinasi
@@ -634,9 +1182,82 @@ module Textbringer
         next if candidates.empty?
 
         if section == :okuriiari
-          @okuriiari[key] = candidates
+          okuriiari[key] = candidates
         else
-          @okurinasi[key] = candidates
+          okurinasi[key] = candidates
+        end
+      end
+
+      [okuriiari, okurinasi]
+    end
+
+    # Mirrors ddskk's skk-update-jisyo-1: move the confirmed candidate to
+    # the front of its entry, and the entry itself to the front of the
+    # dictionary (completion walks the keys in that order), then persist
+    # immediately, since this SKK implementation has no explicit save
+    # command or autosave-count setting yet.
+    def learn_candidate(candidate)
+      dict = @okuri_roman ? @user_okuriiari : @user_okurinasi
+      entries = dict.delete(@lookup_key) || []
+      candidates = [candidate] + entries.reject { |c| c == candidate }
+      dict.replace({ @lookup_key => candidates }.merge(dict))
+      save_user_dictionary
+      # skk-update-jisyo records only okuri-nasi conversions in the history.
+      record_kakutei_history(@lookup_key) unless @okuri_roman
+    end
+
+    # Mirrors the purge branch of ddskk's skk-update-jisyo-1: a word the
+    # system dictionary (or SKK server) also has is quoted with
+    # skk-ignore-dic-word, folded into one candidate as
+    # skk-compose-ignore-word does, so that later conversions hide it;
+    # any other word is just deleted. Unlike ddskk's skk-update-jisyo,
+    # the yomi is not recorded in the kakutei history.
+    def purge_from_user_dictionary(word)
+      dict = @okuri_roman ? @user_okuriiari : @user_okurinasi
+      entries = (dict.delete(@lookup_key) || []) - [word]
+      if @base_candidates.include?(word)
+        ignored = ignored_words(entries) + [word]
+        quoted = ignored.map { |w| "\"#{w}\"" }.join(" ")
+        entries = ["(skk-ignore-dic-word #{quoted})"] + entries.grep_v(IGNORE_DIC_WORD_RE)
+      end
+      # skk-update-jisyo-1 writes nothing back for an entry left empty.
+      dict.replace({ @lookup_key => entries }.merge(dict)) unless entries.empty?
+      save_user_dictionary
+    end
+
+    def ignored_words(candidates)
+      candidates.flat_map { |c|
+        m = IGNORE_DIC_WORD_RE.match(c)
+        m ? m[1].scan(/"([^"]*)"/).flatten : []
+      }
+    end
+
+    # Like skk-update-kakutei-history, keeping only the newest
+    # KAKUTEI_HISTORY_LIMIT entries.
+    def record_kakutei_history(yomi)
+      @@kakutei_history.unshift(yomi)
+      @@kakutei_history.slice!(KAKUTEI_HISTORY_LIMIT..)
+    end
+
+    # The check skk-kakutei and skk-henkan-skk-region-by-func make with
+    # skk-what-char-type at the ▽ point before recording a yomi.
+    def starts_with_hiragana?(yomi)
+      yomi.match?(/\A[ぁ-ん]/)
+    end
+
+    def save_user_dictionary
+      path = CONFIG[:skk_user_dictionary_path]
+      return unless path
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "w:UTF-8") do |f|
+        f.puts ";; okuri-ari entries."
+        @user_okuriiari.each do |key, candidates|
+          f.puts "#{key} /#{candidates.join('/')}/"
+        end
+        f.puts ";; okuri-nasi entries."
+        @user_okurinasi.each do |key, candidates|
+          f.puts "#{key} /#{candidates.join('/')}/"
         end
       end
     end
@@ -660,6 +1281,16 @@ module Textbringer
       }.join
     end
 
+    def katakana_to_hiragana(kana)
+      kana.chars.map { |c|
+        c.ord.between?(0x30A1, 0x30F6) ? (c.ord - 0x60).chr("UTF-8") : c
+      }.join
+    end
+
+    def katakana?(char)
+      char.ord.between?(0x30A1, 0x30F6)
+    end
+
     def hiragana_to_hankaku_katakana(kana)
       kana.chars.map { |c|
         case c.ord
@@ -766,13 +1397,18 @@ module Textbringer
       end
     end
 
-    # During converting phase, always use hiragana for yomi tracking
-    def hiragana_table_for_converting
-      HIRAGANA_TABLE
+    # Unlike current_table/current_prefixes (used by process_romaji for
+    # ordinary input), converting only switches to katakana, not hankaku
+    # katakana: half-width katakana isn't hiragana-convertible for the
+    # dictionary lookup key the way full-width katakana is (see
+    # start_selecting), and ddskk's half-width kana input is a separate
+    # mode with its own conversion path, not part of skk-katakana.
+    def converting_table
+      @mode == :katakana ? KATAKANA_TABLE : HIRAGANA_TABLE
     end
 
-    def hiragana_prefixes_for_converting
-      HIRAGANA_PREFIXES
+    def converting_kana_for_mode(hiragana_kana)
+      @mode == :katakana ? hiragana_to_katakana(hiragana_kana) : hiragana_kana
     end
 
     def update_cursor_color