qtimetrap 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c354f5a65349384bd932fceb8f62cb7b43927c789b67bcd57a5c064baf6754f
-  data.tar.gz: a0b067c516cfc16874afcd1f98088e8e8dbf023c079bc26cdb390c2e6e0c6b58
+  metadata.gz: 5287d989740a397f7ed84b151eb5d3d48ab8edd480bb580517cfdedc8e20bb54
+  data.tar.gz: 6234dfac9679d2b577999f83b561226d03bc70201743f8df8c4668d0e8c5fe57
 SHA512:
-  metadata.gz: b8a21804d830a6b48bedd2bcd3bf53b7ddc00db6d9b38174a3c6ff0a7fc63dc7b41e61ba2ac301a4aeef5c9b9d432c096bd1c1bce614ada07fb7c50a19e4d840
-  data.tar.gz: ba9ba9ff36f90346913699562b13c0842281e5c27bab6e22f5e326638b9c49bfceca7f51039345d84a994831065c1a73bfe8891ebed147ddfea2abb0a534a11d
+  metadata.gz: 140de50f2fde21743d1f58e108ceed523906dc79d2971ae519a45dda8fbdce3e5850f6a179c926580d6b3436450b2dd56f96a725619dc09fc8191fb3127db18c
+  data.tar.gz: 1cb985651e8bc995f9ad5d9fe554c5ef151a11a2bdcd88c31882c872d17bf765ab3cb3f1aaaf6924dc1bd44aef947c47a991b55447a76f2c5f29c93f950f9ec2

data/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.2] - 2026-03-17
+
+### Added
+- Editable task reassignment for individual entries.
+- Archive mode with archive/restore flow for entry rows.
+- Multi-select project filtering in the sidebar with recent-activity ordering for projects and tasks.
+- Date/time range filtering for rendered entry nodes.
+- Custom RuboCop enforcement for Ruby-style Qt setter usage in `app/**`.
+
+### Changed
+- Switched project license to BSD-2-Clause.
+- Moved specs under `spec/qtimetrap/**` and removed the RuboCop todo file.
+- Improved README, packaging metadata, and release preparation.
+- Tracker inputs now take focus on direct click when editing is allowed.
+
+### Fixed
+- Preserved running tracker inputs when selecting sidebar tasks.
+- Closed inline editors on outside click without relying on application-level hit-testing workarounds.
+- Restored entry task editor styling and display-field behavior.
+- Reduced UI regressions around inline task editing, scrolling, and blur handling.
+
+## [0.1.1] - 2026-03-14
+
+### Added
+- Fedora/COPR packaging, desktop entry installation, and application icons.
+- Sidebar task filtering, multi-project filtering, and archive support groundwork.
+- Editable note and time updates for entry leaves.
+
+### Changed
+- Updated runtime dependency to newer `qt` releases in the 0.1 series.
+
+## [0.1.0] - 2026-03-05
+
+### Added
+- Initial release of QTimetrap as a Ruby gem with a Qt desktop UI.
+- MVVM application structure with Zeitwerk autoloading, themed QSS styling, and Timetrap integration.

data/app/components/entries/branch_hierarchy_helpers.rb

@@ -8,10 +8,10 @@ module QTimetrap
 
       def build_children_container(parent_widget)
         container = QWidget.new(parent_widget)
-        container.set_object_name('entry_node_children')
+        container.object_name = 'entry_node_children'
         layout = QVBoxLayout.new(container)
         layout.set_contents_margins(0, 0, 0, 0)
-        layout.set_spacing(2)
+        layout.spacing = 2
         [container, layout]
       end
 
@@ -32,9 +32,9 @@ module QTimetrap
         binding = branch_bindings[node_id]
         return unless binding
 
-        binding.fetch(:children_container).set_visible(visible)
+        binding.fetch(:children_container).visible = visible
         text = branch_button_text(binding.fetch(:level), binding.fetch(:label), visible)
-        binding.fetch(:button).set_text(text)
+        binding.fetch(:button).text = text
       end
     end
   end

data/app/components/entries/leaf_archive_helpers.rb

@@ -8,12 +8,12 @@ module QTimetrap
 
       def build_entry_archive_button(row, node)
         QPushButton.new(row).tap do |button|
-          button.set_object_name('entry_node_entry_archive')
-          button.set_text('🗃')
-          button.set_tool_tip('Toggle archive state')
-          button.set_focus_policy(Qt::NoFocus)
-          button.set_fixed_width(28)
-          button.set_fixed_height(24)
+          button.object_name = 'entry_node_entry_archive'
+          button.text = '🗃'
+          button.tool_tip = 'Toggle archive state'
+          button.focus_policy = Qt::NoFocus
+          button.fixed_width = 28
+          button.fixed_height = 24
           entry_id = resolve_entry_id(node)
           button.connect('clicked') { |_| on_entry_archive&.call(entry_id) }
         end

data/app/components/entries/leaf_note_helpers.rb

@@ -31,32 +31,32 @@ module QTimetrap
 
       def build_entry_row(parent_widget)
         QWidget.new(parent_widget).tap do |row|
-          row.set_object_name('entry_node_entry_row')
-          row.set_fixed_width(branch_button_width)
-          row.set_fixed_height(32)
+          row.object_name = 'entry_node_entry_row'
+          row.fixed_width = branch_button_width
+          row.fixed_height = 32
         end
       end
 
       def build_entry_row_layout(row)
         QHBoxLayout.new(row).tap do |layout|
           layout.set_contents_margins(8, 0, 8, 0)
-          layout.set_spacing(6)
+          layout.spacing = 6
         end
       end
 
       def build_entry_prefix_label(row, node, level)
         QLabel.new(row).tap do |prefix_label|
-          prefix_label.set_object_name('entry_node_entry_prefix')
-          prefix_label.set_text("#{indent(level)}#{node.fetch(:prefix, node.fetch(:label))}")
+          prefix_label.object_name = 'entry_node_entry_prefix'
+          prefix_label.text = "#{indent(level)}#{node.fetch(:prefix, node.fetch(:label))}"
         end
       end
 
       def build_entry_note_input(row, node)
         QLineEdit.new(row).tap do |note_input|
-          note_input.set_object_name('entry_node_entry_note')
+          note_input.object_name = 'entry_node_entry_note'
           note_input.text = node.fetch(:note, '')
-          note_input.set_placeholder_text('(no note)')
-          note_input.set_read_only(true)
+          note_input.placeholder_text = '(no note)'
+          note_input.read_only = true
           bind_entry_note_input_events(note_input, resolve_entry_id(node))
         end
       end
@@ -83,12 +83,12 @@ module QTimetrap
       end
 
       def activate_entry_note_input(note_input)
-        note_input.set_read_only(false)
+        note_input.read_only = false
         note_input.set_focus
       end
 
       def deactivate_entry_note_input(note_input)
-        note_input.set_read_only(true)
+        note_input.read_only = true
         note_input.clear_focus
       end
 

data/app/components/entries/leaf_task_display_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Display-field helpers for entry task controls.
+    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
+end

data/app/components/entries/leaf_task_editor_state_helpers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # State transitions for entry task display/editor widgets.
+    module LeafTaskEditorStateHelpers
+      private
+
+      def activate_entry_task_input(task_container)
+        close_previous_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
+        editor.show_popup
+      end
+
+      def deactivate_entry_task_input(task_container)
+        editor = entry_task_editor(task_container)
+        editor_input = entry_task_editor_line_edit(editor)
+        editor_input.read_only = true
+        editor.hide_popup
+        editor.clear_focus
+        show_entry_task_display(task_container)
+      end
+
+      def handle_entry_task_focus_out(task_container)
+        return unless task_container
+
+        reset_entry_task_editor(task_container)
+        deactivate_entry_task_input(task_container)
+        return unless active_task_container
+        return unless task_container_matches?(active_task_container, task_container)
+
+        self.active_task_container = nil
+      end
+
+      def close_previous_task_editor(task_container)
+        return unless active_task_container
+        return if task_container_matches?(active_task_container, task_container)
+
+        handle_entry_task_focus_out(active_task_container)
+      end
+
+      def reset_entry_task_editor(task_container)
+        entry_task_editor(task_container).current_text = entry_task_display_input(task_container).text.to_s
+      end
+
+      def show_entry_task_editor(task_container)
+        entry_task_display_input(task_container).hide
+        entry_task_editor(task_container).show
+      end
+
+      def show_entry_task_display(task_container)
+        entry_task_editor(task_container).hide
+        entry_task_display_input(task_container).show
+      end
+
+      def sync_entry_task_display(task_container, task_name)
+        sync_task_display_field(entry_task_display_input(task_container), task_name)
+        entry_task_editor(task_container).current_text = task_name
+        entry_task_editor(task_container).tool_tip = task_name
+      end
+    end
+  end
+end

data/app/components/entries/leaf_task_helpers.rb

@@ -2,79 +2,124 @@
 
 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)
+        QLineEdit.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
+          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)
+        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
       end
 
-      def activate_entry_task_input(task_input)
-        entry_task_line_edit(task_input).set_read_only(false)
-        task_input.set_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 deactivate_entry_task_input(task_input)
-        entry_task_line_edit(task_input).set_read_only(true)
-        task_input.clear_focus
+      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
 
-      def handle_entry_task_key_press(task_input, entry_id, event)
-        return unless enter_key?(event)
+      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)
 
-        handle_entry_task_commit(task_input, entry_id)
+        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 handle_entry_task_commit(task_input, entry_id, force: false)
-        return if entry_task_line_edit(task_input).is_read_only && !force
+      def entry_task_display_input(task_container)
+        task_display_input_for(task_container)
+      end
 
-        task_name = task_input.current_text.to_s
-        deactivate_entry_task_input(task_input)
-        return unless on_entry_task_change
+      def entry_task_editor(task_container)
+        task_editor_for(task_container)
+      end
 
-        on_entry_task_change.call(entry_id, task_name)
+      def entry_task_editor_line_edit(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,7 @@ module QTimetrap
     class ListComponent
       include ListHostHelpers
       include ListStateHelpers
+      include ListTaskEditorHelpers
       include QtUiHelpers
       include TreeHelpers
       include RenderHelpers
@@ -73,7 +74,7 @@ module QTimetrap
 
       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))
@@ -91,22 +92,22 @@ module QTimetrap
 
       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) }
+        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 }
       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,20 @@ 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!
         @host = build_host
         @host_layout = build_host_layout
-        scroll_area.set_widget(host)
+        scroll_area.widget = host
       end
     end
   end

data/app/components/entries/list_state_helpers.rb

@@ -15,11 +15,20 @@ module QTimetrap
         @expanded = {}
         @current_nodes = []
         @branch_bindings = {}
+        initialize_task_editor_state!
+        @active_task_container_key = nil
         @leaf_labels = []
         @entry_rows = []
         @rendering = false
       end
 
+      def initialize_task_editor_state!
+        @task_containers = {}
+        @task_display_inputs = {}
+        @task_editors = {}
+        @task_editor_line_edits = {}
+      end
+
       def initialize_time_filter_state!
         @time_filter_from_toggle = nil
         @time_filter_to_toggle = nil
@@ -31,8 +40,8 @@ module QTimetrap
 
       def set_time_filter_state(toggle:, input:, value:)
         enabled = !value.nil?
-        toggle.set_checked(enabled)
-        input.set_date_time(value) if enabled
+        toggle.checked = enabled
+        input.date_time = value if enabled
       end
 
       def syncing_time_filters?
@@ -49,11 +58,58 @@ module QTimetrap
 
       def build_time_filter_debounce_timer
         QTimer.new(parent).tap do |timer|
-          timer.set_single_shot(true)
-          timer.set_interval(self.class::TIME_FILTER_DEBOUNCE_MS)
+          timer.single_shot = true
+          timer.interval = self.class::TIME_FILTER_DEBOUNCE_MS
           timer.connect('timeout') { |_| emit_time_range_filter_changed }
         end
       end
+
+      def register_task_widgets(task_container, display_input, editor, line_edit)
+        container_key = task_container_key(task_container)
+        task_containers[container_key] = task_container
+        task_display_inputs[container_key] = display_input
+        task_editors[container_key] = editor
+        task_editor_line_edits[task_editor_key(editor)] = line_edit
+      end
+
+      def task_container_key(task_container)
+        task_container.handle.address
+      end
+
+      def task_editor_key(editor)
+        editor.handle.address
+      end
+
+      def task_container_matches?(left, right)
+        task_container_key(left) == task_container_key(right)
+      end
+
+      def task_container_for_key(key)
+        task_containers[key]
+      end
+
+      def active_task_container
+        task_container_for_key(active_task_container_key)
+      end
+
+      def active_task_container=(task_container)
+        @active_task_container_key = task_container ? task_container_key(task_container) : nil
+      end
+
+      def task_display_input_for(task_container)
+        task_display_inputs[task_container_key(task_container)]
+      end
+
+      def task_editor_for(task_container)
+        task_editors[task_container_key(task_container)]
+      end
+
+      def task_editor_line_edit_for(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
     end
   end
 end

data/app/components/entries/list_task_editor_helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Public helpers for active task editor lifecycle.
+    module ListTaskEditorHelpers
+      def close_active_task_editor
+        return unless active_task_container
+
+        handle_entry_task_focus_out(active_task_container)
+      end
+
+      def task_editor_widget?(widget)
+        return false unless widget
+
+        task_editor_widget_names.include?(widget.object_name)
+      end
+
+      private
+
+      def task_editor_widget_names
+        %w[
+          entry_node_entry_task_container
+          entry_node_entry_task
+          entry_node_entry_task_editor
+          entry_node_entry_task_editor_input
+        ]
+      end
+    end
+  end
+end

data/app/components/entries/render_helpers.rb

@@ -7,10 +7,10 @@ module QTimetrap
       private
 
       def with_widget_updates_suspended
-        widget.set_updates_enabled(false)
+        widget.updates_enabled = false
         yield
       ensure
-        widget.set_updates_enabled(true)
+        widget.updates_enabled = true
         widget.update
       end