shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/input/controllers/ui_controller/delegation_facade.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module UiControllerDelegationFacade
+          # === Sidebar delegation ===
+          def open_toc
+            @sidebar_controller.open_toc
+          end
+
+          def open_bookmarks
+            @sidebar_controller.open_bookmarks
+          end
+
+          def open_annotations_tab
+            @sidebar_controller.open_annotations_tab
+          end
+
+          def activate_sidebar_tab(tab)
+            @sidebar_controller.activate_sidebar_tab(tab)
+          end
+
+          def handle_sidebar_toc_click(index)
+            @sidebar_controller.handle_sidebar_toc_click(index)
+          end
+
+          def set_sidebar_toc_selected(index)
+            @sidebar_controller.set_sidebar_toc_selected(index)
+          end
+
+          def sidebar_down
+            @sidebar_controller.sidebar_down
+          end
+
+          def sidebar_up
+            @sidebar_controller.sidebar_up
+          end
+
+          def sidebar_select
+            @sidebar_controller.sidebar_select
+          end
+
+          def sidebar_toggle_toc
+            @sidebar_controller.sidebar_toggle_toc
+          end
+
+          def sidebar_visible?
+            @sidebar_controller.sidebar_visible?
+          end
+
+          def close_sidebar_with_restore(tab)
+            @sidebar_controller.close_sidebar_with_restore(tab)
+          end
+
+          # TOC helpers exposed for external use
+          def toc_entries_for(doc)
+            @sidebar_controller.toc_entries_for(doc)
+          end
+
+          def toc_collapsed_for(entries, raw = nil)
+            @sidebar_controller.toc_collapsed_for(entries, raw)
+          end
+
+          def toc_visible_indices(entries, collapsed)
+            @sidebar_controller.toc_visible_indices(entries, collapsed)
+          end
+
+          def toc_entry_has_children?(entries, index)
+            @sidebar_controller.toc_entry_has_children?(entries, index)
+          end
+
+          # === Annotation overlay delegation ===
+          def open_annotations
+            @annotation_controller.open_annotations
+          end
+
+          def open_annotation_editor_overlay(text:, range:, chapter_index:, annotation: nil)
+            @annotation_controller.open_annotation_editor_overlay(
+              text: text,
+              range: range,
+              chapter_index: chapter_index,
+              annotation: annotation
+            )
+          end
+
+          def show_annotations_overlay
+            @annotation_controller.show_annotations_overlay
+          end
+
+          def close_annotations_overlay
+            @annotation_controller.close_annotations_overlay
+          end
+
+          def show_annotation_editor_overlay(text:, range:, chapter_index:, annotation: nil)
+            @annotation_controller.show_annotation_editor_overlay(
+              text: text,
+              range: range,
+              chapter_index: chapter_index,
+              annotation: annotation
+            )
+          end
+
+          def close_annotation_editor_overlay
+            @annotation_controller.close_annotation_editor_overlay
+          end
+
+          def annotations_overlay_visible?
+            @annotation_controller.annotations_overlay_visible?
+          end
+
+          def annotation_editor_visible?
+            @annotation_controller.annotation_editor_visible?
+          end
+
+          def open_annotation_from_overlay(annotation)
+            @annotation_controller.open_annotation_from_overlay(annotation)
+          end
+
+          def edit_annotation_from_overlay(annotation)
+            @annotation_controller.edit_annotation_from_overlay(annotation)
+          end
+
+          def delete_annotation_from_overlay(annotation)
+            @annotation_controller.delete_annotation_from_overlay(annotation)
+          end
+
+          def annotations_up
+            @annotation_controller.annotations_up
+          end
+
+          def annotations_down
+            @annotation_controller.annotations_down
+          end
+
+          def annotations_open
+            @annotation_controller.annotations_open
+          end
+
+          def annotations_edit
+            @annotation_controller.annotations_edit
+          end
+
+          def annotations_delete
+            @annotation_controller.annotations_delete
+          end
+
+          def annotations_cancel
+            @annotation_controller.annotations_cancel
+          end
+
+          def annotation_editor_insert_char(char)
+            @annotation_controller.annotation_editor_insert_char(char)
+          end
+
+          def annotation_editor_backspace
+            @annotation_controller.annotation_editor_backspace
+          end
+
+          def annotation_editor_enter
+            @annotation_controller.annotation_editor_enter
+          end
+
+          def annotation_editor_move_left
+            @annotation_controller.annotation_editor_move_left
+          end
+
+          def annotation_editor_move_right
+            @annotation_controller.annotation_editor_move_right
+          end
+
+          def annotation_editor_move_up
+            @annotation_controller.annotation_editor_move_up
+          end
+
+          def annotation_editor_move_down
+            @annotation_controller.annotation_editor_move_down
+          end
+
+          def annotation_editor_cancel
+            @annotation_controller.annotation_editor_cancel
+          end
+
+          def annotation_editor_save
+            @annotation_controller.annotation_editor_save
+          end
+
+          def handle_annotation_editor_overlay_click(col, row)
+            @annotation_controller.handle_annotation_editor_overlay_click(col, row)
+          end
+
+          def handle_annotation_editor_overlay_event(result)
+            @annotation_controller.handle_annotation_editor_overlay_event(result)
+          end
+
+          def refresh_annotations
+            @annotation_controller.refresh_annotations
+          end
+
+          def current_book_path
+            @annotation_controller.current_book_path
+          end
+
+          # === Dictionary delegation ===
+          def handle_lookup_action(action_data)
+            @dictionary_controller.handle_lookup_action(action_data)
+          end
+
+          def show_dictionary_panel(result, announce: true)
+            @dictionary_controller.show_dictionary_panel(result, announce: announce)
+          end
+
+          def show_dictionary_popup(result, announce: true)
+            @dictionary_controller.show_dictionary_popup(result, announce: announce)
+          end
+
+          def close_dictionary(_key = nil)
+            @dictionary_controller.close_dictionary
+          end
+
+          def dictionary_insert_char(char)
+            @dictionary_controller.dictionary_insert_char(char)
+          end
+
+          def dictionary_backspace(key = nil)
+            @dictionary_controller.dictionary_backspace(key)
+          end
+
+          def dictionary_confirm(key = nil)
+            @dictionary_controller.dictionary_confirm(key)
+          end
+
+          def dictionary_cancel(key = nil)
+            @dictionary_controller.dictionary_cancel(key)
+          end
+
+          def dictionary_tab(key = nil)
+            @dictionary_controller.dictionary_tab(key)
+          end
+
+          def dictionary_swap_languages(key = nil)
+            @dictionary_controller.dictionary_swap_languages(key)
+          end
+
+          def refresh_dictionary_display_mode(terminal_width:, terminal_height:)
+            @dictionary_controller.refresh_dictionary_display_mode(
+              terminal_width: terminal_width,
+              terminal_height: terminal_height
+            )
+          end
+
+          def dictionary_scroll_up(key = nil)
+            @dictionary_controller.dictionary_scroll_up(key)
+          end
+
+          def dictionary_scroll_down(key = nil)
+            @dictionary_controller.dictionary_scroll_down(key)
+          end
+
+          def dictionary_toggle_fuzzy(key = nil)
+            @dictionary_controller.dictionary_toggle_fuzzy(key)
+          end
+
+          def dictionary_cycle_result(key = nil)
+            @dictionary_controller.dictionary_cycle_result(key)
+          end
+
+          def dictionary_cycle_pair(key = nil)
+            @dictionary_controller.dictionary_cycle_pair(key)
+          end
+
+          def active_dictionary_component
+            @dictionary_controller.active_dictionary_component
+          end
+
+          # === In-book search delegation ===
+          def open_in_book_search(key = nil)
+            @in_book_search_controller.open_in_book_search(key)
+          end
+
+          def close_in_book_search(key = nil)
+            @in_book_search_controller.close_in_book_search(key)
+          end
+
+          def in_book_search_insert_char(char)
+            @in_book_search_controller.in_book_search_insert_char(char)
+          end
+
+          def in_book_search_backspace(key = nil)
+            @in_book_search_controller.in_book_search_backspace(key)
+          end
+
+          def in_book_search_confirm(key = nil)
+            @in_book_search_controller.in_book_search_confirm(key)
+          end
+
+          def in_book_search_cancel(key = nil)
+            @in_book_search_controller.in_book_search_cancel(key)
+          end
+
+          def in_book_search_up(key = nil)
+            @in_book_search_controller.in_book_search_up(key)
+          end
+
+          def in_book_search_down(key = nil)
+            @in_book_search_controller.in_book_search_down(key)
+          end
+
+          def dictionary_visible?
+            @dictionary_controller.dictionary_visible?
+          end
+
+          def in_book_search_visible?
+            @in_book_search_controller.in_book_search_visible?
+          end
+
+          def determine_dictionary_display_mode(terminal_width, terminal_height)
+            @dictionary_controller.determine_dictionary_display_mode(terminal_width, terminal_height)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/ui_controller/mode_switching.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module UiControllerModeSwitching
+          # Mode switching
+          def switch_mode(mode, **)
+            annotation_editor_mode =
+              mode == :annotation_editor ? UIController::AnnotationEditorMode.new(self, @annotation_service, @ui_component_factory) : nil
+            close_annotations_overlay unless annotation_editor_mode
+            close_annotation_editor_overlay unless annotation_editor_mode
+            @state_writer.update_reader(mode: mode)
+
+            @current_mode = annotation_editor_mode&.build_component(**)
+
+            begin
+              @input_controller.activate_for_mode(mode) if @input_controller
+            rescue Shoko::Error
+              # If not available, ignore; read mode remains default
+            end
+          end
+
+          # === UI config methods ===
+          def show_help(_key = nil)
+            switch_mode(:help)
+          end
+
+          def toggle_view_mode(_key = nil)
+            @state_writer.toggle_view_mode
+          end
+
+          def increase_line_spacing(_key = nil)
+            modes = %i[compact normal relaxed]
+            current = modes.index(@config_reader.line_spacing) || 1
+            return unless current < 2
+
+            @state_writer.update_config(line_spacing: modes[current + 1])
+            @state_writer.update_page(last_width: 0)
+          end
+
+          def decrease_line_spacing(_key = nil)
+            modes = %i[compact normal relaxed]
+            current = modes.index(@config_reader.line_spacing) || 1
+            return unless current.positive?
+
+            @state_writer.update_config(line_spacing: modes[current - 1])
+            @state_writer.update_page(last_width: 0)
+          end
+
+          def toggle_page_numbering_mode(_key = nil)
+            current_mode = @config_reader.page_numbering_mode
+            new_mode = current_mode == :absolute ? :dynamic : :absolute
+            @state_writer.update_config(page_numbering_mode: new_mode)
+            set_message("Page numbering: #{new_mode}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/ui_controller/popup_actions.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../support/message_notifier'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module UiControllerPopupActions
+          include Shoko::Adapters::Input::Controllers::Support::MessageNotifier
+
+          # === Popup handling ===
+          def handle_popup_action(action_data)
+            action_type = action_data.is_a?(Hash) ? action_data[:action] : action_data
+
+            case action_type
+            when :create_annotation, 'Create Annotation'
+              handle_create_annotation_action(action_data)
+            when :copy_to_clipboard, 'Copy to Clipboard'
+              handle_copy_to_clipboard_action(action_data)
+            when :lookup, 'Look Up'
+              handle_lookup_action(action_data)
+              return # Don't cleanup popup state - dictionary overlay handles its own cleanup
+            end
+
+            skip_editor = %i[create_annotation].include?(action_type) || action_type == 'Create Annotation'
+            cleanup_popup_state(skip_editor: skip_editor)
+          end
+
+          def cleanup_popup_state(skip_editor: false)
+            @state_writer.update_reader(popup_menu: nil)
+            @state_writer.clear_selection
+            close_in_book_search
+            close_annotations_overlay
+            close_annotation_editor_overlay unless skip_editor
+            begin
+              @reader_controller&.clear_active_selection
+            rescue Shoko::Error
+              # Best-effort; ignore if not available
+            end
+          end
+
+          private
+
+          def handle_create_annotation_action(action_data)
+            selection_range = if action_data.is_a?(Hash)
+                                action_data[:data][:selection_range]
+                              else
+                                @reader_state.selection
+                              end
+            selected_text = extract_selected_text_from_selection(selection_range)
+            close_annotations_overlay
+            show_annotation_editor_overlay(text: selected_text,
+                                           range: selection_range,
+                                           chapter_index: @reader_state.current_chapter)
+          end
+
+          def handle_copy_to_clipboard_action(_action_data)
+            clipboard_service = @clipboard_service
+            selection = @reader_state.selection
+            selected_text = extract_selected_text_from_selection(selection)
+
+            if clipboard_service.available? && selected_text && !selected_text.strip.empty?
+              success = clipboard_service.copy_with_feedback(selected_text) do |msg|
+                set_message(msg)
+              end
+              set_message(' Failed to copy to clipboard') unless success
+            else
+              set_message(' Copy to clipboard not available')
+            end
+            switch_mode(:read)
+          end
+
+          def extract_selected_text_from_selection(selection_range)
+            return nil unless @selection_service && @rendered_content_reader
+
+            rendered_lines = @rendered_content_reader.rendered_lines
+            @selection_service.extract_text(selection_range, rendered_lines)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/ui_controller.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'ui_controller/mode_switching'
+require_relative 'ui_controller/popup_actions'
+require_relative 'ui_controller/delegation_facade'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        # Coordinates all UI-related functionality by delegating to specialized controllers.
+        class UIController
+          include UiControllerModeSwitching
+          include UiControllerPopupActions
+          include UiControllerDelegationFacade
+
+          # Raised when required dependencies are missing for a UI action.
+          class MissingDependencyError < StandardError; end
+
+          Dependencies = Data.define(
+            :reader_state,
+            :config_reader,
+            :state_writer,
+            :sidebar_state,
+            :ui_state,
+            :sidebar_controller,
+            :dictionary_controller,
+            :annotation_controller,
+            :in_book_search_controller,
+            :input_controller,
+            :reader_controller,
+            :notification_service,
+            :selection_service,
+            :rendered_content_reader,
+            :clipboard_service,
+            :ui_component_factory,
+            :annotation_service,
+            :logger
+          ) do
+            REQUIRED_FIELDS = %i[
+              reader_state
+              config_reader
+              state_writer
+              sidebar_controller
+              dictionary_controller
+              annotation_controller
+              in_book_search_controller
+              input_controller
+              notification_service
+            ].freeze
+
+            def validate!
+              values = to_h
+              missing = REQUIRED_FIELDS.select { |field| values[field].nil? }
+              return self if missing.empty?
+
+              raise ArgumentError, "Missing required UI controller dependencies: #{missing.join(', ')}"
+            end
+          end
+
+          # Builds the annotation editor screen component for annotation editor mode.
+          class AnnotationEditorMode
+            def initialize(controller, annotation_service, component_factory)
+              @controller = controller
+              @annotation_service = annotation_service
+              @component_factory = component_factory
+            end
+
+            def build_component(**)
+              @component_factory.annotation_editor_screen(
+                controller: @controller,
+                annotation_service: @annotation_service,
+                **
+              )
+            end
+          end
+
+          attr_reader :current_mode
+
+          def initialize(deps:)
+            dependencies = deps.validate!
+
+            @reader_state = dependencies.reader_state
+            @config_reader = dependencies.config_reader
+            @state_writer = dependencies.state_writer
+            @sidebar_state = dependencies.sidebar_state
+            @ui_state = dependencies.ui_state
+
+            @sidebar_controller = dependencies.sidebar_controller
+            @dictionary_controller = dependencies.dictionary_controller
+            @annotation_controller = dependencies.annotation_controller
+            @in_book_search_controller = dependencies.in_book_search_controller
+
+            @input_controller = dependencies.input_controller
+            @reader_controller = dependencies.reader_controller
+            @notification_service = dependencies.notification_service
+            @selection_service = dependencies.selection_service
+            @rendered_content_reader = dependencies.rendered_content_reader
+            @clipboard_service = dependencies.clipboard_service
+            @ui_component_factory = dependencies.ui_component_factory
+            @annotation_service = dependencies.annotation_service
+            @logger = dependencies.logger
+            @current_mode = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/dispatcher.rb

@@ -3,66 +3,68 @@
 require_relative 'commands'
 
 module Shoko
-  module Adapters::Input
-    # Dispatches keys through a stack of active input modes.
-    class Dispatcher
-      def initialize(context)
-        @context = context
-        @command_map = {}
-        @mode_stack = []
-      end
+  module Adapters
+    module Input
+      # Dispatches keys through a stack of active input modes.
+      class Dispatcher
+        def initialize(context)
+          @context = context
+          @command_map = {}
+          @mode_stack = []
+        end
 
-      def handle_key(key)
-        return if key.nil?
+        def handle_key(key)
+          return if key.nil?
 
-        @mode_stack.reverse_each do |mode|
-          bindings = @command_map[mode] || {}
-          cmd = bindings[key] || bindings[:__default__]
-          next unless cmd
+          @mode_stack.reverse_each do |mode|
+            bindings = @command_map[mode] || {}
+            cmd = bindings[key] || bindings[:__default__]
+            next unless cmd
 
-          result = Commands.execute(cmd, @context, key)
-          return result if result == :handled
+            result = Commands.execute(cmd, @context, key)
+            return result if result == :handled
+          end
+          :pass
         end
-        :pass
-      end
 
-      def push_mode(mode, bindings = {})
-        @mode_stack << mode
-        @command_map[mode] = bindings if bindings && !bindings.empty?
-      end
+        def push_mode(mode, bindings = {})
+          @mode_stack << mode
+          @command_map[mode] = bindings if bindings && !bindings.empty?
+        end
 
-      def pop_mode
-        @mode_stack.pop
-      end
+        def pop_mode
+          @mode_stack.pop
+        end
 
-      def remove_mode(mode)
-        @mode_stack.delete(mode)
-        @command_map.delete(mode)
-      end
+        def remove_mode(mode)
+          @mode_stack.delete(mode)
+          @command_map.delete(mode)
+        end
 
-      def clear
-        @mode_stack.clear
-      end
+        def clear
+          @mode_stack.clear
+        end
 
-      # Register bindings for a mode without activating it
-      def register_mode(mode, bindings)
-        @command_map[mode] = bindings
-      end
+        # Register bindings for a mode without activating it
+        def register_mode(mode, bindings)
+          @command_map[mode] = bindings
+        end
 
-      # Activate a single mode (clears the stack, then pushes)
-      def activate(mode)
-        clear
-        push_mode(mode, @command_map[mode] || {})
-      end
+        # Activate a single mode (clears the stack, then pushes)
+        def activate(mode)
+          clear
+          push_mode(mode, @command_map[mode] || {})
+        end
 
-      # Activate a full stack of modes in order; last wins on dispatch
-      def activate_stack(modes)
-        clear
-        modes.each { |m| push_mode(m, @command_map[m] || {}) }
-      end
+        # Activate a full stack of modes in order; last wins on dispatch
+        def activate_stack(modes)
+          clear
+          modes.each { |m| push_mode(m, @command_map[m] || {}) }
+        end
 
-      def mode_stack
-        @mode_stack.dup
+        def mode_stack
+          @mode_stack.dup
+        end
       end
     end
   end