qtimetrap 0.1.1

data/app/views/main_window.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Main Qt window wiring together components and user interactions.
+    class MainWindow
+      include MainWindowRuntime
+      include MainWindowUiHelpers
+
+      WINDOW_W = 1380
+      WINDOW_H = 860
+      THEMES = %w[light dark].freeze
+      HEARTBEAT_MS = 33
+
+      def initialize(
+        view_model: ViewModels::MainViewModel.new,
+        theme: Styles::Theme.new(name: 'light', root: Application.root),
+        settings_store: Models::NullSettingsStore.new
+      )
+        @view_model = view_model
+        @theme = theme
+        @settings_store = settings_store
+        @pending_refresh = true
+        @shutdown_requested = false
+
+        build_window
+        connect_key_events
+        connect_shortcuts
+        connect_heartbeat
+      end
+
+      def show = window.show
+
+      def close
+        persist_window_geometry
+        window.close
+      end
+
+      def request_shutdown = @shutdown_requested = true
+
+      private
+
+      attr_reader :view_model, :window, :theme, :settings_store, :sidebar, :controls, :entries, :heartbeat
+
+      def build_window
+        @window = build_base_window
+        restore_window_geometry
+        set_window_icon
+        window.set_style_sheet(theme.application_stylesheet)
+        ui = MainWindowLayoutBuilder.new(
+          window: window,
+          callbacks: layout_callbacks
+        ).build
+        @sidebar = ui.fetch(:sidebar)
+        @controls = ui.fetch(:controls)
+        @entries = ui.fetch(:entries)
+      end
+
+      def connect_heartbeat
+        @heartbeat = QTimer.new(window)
+        heartbeat.set_interval(HEARTBEAT_MS)
+        heartbeat.connect('timeout') { |_| on_tick }
+        heartbeat.start
+      end
+
+      def connect_key_events
+        window.on(:key_press) { |event| on_key_press(event) }
+        register_blur_click_source(window)
+        register_blur_click_source(sidebar.widget)
+        register_blur_click_source(controls.widget)
+        register_blur_click_source(entries.widget)
+      end
+
+      def connect_shortcuts
+        @space_shortcut = QShortcut.new(QKeySequence.new('Space'), window)
+        @space_shortcut.connect('activated') { |_| on_space_shortcut }
+      end
+
+      def register_blur_click_source(widget)
+        widget.on(:mouse_button_press) { |event| on_mouse_button_press(event, source_widget: widget) }
+      end
+
+      def restore_window_geometry
+        geometry = settings_store.read_window_geometry
+        return unless geometry
+
+        window.set_geometry(
+          geometry.fetch(:left),
+          geometry.fetch(:top),
+          geometry.fetch(:width),
+          geometry.fetch(:height)
+        )
+      end
+
+      def persist_window_geometry
+        settings_store.write_window_geometry(
+          left: window.x,
+          top: window.y,
+          width: window.width,
+          height: window.height
+        )
+      rescue StandardError => e
+        warn("[qtimetrap] save geometry failed: #{e.class}: #{e.message}")
+      end
+
+      def layout_callbacks
+        {
+          on_project_selected: method(:handle_project_selected),
+          on_task_selected: method(:handle_task_selected),
+          on_archive_mode_toggled: method(:handle_archive_mode_toggled),
+          on_start: method(:handle_start),
+          on_project_change: method(:handle_project_input),
+          on_time_range_change: method(:handle_time_range_changed),
+          on_entry_note_change: method(:handle_entry_note_changed),
+          on_entry_task_change: method(:handle_entry_task_changed),
+          on_entry_time_change: method(:handle_entry_time_changed),
+          task_suggestions_for_project: method(:task_suggestions_for_project),
+          on_entry_archive: method(:handle_entry_archived),
+          on_stop: method(:handle_stop),
+          on_refresh: -> { @pending_refresh = true },
+          on_switch_theme: method(:switch_theme!)
+        }
+      end
+    end
+  end
+end

data/app/views/main_window_layout_builder.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Builds main window layout and returns initialized component instances.
+    class MainWindowLayoutBuilder
+      include MainWindowSplitterToggleHelpers
+
+      SIDEBAR_WIDTH = 220
+      SIDEBAR_MIN_WIDTH = 180
+      SIDEBAR_MAX_WIDTH = 520
+
+      def initialize(window:, callbacks:)
+        @window = window
+        @callbacks = callbacks
+      end
+
+      def build
+        root = QHBoxLayout.new(window)
+        root.set_contents_margins(0, 0, 0, 0)
+        root.set_spacing(0)
+        splitter, sidebar, controls, entries = build_splitter_and_content
+        root.add_widget(splitter)
+        { sidebar: sidebar, controls: controls, entries: entries }
+      end
+
+      private
+
+      attr_reader :window, :callbacks
+
+      def build_splitter_and_content
+        splitter = QSplitter.new(window)
+        splitter.set_orientation(Qt::Horizontal)
+        splitter.set_mouse_tracking(true)
+        sidebar = build_sidebar(parent: splitter)
+        content, controls, entries = build_content(parent: splitter)
+        splitter.add_widget(sidebar.widget)
+        splitter.add_widget(content)
+        configure_splitter(splitter)
+        add_sidebar_toggle_button(window: window, splitter: splitter, sidebar_widget: sidebar.widget)
+        [splitter, sidebar, controls, entries]
+      end
+
+      def configure_splitter(splitter)
+        splitter.set_stretch_factor(0, 0)
+        splitter.set_stretch_factor(1, 1)
+        splitter.set_collapsible(0, false)
+        splitter.set_collapsible(1, false)
+      end
+
+      def build_sidebar(parent:)
+        QTimetrap::ProjectSidebar::Component.new(
+          parent: parent,
+          on_project_selected: callbacks.fetch(:on_project_selected),
+          on_task_selected: callbacks.fetch(:on_task_selected),
+          on_archive_mode_toggled: callbacks.fetch(:on_archive_mode_toggled)
+        ).tap do |component|
+          component.widget.set_base_size(SIDEBAR_WIDTH, 0)
+          component.widget.set_minimum_width(SIDEBAR_MIN_WIDTH)
+          component.widget.set_maximum_width(SIDEBAR_MAX_WIDTH)
+        end
+      end
+
+      def build_content(parent:)
+        content, layout = build_content_widget(parent: parent)
+        controls = build_controls(content)
+        entries = build_entries_component(content)
+        layout.add_widget(controls.widget)
+        layout.add_widget(entries.widget)
+        layout.set_stretch(1, 1)
+        [content, controls, entries]
+      end
+
+      def build_entries_component(parent)
+        QTimetrap::Entries::ListComponent.new(
+          parent: parent,
+          callbacks: entries_callbacks,
+          task_suggestions_for_project: callbacks.fetch(:task_suggestions_for_project)
+        )
+      end
+
+      def entries_callbacks
+        {
+          on_entry_note_change: callbacks.fetch(:on_entry_note_change),
+          on_entry_task_change: callbacks.fetch(:on_entry_task_change),
+          on_entry_time_change: callbacks.fetch(:on_entry_time_change),
+          on_entry_archive: callbacks.fetch(:on_entry_archive),
+          on_time_range_change: callbacks.fetch(:on_time_range_change)
+        }
+      end
+
+      def build_content_widget(parent:)
+        content = QWidget.new(parent)
+        layout = QVBoxLayout.new(content)
+        layout.set_contents_margins(14, 8, 14, 8)
+        layout.set_spacing(10)
+        [content, layout]
+      end
+
+      def build_controls(content)
+        QTimetrap::TrackerControls::Component.new(
+          parent: content,
+          callbacks: {
+            on_start: callbacks.fetch(:on_start),
+            on_stop: callbacks.fetch(:on_stop),
+            on_refresh: callbacks.fetch(:on_refresh),
+            on_switch_theme: callbacks.fetch(:on_switch_theme),
+            on_project_change: callbacks.fetch(:on_project_change)
+          }
+        )
+      end
+    end
+  end
+end

data/app/views/main_window_runtime.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Event/runtime behavior extracted from MainWindow.
+    module MainWindowRuntime
+      include MainWindowRuntimeArchiveHelpers
+      include MainWindowRuntimeEntryTaskHelpers
+      include MainWindowRuntimeEntryTimeHelpers
+      include MainWindowRuntimeKeyHelpers
+      include MainWindowRuntimeRenderHelpers
+
+      private
+
+      def on_tick
+        return unless window.is_visible
+        return close if @shutdown_requested
+
+        now = Time.now
+        update_live_indicators(now)
+        refresh_if_needed
+      end
+
+      def update_live_indicators(now)
+        controls.clock_label.set_text(now.strftime('%a %d %b %Y  %H:%M:%S'))
+        controls.timer_label.set_text(view_model.running_timer_line(now: now))
+      end
+
+      def refresh_if_needed
+        return unless @pending_refresh
+
+        view_model.refresh!
+        render!(sync_sheet: true)
+        @pending_refresh = false
+      end
+
+      def handle_start(task_input, project_name)
+        task_name = resolved_start_task(task_input)
+        project = resolved_start_project(project_name)
+        view_model.current_project_name = project
+        view_model.current_task_input = task_name
+        view_model.start_tracking(view_model.sheet_for_task_input(task_name))
+        @pending_refresh = true
+      rescue StandardError => e
+        warn("[qtimetrap] start failed: #{e.class}: #{e.message}")
+      end
+
+      def handle_stop
+        view_model.stop_tracking
+        @pending_refresh = true
+      rescue StandardError => e
+        warn("[qtimetrap] stop failed: #{e.class}: #{e.message}")
+      end
+
+      def handle_project_selected(projects, project)
+        update_current_fields = !view_model.running_current_sheet?
+        view_model.select_projects(projects, primary_project: project, sync_current_fields: update_current_fields)
+        view_model.current_project_name = project if update_current_fields && project != '* ALL'
+        render!
+        return unless update_current_fields
+
+        controls.update_task_input(view_model.current_sheet_input)
+        controls.update_project_input(project == '* ALL' ? '' : project)
+      end
+
+      def handle_task_selected(tasks, task)
+        view_model.select_tasks(tasks)
+        unless view_model.running_current_sheet?
+          view_model.current_task_input = task.to_s
+          controls.update_task_input(view_model.current_sheet_input)
+        end
+        render_controls(sync_sheet: false)
+        entries.render(view_model.entry_nodes)
+      end
+
+      def handle_project_input(project_name)
+        return if view_model.running_current_sheet?
+
+        view_model.current_project_name = project_name
+      end
+
+      def handle_time_range_changed(from_at, to_at)
+        view_model.update_time_range_filter(from_at: from_at, to_at: to_at)
+        render_controls(sync_sheet: false)
+        entries.update_time_range_inputs(
+          from_at: view_model.time_filter_from_at,
+          to_at: view_model.time_filter_to_at
+        )
+        entries.render(view_model.entry_nodes)
+      rescue StandardError => e
+        warn("[qtimetrap] update time-range failed: #{e.class}: #{e.message}")
+      end
+
+      def handle_entry_note_changed(entry_id, note)
+        view_model.update_entry_note(entry_id, note)
+      rescue StandardError => e
+        warn("[qtimetrap] update note failed: #{e.class}: #{e.message}")
+      end
+
+      def resolved_start_task(fallback_task)
+        value = controls.task_input.text.to_s.strip
+        return value unless value.empty?
+
+        fallback_task.to_s.strip
+      end
+
+      def resolved_start_project(fallback)
+        value = controls.project_input.text.to_s.strip
+        return value unless value.empty?
+
+        fallback.to_s.strip
+      end
+
+      def switch_theme!
+        @theme = theme.with_name(next_theme_name)
+        apply_theme
+        render!
+      rescue StandardError => e
+        warn("[qtimetrap] save theme failed: #{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/app/views/main_window_runtime_archive_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Archive handlers for MainWindow runtime.
+    module MainWindowRuntimeArchiveHelpers
+      private
+
+      def handle_archive_mode_toggled(enabled)
+        view_model.archive_mode = enabled
+        render!(sync_sheet: false)
+      end
+
+      def handle_entry_archived(entry_id)
+        archive_mode_active? ? view_model.unarchive_entry(entry_id) : view_model.archive_entry(entry_id)
+        @pending_refresh = true
+      rescue StandardError => e
+        warn("[qtimetrap] archive entry failed: #{e.class}: #{e.message}")
+      end
+
+      def archive_mode_active?
+        view_model.archive_mode?
+      end
+    end
+  end
+end

data/app/views/main_window_runtime_entry_task_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Entry task move handlers for MainWindow runtime.
+    module MainWindowRuntimeEntryTaskHelpers
+      private
+
+      def handle_entry_task_changed(entry_id, task_name)
+        view_model.update_entry_task(entry_id, task_name)
+        @pending_refresh = true
+      rescue StandardError => e
+        warn("[qtimetrap] update task failed: #{e.class}: #{e.message}")
+      end
+
+      def task_suggestions_for_project(project_name)
+        view_model.task_names_for_project(project_name)
+      end
+    end
+  end
+end

data/app/views/main_window_runtime_entry_time_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Entry time change runtime behavior for MainWindow.
+    module MainWindowRuntimeEntryTimeHelpers
+      private
+
+      def handle_entry_time_changed(entry_id, start_text, end_text)
+        view_model.update_entry_time(entry_id, start_text, end_text)
+        @pending_refresh = true
+      rescue StandardError => e
+        warn("[qtimetrap] update time failed: #{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/app/views/main_window_runtime_key_helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Keyboard shortcut handlers for MainWindow runtime.
+    module MainWindowRuntimeKeyHelpers
+      private
+
+      def on_key_press(event)
+        key = extract_event_value(event, :a) || 0
+        modifiers = extract_event_value(event, :b) || 0
+        ctrl_mask = Qt::ControlModifier
+        quit_key = Qt::Key_Q
+        request_shutdown if modifiers.anybits?(ctrl_mask) && key == quit_key
+      end
+
+      def on_space_shortcut
+        return if active_line_edit?
+
+        toggle_tracking_via_space
+      end
+
+      def on_mouse_button_press(event, source_widget: window)
+        focused = window.focus_widget
+        return unless editable_line_edit?(focused)
+
+        target = click_target_widget(source_widget, event)
+        return if editable_line_edit?(target)
+
+        focused.clear_focus
+      end
+
+      def active_line_edit?
+        focused = window.focus_widget
+        editable_line_edit?(focused)
+      end
+
+      def toggle_tracking_via_space
+        if view_model.running_current_sheet?
+          handle_stop
+        else
+          handle_start(controls.task_input.text.to_s, controls.project_input.text.to_s)
+        end
+      end
+
+      def click_target_widget(source_widget, event)
+        source_widget.child_at(extract_event_value(event, :a), extract_event_value(event, :b))
+      end
+
+      def editable_line_edit?(widget)
+        widget.is_a?(QLineEdit) && !widget.is_read_only
+      end
+    end
+  end
+end

data/app/views/main_window_runtime_render_helpers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Rendering helpers for MainWindow runtime loop and interactions.
+    module MainWindowRuntimeRenderHelpers
+      private
+
+      def render!(sync_sheet: false)
+        render_sidebar
+        render_controls(sync_sheet: sync_sheet)
+        render_entries_panel
+      end
+
+      def render_sidebar
+        sidebar.render(
+          projects: view_model.project_names,
+          tasks: view_model.task_names_for_selected_project,
+          selection: {
+            selected_project: view_model.selected_project,
+            selected_projects: view_model.selected_projects
+          },
+          selected_task: view_model.selected_tasks.first,
+          archive_mode: view_model.archive_mode?
+        )
+      end
+
+      def render_entries_panel
+        entries.update_time_range_inputs(
+          from_at: view_model.time_filter_from_at,
+          to_at: view_model.time_filter_to_at
+        )
+        entries.render(view_model.entry_nodes)
+      end
+
+      def render_controls(sync_sheet:)
+        controls.update_summary(view_model.summary_line)
+        update_tracking_controls(sync_sheet: sync_sheet)
+        controls.update_theme_label(theme.name)
+      end
+
+      def update_tracking_controls(sync_sheet:)
+        controls.update_task_input(view_model.current_sheet_input) if sync_sheet
+        controls.update_action_button(running: view_model.running_current_sheet?)
+        project_name = view_model.current_project_name.to_s
+        controls.update_project_input(project_name) unless project_name.strip.empty?
+      end
+    end
+  end
+end

data/app/views/main_window_splitter_toggle_bootstrap_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Bootstrap helpers to stabilize initial splitter toggle placement.
+    module MainWindowSplitterToggleBootstrapHelpers
+      private
+
+      def schedule_initial_toggle_reposition(splitter:, sidebar_widget:, button:, zone:)
+        attempts = { count: 0 }
+        context = { splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone }
+        timer = QTimer.new(zone)
+        timer.set_interval(120)
+        timer.connect('timeout') do |_|
+          tick_initial_reposition(
+            attempts: attempts,
+            timer: timer,
+            context: context
+          )
+        end
+        timer.start
+      end
+
+      def tick_initial_reposition(attempts:, timer:, context:)
+        attempts[:count] += 1
+        reposition_toggle_affordance(**context)
+        return unless attempts[:count] >= 4
+
+        timer.stop
+        timer.delete_later
+      end
+    end
+  end
+end

data/app/views/main_window_splitter_toggle_helpers.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Views
+    # Sidebar collapse/expand toggle attached to splitter handle area.
+    module MainWindowSplitterToggleHelpers
+      include MainWindowSplitterToggleLayoutHelpers
+      include MainWindowSplitterToggleBootstrapHelpers
+      include MainWindowSplitterToggleHoverHelpers
+
+      SIDEBAR_TOGGLE_W = 20
+      SIDEBAR_TOGGLE_H = 56
+      SIDEBAR_TOGGLE_ZONE_W = 24
+      SIDEBAR_TOGGLE_ZONE_H = 128
+
+      private
+
+      def add_sidebar_toggle_button(window:, splitter:, sidebar_widget:)
+        button = build_sidebar_toggle_button(window)
+        zone = build_sidebar_toggle_zone(window)
+        state = { collapsed: false, button_hovered: false, zone_hovered: false }
+        button.connect('clicked') { |_| on_sidebar_toggle_clicked(splitter, sidebar_widget, button, zone, state) }
+        bind_splitter_toggle_events(
+          splitter: splitter,
+          sidebar_widget: sidebar_widget,
+          button: button,
+          zone: zone,
+          state: state
+        )
+        bind_toggle_button_events(button: button, state: state)
+        reposition_toggle_affordance(splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone)
+        schedule_initial_toggle_reposition(
+          splitter: splitter,
+          sidebar_widget: sidebar_widget,
+          button: button,
+          zone: zone
+        )
+      end
+
+      def build_sidebar_toggle_button(window)
+        QPushButton.new(window).tap do |button|
+          button.set_object_name('sidebar_toggle_button')
+          button.set_text('◀')
+          button.set_focus_policy(Qt::NoFocus)
+          button.set_tool_tip('Collapse sidebar')
+          button.set_fixed_size(SIDEBAR_TOGGLE_W, SIDEBAR_TOGGLE_H)
+          button.raise
+          button.hide
+        end
+      end
+
+      def on_sidebar_toggle_clicked(splitter, sidebar_widget, button, zone, state)
+        state[:collapsed] = !state[:collapsed]
+        update_sidebar_visibility(sidebar_widget, button, collapsed: state[:collapsed])
+        reposition_toggle_affordance(splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone)
+      end
+
+      def build_sidebar_toggle_zone(window)
+        QWidget.new(window).tap do |zone|
+          zone.set_object_name('sidebar_toggle_hotspot')
+          zone.set_fixed_size(SIDEBAR_TOGGLE_ZONE_W, SIDEBAR_TOGGLE_ZONE_H)
+          zone.set_style_sheet('background: transparent;')
+          zone.raise
+        end
+      end
+
+      def bind_splitter_toggle_events(splitter:, sidebar_widget:, button:, zone:, state:)
+        splitter.connect('splitterMoved') do |_|
+          reposition_toggle_affordance(splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone)
+        end
+        splitter.on(:resize) do |_|
+          reposition_toggle_affordance(splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone)
+        end
+        sidebar_widget.on(:resize) do |_|
+          reposition_toggle_affordance(splitter: splitter, sidebar_widget: sidebar_widget, button: button, zone: zone)
+        end
+        bind_toggle_zone_events(zone: zone, button: button, state: state)
+      end
+
+      def reposition_toggle_affordance(splitter:, sidebar_widget:, button:, zone:)
+        x = toggle_x(splitter: splitter, sidebar_widget: sidebar_widget)
+        y = toggle_y(splitter_height: splitter.height)
+        button.move(x, y)
+        button.raise
+        zone_x = x - ((SIDEBAR_TOGGLE_ZONE_W - SIDEBAR_TOGGLE_W) / 2)
+        zone_y = y - ((SIDEBAR_TOGGLE_ZONE_H - SIDEBAR_TOGGLE_H) / 2)
+        zone.move(zone_x, zone_y)
+      end
+
+      def update_sidebar_visibility(sidebar_widget, button, collapsed:)
+        if collapsed
+          sidebar_widget.hide
+          button.set_text('▶')
+          button.set_tool_tip('Expand sidebar')
+        else
+          sidebar_widget.show
+          button.set_text('◀')
+          button.set_tool_tip('Collapse sidebar')
+        end
+      end
+    end
+  end
+end