def tree_view_keypress_callback(self, widget, event):
        """Tab back and forward tab-key motion in list widget and the scrollbar motion to follow key cursor motions

         The method introduce motion and edit functionality by using "tab"- or "shift-tab"-key for a Gtk.TreeView.
         It is designed to work with a Gtk.TreeView which model is a Gtk.ListStore and only uses text cell renderer.
         Additional, the TreeView is assumed to be used as a list not as a tree.
         With the "tab"-key the cell on the right site of the actual focused cell is started to be edit. Changes in the
         Gtk.Entry-Widget are confirmed by emitting a 'edited'-signal. If the row ends the edit process continues
         with the first cell of the next row. With the "shift-tab"-key the inverse functionality of the "tab"-key is
         provided.
         The Controller over steps not editable cells.

        :param Gtk.TreeView widget: The tree view the controller use
        :param Gdk.Event event: The key press event
        :return:
        """
        # self._logger.info("key_value: " + str(event.keyval if event is not None else ''))
        # TODO works for root level or other single level of tree view but not for switching in between levels
        if event and "GDK_KEY_PRESS" == event.type.value_name \
                and (event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab):
            [path, focus_column] = self.tree_view.get_cursor()
            # print("cursor ", path, focus_column)
            model, paths = self.tree_view.get_selection().get_selected_rows()
            if paths:
                path = paths[0]
                # print("tree selection", path, focus_column, paths)
            if not path:
                return False
            self.tree_view_keypress_callback.__func__.core_element_id = self.store[path][self.ID_STORAGE_ID]
            # print("core id", self.store[path][self.ID_STORAGE_ID], path, type(path))
            # finish active edit process
            if self.active_entry_widget is not None:
                text = self.active_entry_widget.get_buffer().get_text()
                if focus_column in self.widget_columns:
                    # print("path", ':'.join([str(elem) for elem in path]))
                    focus_column.get_cells()[0].emit('edited', ':'.join([str(elem) for elem in path]), text)

            # row could be updated by other call_backs caused by emitting 'edited' signal but selection stays an editable neighbor
            core_element_id = ':'.join([str(key) for key in self.tree_view_keypress_callback.__func__.core_element_id])
            if core_element_id in self._changed_id_to:
                self.tree_view_keypress_callback.__func__.core_element_id = self._changed_id_to[core_element_id]
            path = self.get_path_for_core_element(self.tree_view_keypress_callback.__func__.core_element_id)
            if event.keyval == Gdk.KEY_Tab:
                # logger.info("move right")
                direction = +1
            else:
                # logger.info("move left")
                direction = -1

            if len(path) > 1:
                n_elements_in_hierarchy = self.tree_store.iter_n_children(self.tree_store.get_iter(path[:-1]))
            else:
                n_elements_in_hierarchy = self.tree_store.iter_n_children(None)  # root

            if direction < 0 and focus_column is self.widget_columns[0] \
                    or direction > 0 and focus_column is self.widget_columns[-1]:
                if direction < 0 < path[-1] or direction > 0 and not path[-1] + 1 > n_elements_in_hierarchy:
                    next_row = path[-1] + direction
                else:
                    return False
            else:
                next_row = path[-1]
            new_path = tuple(list(path[:-1]) + [next_row])
            # print("new path", new_path, path[:-1])
            # get next column_id for focus
            focus_column_id = self.widget_columns.index(focus_column)
            if focus_column_id is not None:
                # search all columns for next editable cell renderer
                next_focus_column_id = 0
                for index in range(len(self.tree_view.get_model())):
                    test_id = focus_column_id + direction * index + direction
                    next_focus_column_id = test_id % len(self.widget_columns)
                    if test_id > len(self.widget_columns) - 1 or test_id < 0:
                        next_row = path[-1] + direction
                        if next_row < 0 or next_row > len(self.tree_store[path[:-1]] if len(path) > 1 else self.tree_store) - 1:
                            return False

                    if self.widget_columns[next_focus_column_id].get_cells()[0].get_property('editable'):
                        break
            else:
                return False
            new_path = tuple(list(path[:-1]) + [next_row])
            # print("nnew path", new_path)
            del self.tree_view_keypress_callback.__func__.core_element_id
            # self._logger.info("self.tree_view.scroll_to_cell(next_row={0}, self.widget_columns[{1}] , use_align={2})"
            #              "".format(next_row, next_focus_column_id, False))
            # self.tree_view.scroll_to_cell(new_path, self.widget_columns[next_focus_column_id], use_align=False)
            self.tree_view.set_cursor_on_cell(Gtk.TreePath.new_from_indices([new_path]), self.widget_columns[
                next_focus_column_id], focus_cell=None, start_editing=True)
            return True
        else:
            super(TreeViewController, self).tree_view_keypress_callback(widget, event)
Tab back and forward tab-key motion in list widget and the scrollbar motion to follow key cursor motions

         The method introduce motion and edit functionality by using "tab"- or "shift-tab"-key for a Gtk.TreeView.
         It is designed to work with a Gtk.TreeView which model is a Gtk.ListStore and only uses text cell renderer.
         Additional, the TreeView is assumed to be used as a list not as a tree.
         With the "tab"-key the cell on the right site of the actual focused cell is started to be edit. Changes in the
         Gtk.Entry-Widget are confirmed by emitting a 'edited'-signal. If the row ends the edit process continues
         with the first cell of the next row. With the "shift-tab"-key the inverse functionality of the "tab"-key is
         provided.
         The Controller over steps not editable cells.

        :param Gtk.TreeView widget: The tree view the controller use
        :param Gdk.Event event: The key press event
        :return: