docs: def _apply_value_on_edited_and_focus_out(self, renderer, apply_method):
          """Sets up the renderer to apply changed when loosing focus
  
          The default behaviour for the focus out event dismisses the changes in the renderer. Therefore we setup
          handlers for that event, applying the changes.
  
          :param Gtk.CellRendererText renderer: The cell renderer who's changes are to be applied on focus out events
          :param apply_method: The callback method applying the newly entered value
          """
          assert isinstance(renderer, Gtk.CellRenderer)
  
          def remove_all_handler(renderer):
              """Remove all handler for given renderer and its editable
  
              :param renderer: Renderer of the respective column which is edit by a entry widget, at the moment
              """
              def remove_handler(widget, data_name):
                  """Remove handler from given widget
  
                  :param Gtk.Widget widget: Widget from which a handler is to be removed
                  :param data_name: Name of the data of the widget in which the handler id is stored
                  """
                  handler_id = getattr(widget, data_name)
                  if widget.handler_is_connected(handler_id):
                      widget.disconnect(handler_id)
  
              editable = getattr(renderer, "editable")
              remove_handler(editable, "focus_out_handler_id")
              remove_handler(editable, "cursor_move_handler_id")
              remove_handler(editable, "insert_at_cursor_handler_id")
              remove_handler(editable, "entry_widget_expose_event_handler_id")
              remove_handler(renderer, "editing_cancelled_handler_id")
  
          def on_focus_out(entry, event):
              """Applies the changes to the entry
  
              :param Gtk.Entry entry: The entry that was focused out
              :param Gtk.Event event: Event object with information about the event
              """
              renderer.remove_all_handler(renderer)
              if renderer.ctrl.get_path() is None:
                  return
              # Originally we had to use idle_add to prevent core dumps:
              # https://mail.gnome.org/archives/gtk-perl-list/2005-September/msg00143.html
              # Gtk TODO: use idle_add if there are problems
              apply_method(renderer.ctrl.get_path(), entry.get_text())
  
          def on_cursor_move_in_entry_widget(entry, step, count, extend_selection):
              """Trigger scroll bar adjustments according active entry widgets cursor change
              """
              self.tree_view_keypress_callback(entry, None)
  
          def on_editing_started(renderer, editable, path):
              """Connects the a handler for the focus-out-event of the current editable
  
              :param Gtk.CellRendererText renderer: The cell renderer who's editing was started
              :param Gtk.CellEditable editable: interface for editing the current TreeView cell
              :param str path: the path identifying the edited cell
              """
              # secure scrollbar adjustments on active cell
              ctrl = renderer.ctrl
              [path, focus_column] = ctrl.tree_view.get_cursor()
              if path:
                  ctrl.tree_view.scroll_to_cell(path, ctrl.widget_columns[ctrl.widget_columns.index(focus_column)],
                                                use_align=False)
  
              editing_cancelled_handler_id = renderer.connect('editing-canceled', on_editing_canceled)
              focus_out_handler_id = editable.connect('focus-out-event', on_focus_out)
              cursor_move_handler_id = editable.connect('move-cursor', on_cursor_move_in_entry_widget)
              insert_at_cursor_handler_id = editable.connect("insert-at-cursor", on_cursor_move_in_entry_widget)
              entry_widget_expose_event_handler_id = editable.connect("draw", self.on_entry_widget_draw_event)
              # Store reference to editable and signal handler ids for later access when removing the handlers
              # see https://gitlab.gnome.org/GNOME/accerciser/commit/036689e70304a9e98ce31238dfad2432ad4c78ea
              # originally with renderer.set_data()
              # renderer.set_data("editable", editable)
              setattr(renderer, "editable", editable)
              setattr(renderer, "editing_cancelled_handler_id", editing_cancelled_handler_id)
              # editable
              setattr(editable, "focus_out_handler_id", focus_out_handler_id)
              setattr(editable, "cursor_move_handler_id", cursor_move_handler_id)
              setattr(editable, "insert_at_cursor_handler_id", insert_at_cursor_handler_id)
              setattr(editable, "entry_widget_expose_event_handler_id", entry_widget_expose_event_handler_id)
              ctrl.active_entry_widget = editable
  
          def on_edited(renderer, path, new_value_str):
              """Calls the apply method with the new value
  
              :param Gtk.CellRendererText renderer: The cell renderer that was edited
              :param str path: The path string of the renderer
              :param str new_value_str: The new value as string
              """
              renderer.remove_all_handler(renderer)
              apply_method(path, new_value_str)
              renderer.ctrl.active_entry_widget = None
  
          def on_editing_canceled(renderer):
              """Disconnects the focus-out-event handler of cancelled editable
  
              :param Gtk.CellRendererText renderer: The cell renderer who's editing was cancelled
              """
              remove_all_handler(renderer)
              renderer.ctrl.active_entry_widget = None
  
          renderer.remove_all_handler = remove_all_handler
          renderer.ctrl = self
          # renderer.connect('editing-started', on_editing_started)
          # renderer.connect('edited', on_edited)
          self.__attached_renderers.append(renderer)
          self.connect_signal(renderer, 'editing-started', on_editing_started)
          self.connect_signal(renderer, 'edited', on_edited)