docs: def update(self, model, prop_name, info):
          """ The method updates the history (a Gtk.TreeStore) which is the model of respective TreeView.
          It functionality is strongly depends on a consistent history-tree hold by a ChangeHistory-Class.
          """
          # logger.debug("History changed %s\n%s\n%s" % (model, prop_name, info))
          if self.parent is not None and hasattr(self.parent, "focus_notebook_page_of_controller"):
              # request focus -> which has not have to be satisfied
              self.parent.focus_notebook_page_of_controller(self)
  
          if self._selected_sm_model is None or self._selected_sm_model.history.fake or \
                  info is not None and info.method_name not in ["insert_action", "undo", "redo", "reset"]:
              return
  
          self.doing_update = True
          self.history_tree_store.clear()
          self.list_tree_iter = {}
          trail_actions = [action.version_id for action in self._selected_sm_model.history.modifications.single_trail_history()]
  
          def insert_this_action(action, parent_tree_item, init_branch=False):
              """ The function insert a action with respective arguments (e.g. method_name, instance) into a TreeStore.
                  - final trail or tree specific gtk-tree-levels -> 'trail' has no levels as well as 'branch' without tree
                  - defines which element is marked as active
                  - generate branch labels with version-id
              """
              model = action.before_overview['model'][-1]
              method_name = action.before_overview['method_name'][-1]
              instance = action.before_overview['instance'][-1]
              parameters = []
              tool_tip = None
              if action.before_overview['type'] == 'signal':
                  if isinstance(action.before_overview['signal'][0], MetaSignalMsg):
                      # logger.info(action.before_overview._overview_dict)
                      parameters.append(str(action.meta))
                  elif isinstance(action.before_overview['signal'][-1], ActionSignalMsg):
                      if action.action_type not in ['paste', 'cut']:
                          parameters.append(str(action.before_overview['signal'][-1].kwargs))
                  else:
                      logger.warning("no parameters defined for signal: {0}".format(action.before_overview['signal']))
                      # for index, signal in enumerate(action.before_overview['signal']):
                      #     print("\n", index, signal)
              else:
                  for index, value in enumerate(action.before_overview['args'][-1]):
                      if not index == 0:
                          parameters.append(str(value))
              for name, value in action.before_overview['kwargs'][-1].items():
                  parameters.append("{0}: {1}".format(name, value))
  
              if hasattr(action, 'action_type') and action.action_type == "script_text" and hasattr(action, 'script_diff'):
                  line = ""
                  for elem in action.script_diff.split('\n'):
                      line = elem
                      if not line.replace(' ', '') == '' and (line.startswith('+') or line.startswith('-')):
                          break
                  tool_tip = action.script_diff
                  parameters = [line]  # + "\n -> [hover for source script diff in tooltip.]"]
              if hasattr(action, 'action_type') and action.action_type == "description" and hasattr(action, 'description_diff'):
                  line = ""
                  for elem in action.description_diff.split('\n'):
                      line = elem
                      if not line.replace(' ', '') == '' and (line.startswith('+') or line.startswith('-')):
                          break
                  tool_tip = action.description_diff
                  parameters = [line]  # + "\n -> [hover for source script diff in tooltip.]"]
  
              # find active actions in to be marked in view
              if self._mode == 'trail':
                  active = len(self.history_tree_store) <= self._selected_sm_model.history.modifications.trail_pointer
              else:
                  all_active = self._selected_sm_model.history.modifications.get_all_active_actions()
                  active = action.version_id in all_active
  
              # generate label to mark branches
              version_label = action.version_id
              if init_branch:
                  version_label = 'b.' + str(action.version_id)
                  tool_tip = "The element '{0}' starts a new branch of actions.".format(version_label)
  
              tree_row_iter = self.new_change(model, str(method_name).replace('_', ' '), instance, info, version_label, active,
                                              parent_tree_item, ', '.join(parameters), tool_tip)
              self.list_tree_iter[action.version_id] = (tree_row_iter, parent_tree_item)
              return tree_row_iter
  
          def insert_all_next_actions(version_id, parent_tree_item=None):
              """ The function defines linkage of history-tree-elements in a gtk-tree-view to create a optimal overview.
              """
              if len(self._selected_sm_model.history.modifications.all_time_history) == 1:
                  return
              next_id = version_id
              while next_id is not None:
                  # print(next_id, len(self._selected_sm_model.history.modifications.all_time_history))
                  version_id = next_id
                  history_tree_elem = self._selected_sm_model.history.modifications.all_time_history[next_id]
                  next_id = history_tree_elem.next_id
                  prev_tree_elem = None
                  if history_tree_elem.prev_id is not None:
                      prev_tree_elem = self._selected_sm_model.history.modifications.all_time_history[history_tree_elem.prev_id]
                  action = history_tree_elem.action
                  # logger.info("prev branch #{0} <-> {1}, trail_actions are {2}".format(history_tree_elem.action.version_id, prev_tree_elem, trail_actions))
                  in_trail = history_tree_elem.action.version_id in trail_actions
                  if in_trail:
                      # in trail parent is always None
                      if prev_tree_elem is not None and prev_tree_elem.old_next_ids:
                          child_tree_item = insert_this_action(action, None, init_branch=True)
                      else:
                          child_tree_item = insert_this_action(action, None)
                  elif prev_tree_elem is not None and prev_tree_elem.old_next_ids:
                      # branch and not trail -> level + 1 ... child of prev_id -> parent_iter is prev_id_iter
                      prev_id_iter = self.list_tree_iter[prev_tree_elem.action.version_id][0]
                      child_tree_item = insert_this_action(action, prev_id_iter, init_branch=True)
                  elif prev_tree_elem is not None and not prev_tree_elem.old_next_ids:
                      # no branch and not trail
                      prev_prev_tree_elem = self._selected_sm_model.history.modifications.all_time_history[prev_tree_elem.prev_id]
                      branch_limit_for_extra_ident_level = 1 if prev_tree_elem.prev_id in trail_actions else 0
                      if len(prev_prev_tree_elem.old_next_ids) > branch_limit_for_extra_ident_level:
                          # -> level + 1 as previous element, because to many branches -> so prev_id iter as parent_iter
                          iter_of_prev_id = self.list_tree_iter[prev_tree_elem.action.version_id][0]
                          child_tree_item = insert_this_action(action, iter_of_prev_id)
                      else:
                          # -> same level as previous element -> so same parent_iter as prev_id
                          parent_iter_of_prev_id = self.list_tree_iter[prev_tree_elem.action.version_id][1]
                          child_tree_item = insert_this_action(action, parent_iter_of_prev_id)
                  else:
                      logger.warning("relative level could not be found -> this should not happen")
                      child_tree_item = insert_this_action(action, parent_tree_item)
  
                  if history_tree_elem.old_next_ids and self._mode == 'branch':
                      old_next_ids = history_tree_elem.old_next_ids
                      for old_next_id in old_next_ids:
                          insert_all_next_actions(old_next_id, child_tree_item)
  
          insert_all_next_actions(version_id=0)
  
          # set selection of Tree
          if self._selected_sm_model.history.modifications.trail_pointer is not None and len(self.history_tree_store) > 1:
              searched_row_version_id = self._selected_sm_model.history.modifications.single_trail_history()[self._selected_sm_model.history.modifications.trail_pointer].version_id
              row_number = 0
              for action_entry in self.history_tree_store:
                  # compare action.version_id
                  if int(action_entry[1].split('.')[-1]) == searched_row_version_id:
                      self.view['history_tree'].set_cursor(row_number)
                      break
                  row_number += 1
  
          # set colors of Tree
          # - is state full and all element which are open to be re-done gray
          self.doing_update = False