qtimetrap 0.1.1

data/app/components/project_sidebar/component.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Displays project shortcuts and notifies on project selection.
+    class Component
+      include ArchiveToggleHelpers
+      include LogoHelpers
+      include ProjectButtonHelpers
+      include ProjectSelectionHelpers
+      include TaskHelpers
+
+      attr_reader :widget
+
+      def initialize(
+        parent:,
+        on_project_selected:,
+        on_task_selected: nil,
+        on_archive_mode_toggled: nil
+      )
+        @parent = parent
+        @on_project_selected = on_project_selected
+        @on_task_selected = on_task_selected
+        @on_archive_mode_toggled = on_archive_mode_toggled
+        initialize_selection_state
+        build
+      end
+
+      def render(projects:, tasks: [], selection: {}, selected_task: nil, archive_mode: false)
+        values = Array(projects)
+        selection = selection_state(selection)
+        render_projects(projects: values, selection: selection)
+        render_tasks(tasks: tasks, selected_project: selection.fetch(:selected_project), selected_task: selected_task)
+        archive_toggle_button.set_checked(archive_mode)
+      end
+
+      private
+
+      attr_reader :parent, :on_project_selected, :on_task_selected, :buttons, :buttons_layout, :task_buttons,
+                  :task_buttons_layout, :tasks_heading, :on_archive_mode_toggled, :archive_toggle_button
+
+      def build
+        @widget = QWidget.new(parent)
+        widget.set_object_name('sidebar_panel')
+        layout = build_root_layout
+        add_static_sidebar_sections(layout)
+        @buttons_layout = build_buttons_layout
+        layout.add_layout(buttons_layout)
+        add_tasks_section(layout)
+        layout.add_stretch(1)
+        @archive_toggle_button = build_archive_toggle_button
+        layout.add_widget(archive_toggle_button)
+      end
+
+      def render_slot(slot, project, index:)
+        slot[:project] = project
+        view = slot[:view]
+
+        view.set_text(project[0, 24])
+        view.set_disabled(false)
+        view.set_checked(selected_project_indices.include?(index))
+        view.show
+      end
+
+      def sync_project_buttons(target_count)
+        while buttons.size < target_count
+          button = build_project_button
+          buttons_layout.add_widget(button)
+          buttons << { view: button, project: nil }
+        end
+
+        while buttons.size > target_count
+          slot = buttons.pop
+          slot.fetch(:view).hide
+        end
+      end
+
+      def build_root_layout
+        QVBoxLayout.new(widget).tap do |layout|
+          layout.set_contents_margins(12, 12, 12, 12)
+          layout.set_spacing(8)
+        end
+      end
+
+      def initialize_selection_state
+        @buttons = []
+        @selected_project_indices = []
+        @last_project_anchor_index = nil
+        @project_values = []
+        @task_buttons = []
+        @selected_task_indices = []
+        @last_task_anchor_index = nil
+        @task_values = []
+      end
+
+      def add_static_sidebar_sections(layout)
+        layout.add_widget(build_logo)
+        layout.add_widget(build_logo_spacer)
+        layout.add_widget(build_heading)
+      end
+
+      def add_tasks_section(layout)
+        @tasks_heading = build_tasks_heading
+        tasks_heading.hide
+        layout.add_widget(tasks_heading)
+        @task_buttons_layout = build_buttons_layout
+        layout.add_layout(task_buttons_layout)
+      end
+
+      def selection_state(selection)
+        {
+          selected_project: selection.fetch(:selected_project, '* ALL'),
+          selected_projects: selection.fetch(:selected_projects, ['* ALL'])
+        }
+      end
+
+      def build_buttons_layout
+        QVBoxLayout.new.tap do |layout|
+          layout.set_contents_margins(0, 0, 0, 0)
+          layout.set_spacing(8)
+        end
+      end
+    end
+  end
+end

data/app/components/project_sidebar/logo_helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Sidebar header/logo construction helpers.
+    module LogoHelpers
+      private
+
+      def build_logo
+        QWidget.new(widget).tap do |container|
+          container.set_object_name('sidebar_logo')
+          layout = QHBoxLayout.new(container)
+          layout.set_contents_margins(0, 0, 0, 0)
+          layout.set_spacing(8)
+          layout.add_stretch(1)
+          layout.add_widget(build_logo_icon(container))
+          layout.add_widget(build_logo_text(container))
+          layout.add_stretch(1)
+        end
+      end
+
+      def build_logo_icon(parent_widget)
+        QLabel.new(parent_widget).tap do |label|
+          label.set_object_name('sidebar_logo_icon')
+          label.set_alignment(Qt::AlignCenter)
+          label.set_fixed_size(66, 66)
+          icon_path = File.join(Application.root, 'app', 'assets', 'icons', 'qtimetrap-icon-128.png')
+          label.set_text("<img src='#{icon_path}' width='64' height='64'/>")
+        end
+      end
+
+      def build_logo_text(parent_widget)
+        QLabel.new(parent_widget).tap do |label|
+          label.set_object_name('sidebar_logo_text')
+          label.set_alignment(Qt::AlignCenter)
+          label.set_text('QTimetrap')
+        end
+      end
+
+      def build_logo_spacer
+        QWidget.new(widget).tap { |spacer| spacer.set_fixed_height(6) }
+      end
+
+      def build_heading
+        QLabel.new(widget).tap do |label|
+          label.set_object_name('sidebar_heading')
+          label.set_alignment(Qt::AlignCenter)
+          label.set_text('PROJECTS')
+        end
+      end
+    end
+  end
+end

data/app/components/project_sidebar/project_button_helpers.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Project button rendering and interaction behavior for the sidebar.
+    module ProjectButtonHelpers
+      private
+
+      def render_projects(projects:, selection:)
+        refresh_project_state(projects, selection.fetch(:selected_projects), selection.fetch(:selected_project))
+        sync_project_buttons(projects.size)
+        rerender_project_buttons(projects)
+      end
+
+      def sync_project_buttons(target_count)
+        while buttons.size < target_count
+          button = build_project_button
+          buttons_layout.add_widget(button)
+          buttons << { view: button, project: nil }
+        end
+
+        while buttons.size > target_count
+          slot = buttons.pop
+          slot.fetch(:view).hide
+        end
+      end
+
+      def render_slot(slot, project, index:)
+        slot[:project] = project
+        view = slot[:view]
+
+        view.set_text(project[0, 24])
+        view.set_disabled(false)
+        view.set_checked(selected_project_indices.include?(index))
+        view.show
+      end
+
+      def build_project_button
+        QPushButton.new(widget).tap do |button|
+          button.set_object_name('project_button')
+          button.set_checkable(true)
+          button.set_focus_policy(Qt::NoFocus)
+          button.set_fixed_height(30)
+          button.connect('clicked') { |_| on_button_clicked(button) }
+        end
+      end
+
+      def on_button_clicked(button)
+        index, item = selected_project_button(button)
+        return unless index && item
+
+        apply_project_selection(index)
+        rerender_project_buttons(project_values)
+        on_project_selected.call(selected_project_values, item[:project])
+      end
+
+      def selected_project_button(button)
+        index = buttons.index { |candidate| candidate[:view] == button }
+        return [nil, nil] unless index
+
+        item = buttons.fetch(index)
+        return [nil, nil] unless item[:project]
+
+        [index, item]
+      end
+
+      def rerender_project_buttons(projects)
+        buttons.each_with_index { |slot, index| render_slot(slot, projects[index], index: index) }
+      end
+    end
+  end
+end

data/app/components/project_sidebar/project_selection_helpers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Selection state behavior for sidebar project shortcuts.
+    module ProjectSelectionHelpers
+      private
+
+      def refresh_project_state(values, selected_projects, selected_project)
+        values_changed = project_values != values
+        @project_values = values.dup
+        return normalize_project_selection(selected_project) unless values_changed
+
+        @selected_project_indices = []
+        @last_project_anchor_index = nil
+        normalized = normalize_selected_projects(values, selected_projects, selected_project)
+        @selected_project_indices = normalized.filter_map { |project| values.index(project) }
+        @last_project_anchor_index = values.index(selected_project) || selected_project_indices.last
+      end
+
+      def normalize_project_selection(selected_project)
+        @selected_project_indices = in_range_project_indices
+        normalized = normalize_selected_projects(project_values, selected_project_values, selected_project)
+        @selected_project_indices = indices_for_projects(normalized)
+        @last_project_anchor_index = anchor_index_for(selected_project)
+      end
+
+      def apply_project_selection(index)
+        ctrl, shift = selection_modifiers
+        if shift && !last_project_anchor_index.nil?
+          apply_project_shift_selection(index, ctrl: ctrl)
+        elsif ctrl
+          toggle_project_index(index)
+        else
+          @selected_project_indices = [index]
+        end
+
+        @last_project_anchor_index = index
+        normalize_project_all_selection
+      end
+
+      def apply_project_shift_selection(index, ctrl:)
+        first = [last_project_anchor_index, index].min
+        last = [last_project_anchor_index, index].max
+        range = (first..last).to_a
+        @selected_project_indices = ctrl ? (selected_project_indices | range) : range
+      end
+
+      def toggle_project_index(index)
+        @selected_project_indices = if selected_project_indices.include?(index)
+                                      selected_project_indices - [index]
+                                    else
+                                      selected_project_indices + [index]
+                                    end
+      end
+
+      def normalize_project_all_selection
+        all_index = project_values.index('* ALL')
+        return unless all_index
+        return @selected_project_indices = [all_index] if selected_project_indices.empty?
+        return unless selected_project_indices.include?(all_index) && selected_project_indices.length > 1
+
+        @selected_project_indices = [last_project_anchor_index == all_index ? all_index : last_project_anchor_index]
+      end
+
+      def normalize_selected_projects(values, selected_projects, selected_project)
+        normalized = Array(selected_projects).map(&:to_s).reject(&:empty?).uniq
+        normalized = [selected_project.to_s] if normalized.empty? && !selected_project.to_s.empty?
+        normalized &= values
+        normalized = ['* ALL'] if normalized.empty? || normalized.include?('* ALL')
+        normalized
+      end
+
+      def selected_project_values
+        selected_project_indices.filter_map { |index| project_values[index] }
+      end
+
+      def in_range_project_indices
+        max_index = project_values.length - 1
+        selected_project_indices.select { |index| index <= max_index }
+      end
+
+      def indices_for_projects(projects)
+        projects.filter_map { |project| project_values.index(project) }
+      end
+
+      def anchor_index_for(selected_project)
+        project_values.index(selected_project) || selected_project_indices.last
+      end
+
+      attr_reader :selected_project_indices, :last_project_anchor_index, :project_values
+    end
+  end
+end

data/app/components/project_sidebar/task_helpers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Sidebar tasks section rendering and interactions.
+    module TaskHelpers
+      include TaskSelectionHelpers
+
+      private
+
+      def render_tasks(tasks:, selected_project:, selected_task:)
+        values = Array(tasks)
+        visible = tasks_visible?(selected_project, values)
+        tasks_heading.set_visible(visible)
+        sync_task_buttons(visible ? values.size : 0)
+        return clear_task_state unless visible
+
+        refresh_task_state(values, selected_task)
+        fill_task_buttons(values)
+      end
+
+      def sync_task_buttons(target_count)
+        while task_buttons.size < target_count
+          button = build_task_button
+          task_buttons_layout.add_widget(button)
+          task_buttons << { view: button, task: nil }
+        end
+
+        while task_buttons.size > target_count
+          slot = task_buttons.pop
+          slot.fetch(:view).hide
+        end
+      end
+
+      def build_tasks_heading
+        QLabel.new(widget).tap do |label|
+          label.set_object_name('sidebar_tasks_heading')
+          label.set_alignment(Qt::AlignCenter)
+          label.set_text('TASKS')
+        end
+      end
+
+      def build_task_button
+        QPushButton.new(widget).tap do |button|
+          button.set_object_name('task_button')
+          button.set_checkable(true)
+          button.set_focus_policy(Qt::NoFocus)
+          button.set_fixed_height(28)
+          button.connect('clicked') { |_| on_task_button_clicked(button) }
+        end
+      end
+
+      def on_task_button_clicked(button)
+        index = task_buttons.index { |candidate| candidate[:view] == button }
+        return unless index
+
+        item = task_buttons.fetch(index)
+        return unless item && item[:task]
+
+        apply_task_selection(index)
+        fill_task_buttons(task_values)
+        return unless on_task_selected
+
+        on_task_selected.call(selected_task_values, item[:task])
+      end
+
+      def tasks_visible?(selected_project, values)
+        selected_project != '* ALL' && !values.empty?
+      end
+
+      def fill_task_buttons(values)
+        task_buttons.each_with_index do |slot, index|
+          update_task_button(slot: slot, task: values[index], index: index)
+        end
+      end
+
+      def update_task_button(slot:, task:, index:)
+        view = slot.fetch(:view)
+        slot[:task] = task
+        text = task.to_s
+        view.set_text(text)
+        view.set_tool_tip(text)
+        view.set_checked(selected_task_indices.include?(index))
+        view.show
+      end
+
+      def selected_task_values
+        selected_task_indices.filter_map { |index| task_values[index] }
+      end
+
+      attr_reader :selected_task_indices, :last_task_anchor_index, :task_values
+    end
+  end
+end

data/app/components/project_sidebar/task_selection_helpers.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ProjectSidebar
+    # Selection state behavior for sidebar task shortcuts.
+    module TaskSelectionHelpers
+      private
+
+      def refresh_task_state(values, selected_task)
+        values_changed = task_values != values
+        @task_values = values.dup
+        return normalize_task_selection unless values_changed
+
+        @selected_task_indices = []
+        @last_task_anchor_index = nil
+        return unless selected_task
+
+        index = values.index(selected_task)
+        return unless index
+
+        @selected_task_indices = [index]
+        @last_task_anchor_index = index
+      end
+
+      def clear_task_state
+        @task_values = []
+        @selected_task_indices = []
+        @last_task_anchor_index = nil
+      end
+
+      def normalize_task_selection
+        max_index = task_values.length - 1
+        @selected_task_indices = selected_task_indices.select { |index| index <= max_index }
+        @last_task_anchor_index = nil unless selected_task_indices.include?(last_task_anchor_index)
+      end
+
+      def apply_task_selection(index)
+        ctrl, shift = selection_modifiers
+        if shift && !last_task_anchor_index.nil?
+          apply_shift_selection(index, ctrl: ctrl)
+        elsif ctrl
+          toggle_task_index(index)
+        else
+          @selected_task_indices = [index]
+        end
+        @last_task_anchor_index = index
+      end
+
+      def selection_modifiers
+        modifiers = QApplication.keyboard_modifiers.to_i
+        ctrl = modifiers.anybits?(Qt::ControlModifier)
+        shift = modifiers.anybits?(Qt::ShiftModifier)
+        [ctrl, shift]
+      end
+
+      def apply_shift_selection(index, ctrl:)
+        first = [last_task_anchor_index, index].min
+        last = [last_task_anchor_index, index].max
+        range = (first..last).to_a
+        @selected_task_indices = ctrl ? (selected_task_indices | range) : range
+      end
+
+      def toggle_task_index(index)
+        @selected_task_indices = if selected_task_indices.include?(index)
+                                   selected_task_indices - [index]
+                                 else
+                                   selected_task_indices + [index]
+                                 end
+      end
+    end
+  end
+end

data/app/components/qt_ui_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  # Shared helpers for naming and creating common Qt widgets.
+  module QtUiHelpers
+    private
+
+    def build_label(parent_widget, object_name, text, width: nil, height: nil)
+      QLabel.new(parent_widget).tap do |label|
+        label.set_object_name(object_name)
+        label.set_text(text) if text
+        label.set_fixed_width(width) if width
+        label.set_fixed_height(height) if height
+      end
+    end
+
+    def build_button(parent_widget, name, text, width, height)
+      QPushButton.new(parent_widget).tap do |button|
+        button.set_object_name(name)
+        button.set_text(text)
+        button.set_focus_policy(Qt::NoFocus)
+        button.set_fixed_width(width) if width&.positive?
+        button.set_fixed_height(height)
+      end
+    end
+  end
+end

data/app/components/tracker_controls/component.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module TrackerControls
+    # Contains main tracking controls, summary labels, and theme actions.
+    class Component
+      TIMER_FONT_MIN_PT = 12
+      TIMER_FONT_MAX_PT = 20
+      TIMER_CHAR_WIDTH_FACTOR = 0.72
+      TIMER_HORIZONTAL_PADDING = 12
+      TIMER_FIT_SAMPLE = '000:00:00'
+
+      attr_reader :task_input, :project_input, :clock_label, :timer_label, :widget
+
+      def initialize(parent:, callbacks:)
+        assign_ui(build_ui(parent:, callbacks:))
+      end
+
+      def update_summary(text)
+        summary_label.set_text(text)
+      end
+
+      def update_project_input(project_name)
+        value = project_name.to_s.strip
+        project_input.set_text(value)
+      end
+
+      def update_task_input(text)
+        task_input.text = text.to_s
+      end
+
+      def update_theme_label(theme_name)
+        theme_button.set_text("THEME: #{theme_name.upcase}")
+      end
+
+      def update_action_button(running:)
+        start_button.set_visible(!running)
+        stop_button.set_visible(running)
+        task_input.set_read_only(running)
+        project_input.set_read_only(running)
+      end
+
+      private
+
+      attr_reader :summary_label, :theme_button, :start_button, :stop_button
+
+      def apply_timer_font_fit(text)
+        chars = [text.length, 1].max
+        available = [timer_label.width - TIMER_HORIZONTAL_PADDING, 24].max
+        estimated = (available / (chars * TIMER_CHAR_WIDTH_FACTOR)).floor
+        font_size = estimated.clamp(TIMER_FONT_MIN_PT, TIMER_FONT_MAX_PT)
+        timer_label.set_style_sheet("font-size: #{font_size}pt;")
+      end
+
+      def build_ui(parent:, callbacks:)
+        LayoutBuilder.new(
+          parent: parent,
+          callbacks: callbacks
+        ).build
+      end
+
+      def assign_ui(ui_map)
+        @widget = ui_map.fetch(:widget)
+        @task_input = ui_map.fetch(:task_input)
+        @clock_label = ui_map.fetch(:clock_label)
+        @timer_label = ui_map.fetch(:timer_label)
+        @summary_label = ui_map.fetch(:summary_label)
+        @project_input = ui_map.fetch(:project_input)
+        @theme_button = ui_map.fetch(:theme_button)
+        @start_button = ui_map.fetch(:start_button)
+        @stop_button = ui_map.fetch(:stop_button)
+        configure_timer_font_fit!
+      end
+
+      def configure_timer_font_fit!
+        apply_timer_font_fit(TIMER_FIT_SAMPLE)
+      end
+    end
+  end
+end