qtimetrap 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5287d989740a397f7ed84b151eb5d3d48ab8edd480bb580517cfdedc8e20bb54
-  data.tar.gz: 6234dfac9679d2b577999f83b561226d03bc70201743f8df8c4668d0e8c5fe57
+  metadata.gz: '018f44eb75f1594bcb9a78ac9f9cf8663901e2c3bf34d76f324f6e5a955da4d1'
+  data.tar.gz: b0c0f032ae783bb94d12061186c8430596ae7c5dbcef6497337113517bebc6b5
 SHA512:
-  metadata.gz: 140de50f2fde21743d1f58e108ceed523906dc79d2971ae519a45dda8fbdce3e5850f6a179c926580d6b3436450b2dd56f96a725619dc09fc8191fb3127db18c
-  data.tar.gz: 1cb985651e8bc995f9ad5d9fe554c5ef151a11a2bdcd88c31882c872d17bf765ab3cb3f1aaaf6924dc1bd44aef947c47a991b55447a76f2c5f29c93f950f9ec2
+  metadata.gz: 10055a894a818debb7f33541ca4146fe65eb46e0bb364f10d0d7d0cc8bee9d3ee0421658fd9848d186a264d4fa2bd9c1830c166c5e11cdf990ed39bdc5cb4bf7
+  data.tar.gz: c1b33688d08191603e914254c48a1405393dc21482041e8a9f7a5587dd104a012bd8e0ff3b0c5093be0a2743e0a2dd8982e9c0f32570fb599806ad454ee45e20

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.3] - 2026-11-10
+
+### Performance
+- Cache archived-entry IDs during refresh.
+- Render the entry list incrementally and filter existing widgets instead of rebuilding the tree.
+- Create task editors only when activated to reduce initial widget construction.
+- Add a startup and interaction profiling script.
+
 ## [0.1.2] - 2026-03-17
 
 ### Added

data/README.md

@@ -19,7 +19,7 @@ QTimetrap follows an MVVM-style architecture with `Zeitwerk` autoloading and a R
 ## Requirements
 
 - Ruby `>= 3.2`
-- Qt bridge gem: `qt >= 0.1.4`
+- Qt bridge gem: `qt >= 0.1.7`
 - `timetrap` CLI available as `t` (or configured via env)
 
 ## Install
@@ -38,9 +38,8 @@ Install required system libraries first:
 ### Fedora COPR
 
 ```bash
-sudo dnf copr enable cyjimmy264/ruby-qt
-sudo dnf copr enable cyjimmy264/ruby-qtimetrap
-sudo dnf install ruby-qt ruby-qtimetrap
+sudo dnf copr enable cyjimmy264/ruby-qt-stack
+sudo dnf install ruby-qtimetrap
 gem install timetrap
 qtimetrap
 ```

data/app/components/entries/entry_row_render_helpers.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Builds editable entry rows in small GUI-thread steps.
+    module EntryRowRenderHelpers
+      private
+
+      def start_entry_row_render(node, level, layout:, parent_widget:)
+        row = build_entry_row(parent_widget)
+        apply_entry_widget_styles(row, ListComponent::ENTRY_ROW_STYLE_IDS)
+        row_layout = build_entry_row_layout(row)
+        layout.add_widget(row)
+        entry_rows << row
+        entry_id = node.fetch(:entry_id, node.fetch(:id))
+        entry_rows_by_id[entry_id] = row
+        project_branch_id = container_branch_ids[parent_widget.handle.address]
+        entry_row_parent_branches[entry_id] = project_branch_id
+        project_branch_entry_ids[project_branch_id] << entry_id if project_branch_id
+        row_visible = visible_entry_ids.nil? || visible_entry_ids.key?(entry_id)
+        row_filter_state[entry_id] = row_visible
+        row.visible = row_visible
+
+        context = {
+          node: node,
+          level: level,
+          row: row,
+          row_layout: row_layout,
+          parent_layout: layout,
+          parent_widget: parent_widget
+        }
+        enqueue_entry_row_stage(context, :time_group)
+      end
+
+      def enqueue_entry_row_stage(context, stage, index = nil)
+        render_queue << [:entry_stage, stage, context, index]
+      end
+
+      def process_entry_row_stage(context, stage, index)
+        case stage
+        when :time_group then create_entry_time_group(context)
+        when :start_time then create_entry_start_time(context)
+        when :time_separator then create_entry_time_separator(context)
+        when :end_time then create_entry_end_time(context)
+        when :bind_start_time then bind_entry_start_time(context)
+        when :bind_end_time then bind_entry_end_time(context)
+        when :prefix then create_entry_prefix(context)
+        when :task_container then create_task_container(context)
+        when :task_display then create_task_display(context)
+        when :note_input then create_entry_note(context)
+        when :note_bind_mouse then bind_entry_note_mouse(context)
+        when :note_bind_key then bind_entry_note_key(context)
+        when :note_bind_return then bind_entry_note_return(context)
+        when :note_bind_focus then bind_entry_note_focus(context)
+        when :archive_button then create_entry_archive_button(context)
+        when :finish then finish_entry_row(context)
+        end
+      end
+
+      def create_entry_time_group(context)
+        group = QWidget.new(context.fetch(:row))
+        group.object_name = 'entry_node_entry_time_group'
+        layout = QHBoxLayout.new(group)
+        layout.set_contents_margins(0, 0, 0, 0)
+        layout.spacing = 4
+        context[:time_group] = group
+        context[:time_layout] = layout
+        context.fetch(:row_layout).add_widget(group)
+        enqueue_entry_row_stage(context, :start_time)
+      end
+
+      def create_entry_start_time(context)
+        node = context.fetch(:node)
+        input = build_entry_time_input(
+          context.fetch(:row),
+          object_name: 'entry_node_entry_start',
+          value: node.fetch(:start_label, '--:--'),
+          placeholder: '--:--'
+        )
+        context[:start_input] = input
+        context.fetch(:time_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :time_separator)
+      end
+
+      def create_entry_time_separator(context)
+        separator = build_entry_time_separator(context.fetch(:time_group))
+        context[:time_layout].add_widget(separator)
+        enqueue_entry_row_stage(context, :end_time)
+      end
+
+      def create_entry_end_time(context)
+        node = context.fetch(:node)
+        input = build_entry_time_input(
+          context.fetch(:row),
+          object_name: 'entry_node_entry_end',
+          value: node.fetch(:end_label, 'running'),
+          placeholder: 'running'
+        )
+        context[:end_input] = input
+        context.fetch(:time_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :bind_start_time)
+      end
+
+      def bind_entry_start_time(context)
+        bind_single_time_input(
+          context.fetch(:start_input),
+          resolve_entry_id(context.fetch(:node)),
+          context.fetch(:start_input),
+          context.fetch(:end_input)
+        )
+        enqueue_entry_row_stage(context, :bind_end_time)
+      end
+
+      def bind_entry_end_time(context)
+        bind_single_time_input(
+          context.fetch(:end_input),
+          resolve_entry_id(context.fetch(:node)),
+          context.fetch(:start_input),
+          context.fetch(:end_input)
+        )
+        enqueue_entry_row_stage(context, :prefix)
+      end
+
+      def create_entry_prefix(context)
+        label = build_entry_prefix_label(context.fetch(:row), context.fetch(:node), context.fetch(:level))
+        context.fetch(:row_layout).add_widget(label)
+        enqueue_entry_row_stage(context, :task_container)
+      end
+
+      def create_task_container(context)
+        container = QWidget.new(context.fetch(:row))
+        container.object_name = 'entry_node_entry_task_container'
+        build_entry_task_layout(container)
+        context[:task_container] = container
+        context.fetch(:row_layout).add_widget(container)
+        enqueue_entry_row_stage(context, :task_display)
+      end
+
+      def create_task_display(context)
+        node = context.fetch(:node)
+        task_name = node.fetch(:task_name, '').to_s
+        display = build_entry_task_display(context.fetch(:task_container), task_name)
+        context[:task_name] = task_name
+        context[:task_display] = display
+        task_container = context.fetch(:task_container)
+        register_task_widgets(task_container, display, nil, nil)
+        register_task_editor_config(task_container, node: context.fetch(:node), task_name: task_name)
+        display.on(:mouse_button_press) { |_| activate_entry_task_input(task_container) }
+        enqueue_entry_row_stage(context, :note_input)
+      end
+
+      def create_entry_note(context)
+        input = build_entry_note_input_widget(context.fetch(:row), context.fetch(:node))
+        context[:note_input] = input
+        context.fetch(:row_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :note_bind_mouse)
+      end
+
+      def bind_entry_note_mouse(context)
+        input = context.fetch(:note_input)
+        input.on(:mouse_button_press) { |_| activate_entry_note_input(input) }
+        enqueue_entry_row_stage(context, :note_bind_key)
+      end
+
+      def bind_entry_note_key(context)
+        input = context.fetch(:note_input)
+        entry_id = resolve_entry_id(context.fetch(:node))
+        input.on(:key_press) { |event| handle_entry_note_key_press(input, entry_id, event) }
+        enqueue_entry_row_stage(context, :note_bind_return)
+      end
+
+      def bind_entry_note_return(context)
+        input = context.fetch(:note_input)
+        entry_id = resolve_entry_id(context.fetch(:node))
+        input.connect('returnPressed') { |_| handle_entry_note_commit(input, entry_id) }
+        enqueue_entry_row_stage(context, :note_bind_focus)
+      end
+
+      def bind_entry_note_focus(context)
+        context.fetch(:note_input).on(:focus_out) { |_| handle_entry_note_focus_out(context.fetch(:note_input)) }
+        enqueue_entry_row_stage(context, :archive_button)
+      end
+
+      def create_entry_archive_button(context)
+        button = build_entry_archive_button(context.fetch(:row), context.fetch(:node))
+        context.fetch(:row_layout).add_widget(button)
+        enqueue_entry_row_stage(context, :finish)
+      end
+
+      def finish_entry_row(context)
+        context.fetch(:row_layout).set_stretch(2, 1)
+        context.fetch(:row_layout).set_stretch(3, 2)
+      end
+    end
+  end
+end

data/app/components/entries/leaf_note_helpers.rb

@@ -8,6 +8,7 @@ module QTimetrap
 
       def render_entry_leaf_node(node, level, layout:, parent_widget:)
         row = build_entry_row(parent_widget)
+        apply_entry_widget_styles(row, ListComponent::ENTRY_ROW_STYLE_IDS)
         row_layout = build_entry_row_layout(row)
         start_input, end_input = add_entry_time_widgets(row_layout, row, node)
         add_entry_row_widgets(row_layout, row, node, level)
@@ -52,12 +53,17 @@ module QTimetrap
       end
 
       def build_entry_note_input(row, node)
+        build_entry_note_input_widget(row, node).tap do |note_input|
+          bind_entry_note_input_events(note_input, resolve_entry_id(node))
+        end
+      end
+
+      def build_entry_note_input_widget(row, node)
         QLineEdit.new(row).tap do |note_input|
           note_input.object_name = 'entry_node_entry_note'
           note_input.text = node.fetch(:note, '')
           note_input.placeholder_text = '(no note)'
           note_input.read_only = true
-          bind_entry_note_input_events(note_input, resolve_entry_id(node))
         end
       end
 

data/app/components/entries/leaf_task_display_helpers.rb

@@ -6,14 +6,9 @@ module QTimetrap
     module LeafTaskDisplayHelpers
       private
 
-      def reset_task_display_viewport(task_input)
-        task_input.cursor_position = 0
-      end
-
       def sync_task_display_field(task_input, task_name)
         task_input.text = task_name
         task_input.tool_tip = task_name
-        reset_task_display_viewport(task_input)
       end
     end
   end

data/app/components/entries/leaf_task_editor_state_helpers.rb

@@ -8,10 +8,9 @@ module QTimetrap
 
       def activate_entry_task_input(task_container)
         close_previous_task_editor(task_container)
+        editor, editor_input = ensure_entry_task_editor(task_container)
         show_entry_task_editor(task_container)
         self.active_task_container = task_container
-        editor = entry_task_editor(task_container)
-        editor_input = entry_task_editor_line_edit(editor)
         editor_input.read_only = false
         editor.set_focus
         editor_input.set_focus

data/app/components/entries/leaf_task_helpers.rb

@@ -31,25 +31,37 @@ module QTimetrap
       end
 
       def build_entry_task_display(task_container, task_name)
-        QLineEdit.new(task_container).tap do |task_input|
+        QLabel.new(task_container).tap do |task_input|
           task_input.object_name = 'entry_node_entry_task'
           task_input.text = task_name
           task_input.tool_tip = task_name
-          task_input.placeholder_text = 'task'
           task_input.minimum_width = 220
-          task_input.read_only = true
+          task_input.fixed_height = 24
           sync_task_display_field(task_input, task_name)
           task_container.layout.add_widget(task_input)
         end
       end
 
       def build_entry_task_editor(task_container, task_name, node)
-        QComboBox.new(task_container).tap do |editor|
-          line_edit = configure_entry_task_editor(editor, task_container, task_name, node)
-          task_container.layout.add_widget(editor)
-          editor.hide
-          return [editor, line_edit]
-        end
+        editor, line_edit = build_entry_task_editor_shell(task_container, task_name)
+        populate_entry_task_options(editor, task_name, node)
+        editor.current_text = task_name
+        [editor, line_edit]
+      end
+
+      def build_entry_task_editor_shell(task_container, task_name)
+        editor = QComboBox.new(task_container)
+        editor.object_name = 'entry_node_entry_task_editor'
+        editor.editable = true
+        editor.focus_policy = Qt::StrongFocus
+        editor.minimum_width = 220
+        editor.tool_tip = task_name
+        line_edit = build_entry_task_line_edit(task_container)
+        editor.instance_variable_set(:@qtimetrap_task_line_edit, line_edit)
+        editor.line_edit = line_edit
+        task_container.layout.add_widget(editor)
+        editor.hide
+        [editor, line_edit]
       end
 
       def configure_entry_task_editor(editor, task_container, task_name, node)
@@ -65,6 +77,31 @@ module QTimetrap
         line_edit
       end
 
+      def ensure_entry_task_editor(task_container)
+        editor = entry_task_editor(task_container)
+        return [editor, entry_task_editor_line_edit(editor)] if editor
+
+        config = task_editor_config_for(task_container)
+        task_name = config.fetch(:task_name)
+        editor, line_edit = build_entry_task_editor_shell(task_container, task_name)
+        apply_entry_widget_styles(editor, %w[entry_node_entry_task_editor])
+        populate_entry_task_options(editor, task_name, config.fetch(:node))
+        editor.current_text = task_name
+        register_task_editor_widgets(task_container, editor, line_edit)
+        bind_entry_task_editor_events(task_container, config.fetch(:node))
+        [editor, line_edit]
+      end
+
+      def bind_entry_task_editor_events(task_container, node)
+        entry_id = resolve_entry_id(node)
+        editor = entry_task_editor(task_container)
+        line_edit = entry_task_editor_line_edit(editor)
+        line_edit.on(:key_press) { |event| handle_entry_task_key_press(task_container, entry_id, event) }
+        line_edit.connect('returnPressed') { |_| handle_entry_task_commit(task_container, entry_id) }
+        line_edit.on(:focus_out) { |_| handle_entry_task_focus_out(task_container) }
+        editor.connect('textActivated') { |_| handle_entry_task_commit(task_container, entry_id, force: true) }
+      end
+
       def build_entry_task_line_edit(task_container)
         QLineEdit.new(task_container).tap do |line_edit|
           line_edit.object_name = 'entry_node_entry_task_editor_input'
@@ -100,6 +137,8 @@ module QTimetrap
       end
 
       def entry_task_editor_line_edit(editor)
+        return unless editor
+
         task_editor_line_edit_for(editor) || editor.instance_variable_get(:@qtimetrap_task_line_edit)
       end
 

data/app/components/entries/list_component.rb

@@ -7,6 +7,7 @@ module QTimetrap
       include ListHostHelpers
       include ListStateHelpers
       include ListTaskEditorHelpers
+      include EntryRowRenderHelpers
       include QtUiHelpers
       include TreeHelpers
       include RenderHelpers
@@ -14,6 +15,7 @@ module QTimetrap
       HOST_HORIZONTAL_MARGINS = 28
       WIDTH_PADDING = 24
       TIME_FILTER_DEBOUNCE_MS = 220
+      RENDER_SLICE_MS = 4
 
       attr_reader :widget
 
@@ -30,16 +32,89 @@ module QTimetrap
       end
 
       def render(nodes)
-        return if rendering
-
+        time_filter_debounce.stop if time_filter_debounce&.is_active
+        render_timer.stop if render_timer.is_active
+        @theme_style_queue = []
+        @render_generation = render_generation.to_i + 1
         @rendering = true
         @current_nodes = Array(nodes)
         @branch_bindings = {}
         @leaf_labels = []
         @entry_rows = []
-        with_widget_updates_suspended { render_contents }
-      ensure
-        @rendering = false
+        @entry_rows_by_id = {}
+        @entry_row_parent_branches = {}
+        @project_branch_entry_ids = {}
+        @container_branch_ids = {}
+        @row_filter_state = {}
+        @width_queue = []
+        @visibility_queue = []
+        @visible_branch_ids = nil
+        @visible_branch_labels = {}
+        @visible_entry_ids = nil
+        @task_suggestion_cache = {}
+        @render_needs_stretch = true
+        rebuild_host!
+        @empty_label = QLabel.new(host)
+        @empty_label.object_name = 'entry_node_empty'
+        @empty_label.fixed_height = 32
+        @empty_label.visible = false
+        host_layout.add_widget(@empty_label)
+        @render_queue = []
+        enqueue_render_nodes(current_nodes, level: 0, layout: host_layout, parent_widget: host)
+        render_timer.start
+        nil
+      end
+
+      def filter_to(nodes)
+        branch_nodes = {}
+        entry_ids = {}
+        project_entry_ids = Hash.new { |hash, key| hash[key] = [] }
+        empty_label = nil
+        visit = lambda do |collection, project_branch_id = nil|
+          Array(collection).each do |node|
+            if node.fetch(:type) == :entry
+              entry_id = node.fetch(:entry_id, node.fetch(:id))
+              entry_ids[entry_id] = true
+              project_entry_ids[project_branch_id] << entry_id if project_branch_id
+            elsif node.fetch(:type) == :empty
+              empty_label = node.fetch(:label)
+            elsif branch_node?(node)
+              branch_nodes[node.fetch(:id)] = node
+              next_project_id = node.fetch(:type) == :project ? node.fetch(:id) : project_branch_id
+              visit.call(node.fetch(:children), next_project_id)
+            end
+          end
+        end
+        visit.call(nodes)
+
+        @visible_branch_ids = branch_nodes
+        @visible_branch_labels = branch_nodes.transform_values { |node| node.fetch(:label) }
+        @visible_entry_ids = entry_ids
+        @visible_project_entry_ids = project_entry_ids
+        @visibility_queue = branch_bindings.filter_map do |node_id, binding|
+          visible = branch_nodes.key?(node_id)
+          label = branch_nodes[node_id]&.fetch(:label)
+          next if binding[:filter_visible] == visible && (!visible || binding[:label] == label)
+
+          [:branch, node_id]
+        end
+        project_branch_entry_ids.each do |branch_id, entry_keys|
+          next unless project_entry_ids.key?(branch_id)
+
+          visible_ids = project_entry_ids.fetch(branch_id)
+          entry_keys.each do |entry_id|
+            visible = visible_ids.include?(entry_id)
+            next if row_filter_state[entry_id] == visible
+
+            @visibility_queue << [:entry, entry_id, entry_rows_by_id.fetch(entry_id), visible]
+          end
+        end
+        @visibility_queue << [:empty, empty_label]
+        if visibility_queue.any?
+          @rendering = true
+          render_timer.start
+        end
+        nil
       end
 
       def update_time_range_inputs(from_at:, to_at:)
@@ -58,7 +133,34 @@ module QTimetrap
         @syncing_time_filters = false
       end
 
+      def apply_theme_stylesheet(stylesheet, external_targets: [], defer: false)
+        @entry_stylesheet = stylesheet
+        @entry_scroll_stylesheet = stylesheet_for_ids(stylesheet, %w[entries_scroll])
+        @entry_toolbar_stylesheet = stylesheet_for_ids(stylesheet, %w[
+          entries_toolbar entries_expand_all entries_collapse_all
+          entries_time_filter_from_toggle entries_time_filter_to_toggle
+          entries_time_filter_from entries_time_filter_to
+        ])
+        @entry_host_stylesheet = stylesheet_for_ids(stylesheet, %w[entries_host])
+        @entry_row_stylesheet = stylesheet_for_ids(stylesheet, ENTRY_ROW_STYLE_IDS)
+        @entry_empty_stylesheet = stylesheet_for_ids(stylesheet, %w[entry_node_empty])
+        @entry_branch_stylesheets = %w[week day project].to_h do |type|
+          name = "entry_node_#{type}"
+          [name, stylesheet_for_ids(stylesheet, [name])]
+        end
+        @theme_style_queue = theme_style_targets(stylesheet).concat(external_targets)
+        @rendering = true if defer && theme_style_queue.any?
+        unless defer
+          scroll_area.style_sheet = @entry_scroll_stylesheet
+          toolbar.style_sheet = @entry_toolbar_stylesheet
+          @theme_style_queue.clear
+        end
+        render_timer.start if theme_style_queue.any?
+        nil
+      end
+
       def shutdown
+        render_timer.stop if render_timer&.is_active
         return unless time_filter_debounce
 
         time_filter_debounce.stop if time_filter_debounce.is_active
@@ -70,19 +172,201 @@ module QTimetrap
                   :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
+                  :time_filter_debounce, :render_timer, :render_queue, :render_generation, :width_queue,
+                  :task_suggestion_cache, :visibility_queue, :entry_rows_by_id, :visible_branch_ids,
+                  :visible_branch_labels, :visible_entry_ids, :empty_label, :project_branch_entry_ids,
+                  :container_branch_ids, :entry_row_parent_branches, :row_filter_state, :theme_style_queue, :toolbar
 
       def build
         @widget = QWidget.new(parent)
         widget.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))
+        @toolbar = build_toolbar(parent_widget: widget)
+        panel_layout.add_widget(toolbar)
         @scroll_area = build_scroll_area
         bind_scroll_resize
         panel_layout.add_widget(scroll_area)
         panel_layout.set_stretch(1, 1)
         rebuild_host!
+        @render_timer = QTimer.new(widget)
+        render_timer.interval = 1
+        render_timer.connect('timeout') { |_| process_render_slice(render_generation) }
+      end
+
+      def enqueue_render_nodes(nodes, level:, layout:, parent_widget:)
+        nodes.reverse_each do |node|
+          render_queue << [node, level, layout, parent_widget]
+        end
+      end
+
+      def process_render_slice(generation)
+        return unless generation == render_generation
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + (RENDER_SLICE_MS / 1000.0)
+        content_changed = false
+        while queues_pending? && Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+          if theme_style_queue.any?
+            target, stylesheet = theme_style_queue.shift
+            target.style_sheet = stylesheet
+          elsif visibility_queue.any?
+            content_changed = true
+            apply_filter_work(visibility_queue.pop)
+          elsif width_queue.any?
+            content_changed = true
+            width_queue.pop.fixed_width = branch_button_width
+          else
+            content_changed = true
+            work = render_queue.pop
+            if work.first == :entry_stage
+              process_entry_row_stage(work[2], work[1], work[3])
+            elsif work.first == :branch_complete
+              show_rendered_branch_children(work[1])
+            else
+              node, level, layout, parent_widget = work
+              render_one_node(node, level, layout: layout, parent_widget: parent_widget)
+            end
+          end
+        end
+
+        if render_queue.empty? && @render_needs_stretch
+          content_changed = true
+          host_layout.add_stretch(1)
+          @render_needs_stretch = false
+        end
+
+        if !queues_pending?
+          @rendering = false
+          host.update if content_changed
+          render_timer.stop if render_timer.is_active
+        end
+      end
+
+      def queues_pending?
+        render_queue.any? || width_queue.any? || visibility_queue.any? || theme_style_queue.any?
+      end
+
+      def theme_style_targets(stylesheet)
+        targets = [[toolbar, @entry_toolbar_stylesheet]]
+        unless rendering
+          branch_bindings.each do |_node_id, binding|
+            targets << [binding.fetch(:button), @entry_branch_stylesheets.fetch("entry_node_#{binding.fetch(:type)}")]
+          end
+          entry_rows.each do |row|
+            targets << [row, @entry_row_stylesheet]
+          end
+          targets << [empty_label, @entry_empty_stylesheet] if empty_label
+        end
+        targets.reject { |target, rules| target.nil? || rules.empty? }
+      end
+
+      ENTRY_ROW_STYLE_IDS = %w[
+        entry_node_entry_row entry_node_entry_prefix entry_node_entry_time_sep
+        entry_node_entry_start entry_node_entry_end entry_node_entry_note
+        entry_node_entry_task entry_node_entry_task_editor entry_node_entry_archive
+      ].freeze
+
+      def stylesheet_for_ids(stylesheet, ids)
+        id_pattern = ids.map { |id| Regexp.escape("##{id}") }.join('|')
+        stylesheet.scan(/([^{}]+)\{([^{}]*)\}/m).filter_map do |selectors, declarations|
+          selected = selectors.split(',').map(&:strip).select do |selector|
+            selector.match?(/(?:#{id_pattern})(?:\b|(?=[:\s.#>+~\[]))/)
+          end
+          next if selected.empty?
+
+          "#{selected.join(",\n")} {#{declarations}}"
+        end.join("\n")
+      end
+
+      def apply_entry_widget_styles(target, ids)
+        stylesheet = case ids
+                     when %w[entries_host] then @entry_host_stylesheet
+                     when ListComponent::ENTRY_ROW_STYLE_IDS then @entry_row_stylesheet
+                     when %w[entry_node_empty] then @entry_empty_stylesheet
+                     else @entry_branch_stylesheets&.fetch(ids.first, nil)
+                     end
+        target.style_sheet = stylesheet if stylesheet && !stylesheet.empty?
+      end
+
+      def apply_filter_work(work)
+        case work.first
+        when :branch then apply_branch_filter(work[1])
+        when :entry
+          work[2].visible = work[3]
+          row_filter_state[work[1]] = work[3]
+        when :empty
+          empty_label.text = work[1] || 'No entries for filter'
+          empty_label.visible = visible_entry_ids.empty?
+        end
+      end
+
+      def apply_branch_filter(node_id)
+        binding = branch_bindings.fetch(node_id)
+        visible = visible_branch_ids.key?(node_id)
+        expanded_state = expanded.fetch(node_id, true)
+        binding.fetch(:button).visible = visible
+        binding.fetch(:children_container).visible = visible && expanded_state
+        label = visible_branch_labels[node_id] || binding.fetch(:label)
+        binding[:label] = label
+        binding[:filter_visible] = visible
+        binding.fetch(:button).text = branch_button_text(binding.fetch(:level), label, expanded_state)
+      end
+
+      def render_one_node(node, level, layout:, parent_widget:)
+        if node.fetch(:type) == :empty
+          apply_entry_widget_styles(empty_label, %w[entry_node_empty])
+          return render_empty_node(node)
+        end
+        return start_entry_row_render(node, level, layout: layout, parent_widget: parent_widget) if node.fetch(:type) == :entry
+        return render_node(node, level, layout: layout, parent_widget: parent_widget) unless branch_node?(node)
+
+        node_id = node.fetch(:id)
+        label = node.fetch(:label)
+        expanded_state = expanded.fetch(node_id, true)
+        button = build_branch_button(node, level, expanded_state, parent_widget: parent_widget)
+        apply_entry_widget_styles(button, [object_name_for(node)])
+        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
+        )
+        branch_bindings[node_id][:type] = node.fetch(:type)
+        if node.fetch(:type) == :project
+          container_branch_ids[children_container.handle.address] = node_id
+          project_branch_entry_ids[node_id] = []
+        end
+        children_container.visible = false
+        button.text = branch_button_text(level, label, expanded_state)
+        button_visible = visible_branch_ids.nil? || visible_branch_ids.key?(node_id)
+        button.visible = button_visible
+        branch_bindings[node_id][:filter_visible] = button_visible
+        if expanded_state
+          render_queue << [:branch_complete, node_id]
+          enqueue_render_nodes(node.fetch(:children), level: level + 1, layout: children_layout,
+                               parent_widget: children_container)
+        end
+      end
+
+      def show_rendered_branch_children(node_id)
+        binding = branch_bindings.fetch(node_id)
+        visible = visible_branch_ids.nil? || visible_branch_ids.key?(node_id)
+        expanded_state = expanded.fetch(node_id, true)
+        binding.fetch(:button).visible = visible
+        binding.fetch(:children_container).visible = visible && expanded_state
+        label = visible_branch_labels[node_id] || binding.fetch(:label)
+        binding[:label] = label
+        binding[:filter_visible] = visible
+        binding.fetch(:button).text = branch_button_text(binding.fetch(:level), label, expanded_state)
+      end
+
+      def render_empty_node(node)
+        empty_label.text = node.fetch(:label)
+        empty_label.visible = true
       end
 
       def branch_button_width
@@ -91,10 +375,12 @@ module QTimetrap
       end
 
       def adjust_node_widths
-        width = branch_button_width
-        branch_bindings.each_value { |binding| binding.fetch(:button).fixed_width = width }
-        leaf_labels.each { |label| label.fixed_width = width }
-        entry_rows.each { |row| row.fixed_width = width }
+        @width_queue = [
+          *branch_bindings.values.map { |binding| binding.fetch(:button) },
+          *leaf_labels,
+          *entry_rows
+        ]
+        render_timer.start if width_queue.any? && !render_timer.is_active
       end
 
       def build_panel_layout

data/app/components/entries/list_host_helpers.rb

@@ -18,7 +18,10 @@ module QTimetrap
       end
 
       def rebuild_host!
+        previous_host = scroll_area.take_widget
+        previous_host.delete_later if previous_host
         @host = build_host
+        apply_entry_widget_styles(host, %w[entries_host])
         @host_layout = build_host_layout
         scroll_area.widget = host
       end

data/app/components/entries/list_state_helpers.rb

@@ -19,6 +19,7 @@ module QTimetrap
         @active_task_container_key = nil
         @leaf_labels = []
         @entry_rows = []
+        @theme_style_queue = []
         @rendering = false
       end
 
@@ -27,6 +28,7 @@ module QTimetrap
         @task_display_inputs = {}
         @task_editors = {}
         @task_editor_line_edits = {}
+        @task_editor_configs = {}
       end
 
       def initialize_time_filter_state!
@@ -68,10 +70,23 @@ module QTimetrap
         container_key = task_container_key(task_container)
         task_containers[container_key] = task_container
         task_display_inputs[container_key] = display_input
+        register_task_editor_widgets(task_container, editor, line_edit) if editor
+      end
+
+      def register_task_editor_config(task_container, node:, task_name:)
+        task_editor_configs[task_container_key(task_container)] = { node: node, task_name: task_name }
+      end
+
+      def register_task_editor_widgets(task_container, editor, line_edit)
+        container_key = task_container_key(task_container)
         task_editors[container_key] = editor
         task_editor_line_edits[task_editor_key(editor)] = line_edit
       end
 
+      def task_editor_config_for(task_container)
+        task_editor_configs[task_container_key(task_container)]
+      end
+
       def task_container_key(task_container)
         task_container.handle.address
       end
@@ -105,11 +120,13 @@ module QTimetrap
       end
 
       def task_editor_line_edit_for(editor)
+        return unless editor
+
         task_editor_line_edits[task_editor_key(editor)]
       end
 
       attr_reader :task_containers, :task_display_inputs, :task_editors, :task_editor_line_edits,
-                  :active_task_container_key
+                  :active_task_container_key, :task_editor_configs
     end
   end
 end

data/app/components/project_sidebar/component.rb

@@ -34,6 +34,17 @@ module QTimetrap
         archive_toggle_button.checked = archive_mode
       end
 
+      def update_tasks(tasks:, selected_project:, selected_task:)
+        render_tasks(tasks: tasks, selected_project: selected_project, selected_task: selected_task)
+      end
+
+      def theme_style_targets(stylesheet)
+        widgets = [@logo_text, @heading, tasks_heading, archive_toggle_button]
+        widgets.concat(buttons.map { |slot| slot.fetch(:view) })
+        widgets.concat(task_buttons)
+        widgets.compact.map { |target| [target, stylesheet] }
+      end
+
       private
 
       attr_reader :parent, :on_project_selected, :on_task_selected, :buttons, :buttons_layout, :task_buttons,

data/app/components/project_sidebar/logo_helpers.rb

@@ -30,7 +30,7 @@ module QTimetrap
       end
 
       def build_logo_text(parent_widget)
-        QLabel.new(parent_widget).tap do |label|
+        @logo_text = QLabel.new(parent_widget).tap do |label|
           label.object_name = 'sidebar_logo_text'
           label.alignment = Qt::AlignCenter
           label.text = 'QTimetrap'
@@ -42,7 +42,7 @@ module QTimetrap
       end
 
       def build_heading
-        QLabel.new(widget).tap do |label|
+        @heading = QLabel.new(widget).tap do |label|
           label.object_name = 'sidebar_heading'
           label.alignment = Qt::AlignCenter
           label.text = 'PROJECTS'

data/app/components/tracker_controls/component.rb

@@ -40,6 +40,10 @@ module QTimetrap
         project_input.read_only = running
       end
 
+      def theme_style_targets(stylesheet)
+        theme_widgets.compact.map { |target| [target, stylesheet] }
+      end
+
       private
 
       attr_reader :summary_label, :theme_button, :start_button, :stop_button
@@ -69,9 +73,16 @@ module QTimetrap
         @theme_button = ui_map.fetch(:theme_button)
         @start_button = ui_map.fetch(:start_button)
         @stop_button = ui_map.fetch(:stop_button)
+        @theme_widgets = [
+          ui_map.fetch(:topbar), ui_map.fetch(:tracker_row), ui_map.fetch(:actions_row),
+          ui_map.fetch(:title_label), clock_label, timer_label, task_input, project_input,
+          summary_label, theme_button, start_button, stop_button, ui_map.fetch(:refresh_button)
+        ]
         configure_timer_font_fit!
       end
 
+      attr_reader :theme_widgets
+
       def configure_timer_font_fit!
         apply_timer_font_fit(TIMER_FIT_SAMPLE)
       end

data/app/components/tracker_controls/layout_builder.rb

@@ -15,11 +15,13 @@ module QTimetrap
       def build
         @widget = QWidget.new(parent)
         root = build_root_layout
-        root.add_widget(build_topbar)
+        @topbar = build_topbar
+        root.add_widget(@topbar)
         start_button, stop_button = build_tracker_row(root)
         refresh_button = build_actions_row(root)
+        @refresh_button = refresh_button
         connect_actions(start_button, stop_button, refresh_button)
-        ui_payload
+        ui_payload.merge(theme_ui_payload)
       end
 
       private
@@ -35,7 +37,7 @@ module QTimetrap
       end
 
       def build_tracker_row(root_layout)
-        row = QWidget.new(widget)
+        row = @tracker_row = QWidget.new(widget)
         row.object_name = 'tracker_row'
         layout = QHBoxLayout.new(row)
         layout.set_contents_margins(14, 12, 14, 12)
@@ -46,7 +48,7 @@ module QTimetrap
       end
 
       def build_actions_row(root_layout)
-        row = QWidget.new(widget)
+        row = @actions_row = QWidget.new(widget)
         layout = QHBoxLayout.new(row)
         layout.set_contents_margins(0, 0, 0, 0)
         layout.spacing = 8
@@ -82,6 +84,16 @@ module QTimetrap
         connect_project_input
       end
 
+      def theme_ui_payload
+        {
+          topbar: @topbar,
+          tracker_row: @tracker_row,
+          actions_row: @actions_row,
+          title_label: @title_label,
+          refresh_button: @refresh_button
+        }
+      end
+
       def connect_start_stop(start_button, stop_button)
         start_button.connect('clicked') do |_|
           callbacks.fetch(:on_start).call(@task_input.text.to_s, @project_input.text.to_s)

data/app/components/tracker_controls/layout_helpers.rb

@@ -26,7 +26,8 @@ module QTimetrap
       def configure_topbar_layout(layout, topbar)
         layout.set_contents_margins(16, 8, 16, 8)
         layout.spacing = 8
-        layout.add_widget(build_label(topbar, 'title_label', random_title_slogan))
+        @title_label = build_label(topbar, 'title_label', random_title_slogan)
+        layout.add_widget(@title_label)
         layout.add_stretch(1)
         @clock_label = build_label(topbar, 'clock_label', nil, width: 220)
         @clock_label.alignment = Qt::AlignCenter

data/app/services/archived_entries_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'set'
 require 'yaml'
 
 module QTimetrap
@@ -12,7 +13,7 @@ module QTimetrap
       end
 
       def archived_ids
-        read_ids
+        read_ids.to_a.sort
       end
 
       def archived?(entry_id)
@@ -47,19 +48,23 @@ module QTimetrap
       attr_reader :path
 
       def read_ids
-        return [] unless File.exist?(path)
+        return @ids_cache if @ids_cache
+        return @ids_cache = Set.new unless File.exist?(path)
 
         payload = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
-        return [] unless payload.is_a?(Hash)
+        return @ids_cache = Set.new unless payload.is_a?(Hash)
 
-        Array(payload['archived_entry_ids']).filter_map { |value| Integer(value) }.uniq.sort
+        values = Array(payload['archived_entry_ids']).filter_map { |value| Integer(value) }.uniq
+        @ids_cache = Set.new(values)
       rescue Psych::SyntaxError, ArgumentError, TypeError
-        []
+        @ids_cache = Set.new
       end
 
       def write_ids(ids)
         FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, { 'archived_entry_ids' => ids.uniq.sort }.to_yaml)
+        normalized_ids = ids.uniq.sort
+        File.write(path, { 'archived_entry_ids' => normalized_ids }.to_yaml)
+        @ids_cache = Set.new(normalized_ids)
       end
 
       def default_path

data/app/styles/themes/dark/entries_list.qss

@@ -190,25 +190,13 @@ QLineEdit#entry_node_entry_note:focus {
   padding-left: 6px;
 }
 
-QLineEdit#entry_node_entry_task {
+QLabel#entry_node_entry_task {
   color: #94a3b8;
   font-size: 12px;
   background: transparent;
-  border: 0px;
   padding-left: 2px;
 }
 
-QLineEdit#entry_node_entry_task:read-only {
-  background: transparent;
-  border: 0px;
-}
-
-QLineEdit#entry_node_entry_task:focus {
-  background-color: #111827;
-  border: 1px solid #334155;
-  border-radius: 6px;
-}
-
 QComboBox#entry_node_entry_task_editor {
   color: #94a3b8;
   font-size: 12px;

data/app/styles/themes/light/entries_list.qss

@@ -190,25 +190,13 @@ QLineEdit#entry_node_entry_note:focus {
   padding-left: 6px;
 }
 
-QLineEdit#entry_node_entry_task {
+QLabel#entry_node_entry_task {
   color: #334155;
   font-size: 12px;
   background: transparent;
-  border: 0px;
   padding-left: 2px;
 }
 
-QLineEdit#entry_node_entry_task:read-only {
-  background: transparent;
-  border: 0px;
-}
-
-QLineEdit#entry_node_entry_task:focus {
-  background-color: #ffffff;
-  border: 1px solid #d8e0ea;
-  border-radius: 6px;
-}
-
 QComboBox#entry_node_entry_task_editor {
   color: #334155;
   font-size: 12px;

data/app/view_models/main_view_model.rb

@@ -93,6 +93,10 @@ module QTimetrap
         EntryNodesBuilder.new(entries: filtered_entries, selected_project: selected_project).build
       end
 
+      def all_entry_nodes
+        EntryNodesBuilder.new(entries: entries, selected_project: '* ALL').build
+      end
+
       private
 
       attr_reader :gateway, :archived_entries_store

data/app/views/main_window.rb

@@ -46,7 +46,6 @@ module QTimetrap
         @window = build_base_window
         restore_window_geometry
         set_window_icon
-        window.style_sheet = theme.application_stylesheet
         ui = MainWindowLayoutBuilder.new(
           window: window,
           callbacks: layout_callbacks
@@ -54,6 +53,7 @@ module QTimetrap
         @sidebar = ui.fetch(:sidebar)
         @controls = ui.fetch(:controls)
         @entries = ui.fetch(:entries)
+        apply_theme_styles
       end
 
       def connect_heartbeat

data/app/views/main_window_runtime.rb

@@ -56,7 +56,13 @@ module QTimetrap
         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!
+        sidebar.update_tasks(
+          tasks: view_model.task_names_for_selected_project,
+          selected_project: view_model.selected_project,
+          selected_task: view_model.selected_tasks.first
+        )
+        controls.update_summary(view_model.summary_line)
+        entries.filter_to(view_model.entry_nodes)
         return unless update_current_fields
 
         controls.update_task_input(view_model.current_sheet_input)
@@ -69,8 +75,8 @@ module QTimetrap
           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)
+        controls.update_summary(view_model.summary_line)
+        entries.filter_to(view_model.entry_nodes)
       end
 
       def handle_project_input(project_name)
@@ -81,12 +87,12 @@ module QTimetrap
 
       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)
+        controls.update_summary(view_model.summary_line)
         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)
+        entries.filter_to(view_model.entry_nodes)
       rescue StandardError => e
         warn("[qtimetrap] update time-range failed: #{e.class}: #{e.message}")
       end
@@ -114,7 +120,7 @@ module QTimetrap
       def switch_theme!
         @theme = theme.with_name(next_theme_name)
         apply_theme
-        render!
+        controls.update_theme_label(theme.name)
       rescue StandardError => e
         warn("[qtimetrap] save theme failed: #{e.class}: #{e.message}")
       end

data/app/views/main_window_runtime_archive_helpers.rb

@@ -8,7 +8,13 @@ module QTimetrap
 
       def handle_archive_mode_toggled(enabled)
         view_model.archive_mode = enabled
-        render!(sync_sheet: false)
+        sidebar.update_tasks(
+          tasks: view_model.task_names_for_selected_project,
+          selected_project: view_model.selected_project,
+          selected_task: view_model.selected_tasks.first
+        )
+        controls.update_summary(view_model.summary_line)
+        entries.filter_to(view_model.entry_nodes)
       end
 
       def handle_entry_archived(entry_id)

data/app/views/main_window_runtime_render_helpers.rb

@@ -30,7 +30,8 @@ module QTimetrap
           from_at: view_model.time_filter_from_at,
           to_at: view_model.time_filter_to_at
         )
-        entries.render(view_model.entry_nodes)
+        entries.render(view_model.all_entry_nodes)
+        entries.filter_to(view_model.entry_nodes)
       end
 
       def render_controls(sync_sheet:)

data/app/views/main_window_ui_helpers.rb

@@ -37,9 +37,37 @@ module QTimetrap
 
       def apply_theme
         Application.configuration.theme_name = theme.name
-        window.style_sheet = theme.application_stylesheet
+        apply_theme_styles(update_window_background: false, incremental: true)
         settings_store.write_theme_name(theme.name)
       end
+
+      def apply_theme_styles(update_window_background: true, incremental: false)
+        window.style_sheet = theme.stylesheet('application') if update_window_background
+        sidebar_stylesheet = theme.stylesheet('project_sidebar')
+        controls_stylesheet = theme.stylesheet('tracker_controls')
+        entries_stylesheet = theme.stylesheet('entries_list')
+        if incremental
+          sidebar.widget.style_sheet = stylesheet_rule(sidebar_stylesheet, 'QWidget#sidebar_panel')
+          entries.apply_theme_stylesheet(
+            entries_stylesheet,
+            external_targets: sidebar.theme_style_targets(sidebar_stylesheet) +
+                              controls.theme_style_targets(controls_stylesheet),
+            defer: true
+          )
+        else
+          sidebar.widget.style_sheet = sidebar_stylesheet
+          controls.widget.style_sheet = controls_stylesheet
+          entries.apply_theme_stylesheet(entries_stylesheet)
+        end
+      end
+
+      def stylesheet_rule(stylesheet, selector)
+        stylesheet.scan(/([^{}]+)\{([^{}]*)\}/m).find do |selectors, _declarations|
+          selectors.split(',').map(&:strip).include?(selector)
+        end&.then do |selectors, declarations|
+          "#{selectors.strip} {#{declarations}}"
+        end.to_s
+      end
     end
   end
 end

data/lib/qtimetrap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QTimetrap
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qtimetrap
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -60,6 +60,7 @@ files:
 - app/assets/icons/qtimetrap-icon-512.png
 - app/assets/icons/qtimetrap-icon.svg
 - app/components/entries/branch_hierarchy_helpers.rb
+- app/components/entries/entry_row_render_helpers.rb
 - app/components/entries/leaf_archive_helpers.rb
 - app/components/entries/leaf_note_helpers.rb
 - app/components/entries/leaf_task_display_helpers.rb
@@ -206,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Desktop Timetrap UI on Qt
 test_files: []