qtimetrap 0.1.1

data/app/components/entries/leaf_time_helpers.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Entry-leaf helpers for editable start/end time controls.
+    module LeafTimeHelpers
+      private
+
+      def add_entry_time_widgets(row_layout, row, node)
+        start_input = build_entry_time_input(
+          row,
+          object_name: 'entry_node_entry_start',
+          value: node.fetch(:start_label, '--:--'),
+          placeholder: '--:--'
+        )
+        end_input = build_entry_time_input(
+          row,
+          object_name: 'entry_node_entry_end',
+          value: node.fetch(:end_label, 'running'),
+          placeholder: 'running'
+        )
+        row_layout.add_widget(build_entry_time_group(row, start_input, end_input))
+        [start_input, end_input]
+      end
+
+      def build_entry_time_group(row, start_input, end_input)
+        QWidget.new(row).tap do |time_group|
+          time_group.set_object_name('entry_node_entry_time_group')
+          QHBoxLayout.new(time_group).tap do |time_layout|
+            time_layout.set_contents_margins(0, 0, 0, 0)
+            time_layout.set_spacing(4)
+            time_layout.add_widget(start_input)
+            time_layout.add_widget(build_entry_time_separator(time_group))
+            time_layout.add_widget(end_input)
+          end
+        end
+      end
+
+      def build_entry_time_separator(row)
+        QLabel.new(row).tap do |separator|
+          separator.set_object_name('entry_node_entry_time_sep')
+          separator.set_text('-')
+        end
+      end
+
+      def build_entry_time_input(row, object_name:, value:, placeholder:)
+        QLineEdit.new(row).tap do |time_input|
+          time_input.set_object_name(object_name)
+          time_input.text = value.to_s
+          time_input.set_placeholder_text(placeholder)
+          time_input.set_alignment(Qt::AlignCenter)
+          time_input.set_read_only(true)
+          time_input.set_fixed_width(58)
+        end
+      end
+
+      def bind_entry_time_input_events(start_input, end_input, entry_id)
+        bind_single_time_input(start_input, entry_id, start_input, end_input)
+        bind_single_time_input(end_input, entry_id, start_input, end_input)
+      end
+
+      def bind_single_time_input(time_input, entry_id, start_input, end_input)
+        time_input.on(:mouse_button_press) { |_| activate_entry_note_input(time_input) }
+        time_input.on(:key_press) do |event|
+          handle_entry_time_key_press(
+            time_input: time_input,
+            entry_id: entry_id,
+            start_input: start_input,
+            end_input: end_input,
+            event: event
+          )
+        end
+        time_input.connect('returnPressed') do |_|
+          handle_entry_time_commit(
+            time_input: time_input,
+            entry_id: entry_id,
+            start_input: start_input,
+            end_input: end_input
+          )
+        end
+        time_input.on(:focus_out) { |_| handle_entry_note_focus_out(time_input) }
+      end
+
+      def handle_entry_time_key_press(time_input:, entry_id:, start_input:, end_input:, event:)
+        return unless enter_key?(event)
+
+        handle_entry_time_commit(
+          time_input: time_input,
+          entry_id: entry_id,
+          start_input: start_input,
+          end_input: end_input
+        )
+      end
+
+      def handle_entry_time_commit(time_input:, entry_id:, start_input:, end_input:)
+        return if time_input.is_read_only
+
+        deactivate_entry_note_input(time_input)
+        return unless on_entry_time_change
+
+        on_entry_time_change.call(entry_id, start_input.text.to_s, end_input.text.to_s)
+      end
+    end
+  end
+end

data/app/components/entries/list_component.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Renders expandable week/day/project nodes and leaf time entries.
+    class ListComponent
+      include ListHostHelpers
+      include ListStateHelpers
+      include QtUiHelpers
+      include TreeHelpers
+      include RenderHelpers
+
+      HOST_HORIZONTAL_MARGINS = 28
+      WIDTH_PADDING = 24
+      TIME_FILTER_DEBOUNCE_MS = 220
+
+      attr_reader :widget
+
+      def initialize(parent:, callbacks: {}, task_suggestions_for_project: nil)
+        @parent = parent
+        @on_entry_note_change = callbacks[:on_entry_note_change]
+        @on_entry_task_change = callbacks[:on_entry_task_change]
+        @task_suggestions_for_project = task_suggestions_for_project
+        @on_entry_time_change = callbacks[:on_entry_time_change]
+        @on_entry_archive = callbacks[:on_entry_archive]
+        @on_time_range_change = callbacks[:on_time_range_change]
+        initialize_state!
+        build
+      end
+
+      def render(nodes)
+        return if rendering
+
+        @rendering = true
+        @current_nodes = Array(nodes)
+        @branch_bindings = {}
+        @leaf_labels = []
+        @entry_rows = []
+        with_widget_updates_suspended { render_contents }
+      ensure
+        @rendering = false
+      end
+
+      def update_time_range_inputs(from_at:, to_at:)
+        @syncing_time_filters = true
+        set_time_filter_state(
+          toggle: time_filter_from_toggle,
+          input: time_filter_from_input,
+          value: from_at
+        )
+        set_time_filter_state(
+          toggle: time_filter_to_toggle,
+          input: time_filter_to_input,
+          value: to_at
+        )
+      ensure
+        @syncing_time_filters = false
+      end
+
+      def shutdown
+        return unless time_filter_debounce
+
+        time_filter_debounce.stop if time_filter_debounce.is_active
+      end
+
+      private
+
+      attr_reader :parent, :host, :host_layout, :expanded, :current_nodes, :branch_bindings, :leaf_labels, :entry_rows,
+                  :rendering, :scroll_area, :on_entry_note_change, :on_entry_task_change, :task_suggestions_for_project,
+                  :on_entry_time_change, :on_entry_archive, :on_time_range_change,
+                  :time_filter_from_toggle, :time_filter_to_toggle, :time_filter_from_input, :time_filter_to_input,
+                  :time_filter_debounce
+
+      def build
+        @widget = QWidget.new(parent)
+        widget.set_object_name('entries_panel')
+        panel_layout = build_panel_layout
+        @time_filter_debounce = build_time_filter_debounce_timer
+        panel_layout.add_widget(build_toolbar(parent_widget: widget))
+        @scroll_area = build_scroll_area
+        bind_scroll_resize
+        panel_layout.add_widget(scroll_area)
+        panel_layout.set_stretch(1, 1)
+        rebuild_host!
+      end
+
+      def branch_button_width
+        available = scroll_area.width - HOST_HORIZONTAL_MARGINS - WIDTH_PADDING
+        [available, 120].max
+      end
+
+      def adjust_node_widths
+        width = branch_button_width
+        branch_bindings.each_value { |binding| binding.fetch(:button).set_fixed_width(width) }
+        leaf_labels.each { |label| label.set_fixed_width(width) }
+        entry_rows.each { |row| row.set_fixed_width(width) }
+      end
+
+      def build_panel_layout
+        QVBoxLayout.new(widget).tap do |layout|
+          layout.set_contents_margins(0, 0, 0, 0)
+          layout.set_spacing(6)
+        end
+      end
+
+      def build_scroll_area
+        QScrollArea.new(widget).tap do |area|
+          area.set_object_name('entries_scroll')
+          area.set_widget_resizable(true)
+        end
+      end
+
+      def bind_scroll_resize
+        scroll_area.on(:resize) { |_| adjust_node_widths }
+      end
+    end
+  end
+end

data/app/components/entries/list_host_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Host/viewport helpers for entries list rendering.
+    module ListHostHelpers
+      private
+
+      def build_host
+        QWidget.new(scroll_area).tap { |container| container.set_object_name('entries_host') }
+      end
+
+      def build_host_layout
+        QVBoxLayout.new(host).tap do |layout|
+          layout.set_contents_margins(14, 10, 14, 10)
+          layout.set_spacing(2)
+        end
+      end
+
+      def rebuild_host!
+        @host = build_host
+        @host_layout = build_host_layout
+        scroll_area.set_widget(host)
+      end
+    end
+  end
+end

data/app/components/entries/list_state_helpers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Internal state and debounce helpers for entries list component.
+    module ListStateHelpers
+      private
+
+      def initialize_state!
+        initialize_tree_state!
+        initialize_time_filter_state!
+      end
+
+      def initialize_tree_state!
+        @expanded = {}
+        @current_nodes = []
+        @branch_bindings = {}
+        @leaf_labels = []
+        @entry_rows = []
+        @rendering = false
+      end
+
+      def initialize_time_filter_state!
+        @time_filter_from_toggle = nil
+        @time_filter_to_toggle = nil
+        @time_filter_from_input = nil
+        @time_filter_to_input = nil
+        @time_filter_debounce = nil
+        @syncing_time_filters = false
+      end
+
+      def set_time_filter_state(toggle:, input:, value:)
+        enabled = !value.nil?
+        toggle.set_checked(enabled)
+        input.set_date_time(value) if enabled
+      end
+
+      def syncing_time_filters?
+        @syncing_time_filters
+      end
+
+      def schedule_time_range_filter_changed
+        return if syncing_time_filters?
+        return unless on_time_range_change
+
+        time_filter_debounce.stop if time_filter_debounce.is_active
+        time_filter_debounce.start
+      end
+
+      def build_time_filter_debounce_timer
+        QTimer.new(parent).tap do |timer|
+          timer.set_single_shot(true)
+          timer.set_interval(self.class::TIME_FILTER_DEBOUNCE_MS)
+          timer.connect('timeout') { |_| emit_time_range_filter_changed }
+        end
+      end
+    end
+  end
+end

data/app/components/entries/node_presentation_helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Node text/object-name helpers for entries tree rendering.
+    module NodePresentationHelpers
+      private
+
+      def object_name_for(node)
+        case node.fetch(:type)
+        when :week then 'entry_node_week'
+        when :day then 'entry_node_day'
+        when :project then 'entry_node_project'
+        when :entry then 'entry_node_entry'
+        else 'entry_node_empty'
+        end
+      end
+
+      def indent(level)
+        '  ' * level
+      end
+
+      def branch_button_text(level, label, expanded_state)
+        prefix = expanded_state ? '▾' : '▸'
+        "#{indent(level)}#{prefix}  #{label}"
+      end
+    end
+  end
+end

data/app/components/entries/render_helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Render-cycle helpers to reduce flicker during entries tree rebuild.
+    module RenderHelpers
+      private
+
+      def with_widget_updates_suspended
+        widget.set_updates_enabled(false)
+        yield
+      ensure
+        widget.set_updates_enabled(true)
+        widget.update
+      end
+
+      def render_contents
+        rebuild_host!
+        render_nodes(current_nodes, 0)
+        adjust_node_widths
+        host_layout.add_stretch(1)
+      end
+    end
+  end
+end

data/app/components/entries/tree_helpers.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Helper methods for entries tree rendering and expand/collapse controls.
+    module TreeHelpers
+      include BranchHierarchyHelpers
+      include LeafArchiveHelpers
+      include LeafNoteHelpers
+      include LeafTaskHelpers
+      include LeafTimeHelpers
+      include NodePresentationHelpers
+      include TreeToolbarHelpers
+
+      private
+
+      def on_filter_toggle_changed
+        schedule_time_range_filter_changed
+      end
+
+      def set_initial_filter_ui_state
+        time_filter_from_toggle.set_checked(false)
+        time_filter_to_toggle.set_checked(false)
+      end
+
+      def emit_time_range_filter_changed
+        return if syncing_time_filters?
+        return unless on_time_range_change
+
+        on_time_range_change.call(selected_time_filter(time_filter_from_toggle, time_filter_from_input),
+                                  selected_time_filter(time_filter_to_toggle, time_filter_to_input))
+      end
+
+      def selected_time_filter(toggle, input)
+        return nil unless filter_toggle_checked?(toggle)
+
+        input.date_time
+      end
+
+      def filter_toggle_checked?(toggle)
+        value = toggle.is_checked
+        [true, 1].include?(value)
+      end
+
+      def expand_all!
+        set_all_branch_nodes(current_nodes, true)
+        apply_all_branch_states
+      end
+
+      def collapse_all!
+        set_all_branch_nodes(current_nodes, false)
+        apply_all_branch_states
+      end
+
+      def set_all_branch_nodes(nodes, value)
+        nodes.each do |node|
+          next unless branch_node?(node)
+
+          expanded[node.fetch(:id)] = value
+          set_all_branch_nodes(node.fetch(:children), value)
+        end
+      end
+
+      def render_nodes(nodes, level, layout: host_layout, parent_widget: host)
+        nodes.each { |node| render_node(node, level, layout: layout, parent_widget: parent_widget) }
+      end
+
+      def render_node(node, level, layout:, parent_widget:)
+        if branch_node?(node)
+          render_branch_node(node, level, layout: layout, parent_widget: parent_widget)
+        else
+          render_leaf_node(node, level, layout: layout, parent_widget: parent_widget)
+        end
+      end
+
+      def render_branch_node(node, level, layout:, parent_widget:)
+        node_id = node.fetch(:id)
+        label = node.fetch(:label)
+        expanded_state = expanded.fetch(node.fetch(:id), true)
+        button = build_branch_button(node, level, expanded_state, parent_widget: parent_widget)
+        layout.add_widget(button)
+        children_container, children_layout = build_children_container(parent_widget)
+        layout.add_widget(children_container)
+        register_branch_binding(
+          node_id: node_id,
+          button: button,
+          children_container: children_container,
+          label: label,
+          level: level
+        )
+        render_nodes(node.fetch(:children), level + 1, layout: children_layout, parent_widget: children_container)
+        apply_branch_state(node_id, expanded_state)
+      end
+
+      def render_leaf_node(node, level, layout:, parent_widget:)
+        if node.fetch(:type) == :entry
+          render_entry_leaf_node(node, level, layout: layout, parent_widget: parent_widget)
+          return
+        end
+
+        render_default_leaf_node(node, level, parent_widget: parent_widget, layout: layout)
+      end
+
+      def render_default_leaf_node(node, level, parent_widget:, layout:)
+        label = QLabel.new(parent_widget)
+        label.set_object_name(object_name_for(node))
+        label.set_text("#{indent(level)}#{node.fetch(:label)}")
+        label.set_fixed_width(branch_button_width)
+        label.set_fixed_height(32)
+        leaf_labels << label
+        layout.add_widget(label)
+      end
+
+      def toggle_node(node_id)
+        expanded[node_id] = !expanded.fetch(node_id, true)
+        apply_branch_state(node_id, expanded[node_id])
+      end
+
+      def branch_node?(node)
+        !node.fetch(:children).empty?
+      end
+
+      def build_branch_button(node, level, expanded_state, parent_widget:)
+        text = branch_button_text(level, node.fetch(:label), expanded_state)
+        button = build_button(parent_widget, object_name_for(node), text, 0, 32)
+        button.set_fixed_width(branch_button_width)
+        node_id = node.fetch(:id)
+        button.connect('clicked') { |_| toggle_node(node_id) }
+        button
+      end
+    end
+  end
+end

data/app/components/entries/tree_toolbar_helpers.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Toolbar builders for entries tree controls and time-range filters.
+    module TreeToolbarHelpers
+      private
+
+      def build_toolbar(parent_widget:)
+        toolbar = QWidget.new(parent_widget)
+        toolbar.set_object_name('entries_toolbar')
+        layout = build_toolbar_layout(toolbar)
+        add_tree_toolbar_buttons(layout, toolbar)
+        add_time_filter_controls(layout, toolbar)
+        set_initial_filter_ui_state
+        layout.add_stretch(1)
+        toolbar
+      end
+
+      def build_toolbar_layout(toolbar)
+        QHBoxLayout.new(toolbar).tap do |layout|
+          layout.set_contents_margins(0, 0, 0, 0)
+          layout.set_spacing(8)
+        end
+      end
+
+      def add_tree_toolbar_buttons(layout, toolbar)
+        add_toolbar_button(layout, toolbar, 'entries_expand_all', 'EXPAND ALL') { expand_all! }
+        add_toolbar_button(layout, toolbar, 'entries_collapse_all', 'COLLAPSE ALL') { collapse_all! }
+        layout.add_spacing(8)
+      end
+
+      def add_toolbar_button(layout, toolbar, name, text, &)
+        layout.add_widget(build_toolbar_button(toolbar, name, text, &))
+      end
+
+      def add_time_filter_controls(layout, toolbar)
+        @time_filter_from_toggle = add_filter_control(
+          layout: layout,
+          toolbar: toolbar,
+          toggle_name: 'entries_time_filter_from_toggle',
+          toggle_text: 'FROM',
+          input_name: 'entries_time_filter_from'
+        )
+        @time_filter_to_toggle = add_filter_control(
+          layout: layout,
+          toolbar: toolbar,
+          toggle_name: 'entries_time_filter_to_toggle',
+          toggle_text: 'TO',
+          input_name: 'entries_time_filter_to'
+        )
+      end
+
+      def add_filter_control(layout:, toolbar:, toggle_name:, toggle_text:, input_name:)
+        toggle = build_filter_toggle(toolbar, toggle_name, toggle_text)
+        layout.add_widget(toggle)
+        input = build_filter_input(toolbar, input_name)
+        layout.add_widget(input)
+        assign_filter_input(toggle_name, input)
+        toggle
+      end
+
+      def assign_filter_input(toggle_name, input)
+        if toggle_name == 'entries_time_filter_from_toggle'
+          @time_filter_from_input = input
+        else
+          @time_filter_to_input = input
+        end
+      end
+
+      def build_toolbar_button(parent_widget, name, text)
+        build_button(parent_widget, name, text, 136, 28).tap { |button| button.connect('clicked') { |_| yield } }
+      end
+
+      def build_filter_toggle(parent_widget, name, text)
+        QCheckBox.new(parent_widget).tap do |checkbox|
+          checkbox.set_object_name(name)
+          checkbox.set_text(text)
+          checkbox.set_focus_policy(Qt::NoFocus)
+          checkbox.set_fixed_height(28)
+          checkbox.connect('clicked') { |_| on_filter_toggle_changed }
+        end
+      end
+
+      def build_filter_input(parent_widget, name)
+        QDateTimeEdit.new(parent_widget).tap do |input|
+          input.set_object_name(name)
+          input.set_focus_policy(Qt::ClickFocus)
+          input.set_fixed_width(172)
+          input.set_calendar_popup(true)
+          input.set_display_format('yyyy-MM-dd HH:mm')
+          input.set_date_time(Time.now)
+          input.connect('dateTimeChanged(QDateTime)') { |_| schedule_time_range_filter_changed }
+        end
+      end
+    end
+  end
+end

data/app/components/project_sidebar/archive_toggle_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Bottom archive mode toggle button in sidebar.
+    module ArchiveToggleHelpers
+      private
+
+      def build_archive_toggle_button
+        QPushButton.new(widget).tap do |button|
+          button.set_object_name('sidebar_archive_toggle')
+          button.set_checkable(true)
+          button.set_focus_policy(Qt::NoFocus)
+          button.set_fixed_height(30)
+          button.set_text("\u{1F5C3}")
+          button.set_tool_tip('Show archived entries only')
+          button.connect('clicked') { |_| on_archive_mode_toggled&.call(button.is_checked) }
+        end
+      end
+    end
+  end
+end