qtimetrap 0.1.1 → 0.1.3

data/app/components/entries/leaf_task_helpers.rb

@@ -2,79 +2,163 @@
 
 module QTimetrap
   module Entries
-    # Entry-leaf helpers for editable task combo-box controls.
+    # Entry-leaf helpers for editable task controls.
     module LeafTaskHelpers
       private
 
       def build_entry_task_input(row, node)
-        QComboBox.new(row).tap do |task_input|
-          task_input.set_object_name('entry_node_entry_task')
-          task_input.set_editable(true)
-          task_input.instance_variable_set(:@qtimetrap_task_line_edit, build_entry_task_line_edit(row))
-          task_input.set_line_edit(entry_task_line_edit(task_input))
-          task_input.set_placeholder_text('task')
-          task_input.set_minimum_width(220)
-          populate_entry_task_options(task_input, node)
-          bind_entry_task_input_events(task_input, resolve_entry_id(node))
+        task_name = node.fetch(:task_name, '').to_s
+        QWidget.new(row).tap do |task_container|
+          initialize_entry_task_container(task_container, task_name, node)
+          bind_entry_task_input_events(task_container, resolve_entry_id(node))
+          show_entry_task_display(task_container)
         end
       end
 
-      def build_entry_task_line_edit(row)
-        QLineEdit.new(row).tap do |line_edit|
-          line_edit.set_object_name('entry_node_entry_task_input')
+      def initialize_entry_task_container(task_container, task_name, node)
+        task_container.object_name = 'entry_node_entry_task_container'
+        build_entry_task_layout(task_container)
+        display_input = build_entry_task_display(task_container, task_name)
+        editor, line_edit = build_entry_task_editor(task_container, task_name, node)
+        register_task_widgets(task_container, display_input, editor, line_edit)
+      end
+
+      def build_entry_task_layout(task_container)
+        QHBoxLayout.new(task_container).tap do |layout|
+          layout.set_contents_margins(0, 0, 0, 0)
+          layout.spacing = 0
         end
       end
 
-      def populate_entry_task_options(task_input, node)
-        current_task = node.fetch(:task_name, '').to_s
-        suggestions = Array(task_suggestions_for_project&.call(node.fetch(:project_name, '').to_s))
-        options = ([current_task] + suggestions.map(&:to_s)).reject(&:empty?).uniq
-        options.each { |task_name| task_input.add_item(task_name) }
-        task_input.set_current_text(current_task)
-        deactivate_entry_task_input(task_input)
+      def build_entry_task_display(task_container, task_name)
+        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.minimum_width = 220
+          task_input.fixed_height = 24
+          sync_task_display_field(task_input, task_name)
+          task_container.layout.add_widget(task_input)
+        end
       end
 
-      def bind_entry_task_input_events(task_input, entry_id)
-        input = entry_task_line_edit(task_input)
-        input.on(:mouse_button_press) { |_| activate_entry_task_input(task_input) }
-        input.on(:key_press) { |event| handle_entry_task_key_press(task_input, entry_id, event) }
-        input.connect('returnPressed') { |_| handle_entry_task_commit(task_input, entry_id) }
-        input.on(:focus_out) { |_| handle_entry_task_focus_out(task_input) }
-        task_input.connect('textActivated') { |_| handle_entry_task_commit(task_input, entry_id, force: true) }
+      def build_entry_task_editor(task_container, task_name, node)
+        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 activate_entry_task_input(task_input)
-        entry_task_line_edit(task_input).set_read_only(false)
-        task_input.set_focus
+      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 deactivate_entry_task_input(task_input)
-        entry_task_line_edit(task_input).set_read_only(true)
-        task_input.clear_focus
+      def configure_entry_task_editor(editor, task_container, task_name, node)
+        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
+        populate_entry_task_options(editor, task_name, node)
+        line_edit
       end
 
-      def handle_entry_task_key_press(task_input, entry_id, event)
-        return unless enter_key?(event)
+      def ensure_entry_task_editor(task_container)
+        editor = entry_task_editor(task_container)
+        return [editor, entry_task_editor_line_edit(editor)] if editor
 
-        handle_entry_task_commit(task_input, entry_id)
+        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 handle_entry_task_commit(task_input, entry_id, force: false)
-        return if entry_task_line_edit(task_input).is_read_only && !force
+      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
 
-        task_name = task_input.current_text.to_s
-        deactivate_entry_task_input(task_input)
-        return unless on_entry_task_change
+      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'
+        end
+      end
 
-        on_entry_task_change.call(entry_id, task_name)
+      def populate_entry_task_options(editor, task_name, node)
+        suggestions = Array(task_suggestions_for_project&.call(node.fetch(:project_name, '').to_s))
+        ([task_name] + suggestions.map(&:to_s)).reject(&:empty?).uniq.each do |suggestion|
+          editor.add_item(suggestion)
+        end
+        editor.current_text = task_name
+      end
+
+      def bind_entry_task_input_events(task_container, entry_id)
+        display_input = entry_task_display_input(task_container)
+        editor = entry_task_editor(task_container)
+        editor_input = entry_task_editor_line_edit(editor)
+
+        display_input.on(:mouse_button_press) { |_| activate_entry_task_input(task_container) }
+        editor_input.on(:key_press) { |event| handle_entry_task_key_press(task_container, entry_id, event) }
+        editor_input.connect('returnPressed') { |_| handle_entry_task_commit(task_container, entry_id) }
+        editor_input.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 entry_task_display_input(task_container)
+        task_display_input_for(task_container)
+      end
+
+      def entry_task_editor(task_container)
+        task_editor_for(task_container)
+      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
 
-      def handle_entry_task_focus_out(task_input)
-        deactivate_entry_task_input(task_input)
+      def handle_entry_task_key_press(task_container, entry_id, event)
+        return unless enter_key?(event)
+
+        handle_entry_task_commit(task_container, entry_id)
       end
 
-      def entry_task_line_edit(task_input)
-        task_input.instance_variable_get(:@qtimetrap_task_line_edit)
+      def handle_entry_task_commit(task_container, entry_id, force: false)
+        editor = entry_task_editor(task_container)
+        editor_input = entry_task_editor_line_edit(editor)
+        return if editor_input.is_read_only && !force
+
+        task_name = editor.current_text.to_s
+        sync_entry_task_display(task_container, task_name)
+        deactivate_entry_task_input(task_container)
+        return unless on_entry_task_change
+
+        on_entry_task_change.call(entry_id, task_name)
       end
     end
   end

data/app/components/entries/leaf_time_helpers.rb

@@ -25,10 +25,10 @@ module QTimetrap
 
       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')
+          time_group.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.spacing = 4
             time_layout.add_widget(start_input)
             time_layout.add_widget(build_entry_time_separator(time_group))
             time_layout.add_widget(end_input)
@@ -38,19 +38,19 @@ module QTimetrap
 
       def build_entry_time_separator(row)
         QLabel.new(row).tap do |separator|
-          separator.set_object_name('entry_node_entry_time_sep')
-          separator.set_text('-')
+          separator.object_name = 'entry_node_entry_time_sep'
+          separator.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.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)
+          time_input.placeholder_text = placeholder
+          time_input.alignment = Qt::AlignCenter
+          time_input.read_only = true
+          time_input.fixed_width = 58
         end
       end
 

data/app/components/entries/list_component.rb

@@ -6,6 +6,8 @@ module QTimetrap
     class ListComponent
       include ListHostHelpers
       include ListStateHelpers
+      include ListTaskEditorHelpers
+      include EntryRowRenderHelpers
       include QtUiHelpers
       include TreeHelpers
       include RenderHelpers
@@ -13,6 +15,7 @@ module QTimetrap
       HOST_HORIZONTAL_MARGINS = 28
       WIDTH_PADDING = 24
       TIME_FILTER_DEBOUNCE_MS = 220
+      RENDER_SLICE_MS = 4
 
       attr_reader :widget
 
@@ -29,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:)
@@ -57,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
@@ -69,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.set_object_name('entries_panel')
+        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
@@ -90,23 +375,25 @@ module QTimetrap
       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) }
+        @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
         QVBoxLayout.new(widget).tap do |layout|
           layout.set_contents_margins(0, 0, 0, 0)
-          layout.set_spacing(6)
+          layout.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)
+          area.object_name = 'entries_scroll'
+          area.widget_resizable = true
         end
       end
 

data/app/components/entries/list_host_helpers.rb

@@ -7,20 +7,23 @@ module QTimetrap
       private
 
       def build_host
-        QWidget.new(scroll_area).tap { |container| container.set_object_name('entries_host') }
+        QWidget.new(scroll_area).tap { |container| container.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)
+          layout.spacing = 2
         end
       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.set_widget(host)
+        scroll_area.widget = host
       end
     end
   end