docs: def model_changed(self, model, prop_name, info):
          """This method notifies the model lists and the parent state about changes
  
          The method is called each time, the model is changed. This happens, when the state itself changes or one of
          its children (states, transitions, data flows) changes. Changes of the children cannot be observed directly,
          therefore children notify their parent about their changes by calling this method.
          This method then checks, what has been changed by looking at the model that is passed to it. In the following it
          notifies the list in which the change happened about the change.
          E.g. one child state changes its name. The model of that state observes itself and notifies the parent (
          i.e. this state model) about the change by calling this method with the information about the change. This
          method recognizes that the model is of type StateModel and therefore triggers a notify on the list of state
          models.
          "_notify_method_before" is used as trigger method when the changing function is entered and
          "_notify_method_after" is used when the changing function returns. This changing function in the example
          would be the setter of the property name.
          :param model: The model that was changed
          :param prop_name: The property that was changed
          :param info: Information about the change (e.g. the name of the changing function)
          """
          # if info.method_name == 'change_state_type':  # Handled in method 'change_state_type'
          #     return
  
          # If this model has been changed (and not one of its child states), then we have to update all child models
          # This must be done before notifying anybody else, because other may relay on the updated models
          if self.state == info['instance']:
              if 'after' in info:
                  self.update_child_models(model, prop_name, info)
                  # if there is and exception set is_about_to_be_destroyed_recursively flag to False again
                  if info.method_name in ["remove_state"] and isinstance(info.result, Exception):
                      state_id = info.kwargs['state_id'] if 'state_id' in info.kwargs else info.args[1]
                      self.states[state_id].is_about_to_be_destroyed_recursively = False
              else:
                  # while before notification mark all states which get destroyed recursively
                  if info.method_name in ["remove_state"] and \
                          info.kwargs.get('destroy', True) and info.kwargs.get('recursive', True):
                      state_id = info.kwargs['state_id'] if 'state_id' in info.kwargs else info.args[1]
                      self.states[state_id].is_about_to_be_destroyed_recursively = True
  
          changed_list = None
          cause = None
          # If the change happened in a child state, notify the list of all child states
          if (isinstance(model, AbstractStateModel) and model is not self) or (  # The state was changed directly
                  not isinstance(model, AbstractStateModel) and model.parent is not self):  # One of the member models was changed
              changed_list = self.states
              cause = 'state_change'
          # If the change happened in one of the transitions, notify the list of all transitions
          elif isinstance(model, TransitionModel) and model.parent is self:
              changed_list = self.transitions
              cause = 'transition_change'
          # If the change happened in one of the data flows, notify the list of all data flows
          elif isinstance(model, DataFlowModel) and model.parent is self:
              changed_list = self.data_flows
              cause = 'data_flow_change'
          # If the change happened in one of the scoped variables, notify the list of all scoped variables
          elif isinstance(model, ScopedVariableModel) and model.parent is self:
              changed_list = self.scoped_variables
              cause = 'scoped_variable_change'
  
          if not (cause is None or changed_list is None):
              if 'before' in info:
                  changed_list._notify_method_before(self.state, cause, (self.state,), info)
              elif 'after' in info:
                  changed_list._notify_method_after(self.state, cause, None, (self.state,), info)
  
          # Finally call the method of the base class, to forward changes in ports and outcomes
          super(ContainerStateModel, self).model_changed(model, prop_name, info)