docs: def get_possible_combos_for_transition(trans, model, self_model, is_external=False):
          """ The function provides combos for a transition and its respective
  
          :param trans:
          :param model:
          :param self_model:
          :param is_external:
          :return:
          """
          from_state_combo = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING)
          from_outcome_combo = Gtk.ListStore(GObject.TYPE_STRING)
          to_state_combo = Gtk.ListStore(GObject.TYPE_STRING)
          to_outcome_combo = Gtk.ListStore(GObject.TYPE_STRING)
  
          trans_dict = model.state.transitions
  
          # get from state
          if trans is None:
              from_state = None
          elif trans.from_state is not None:
              from_state = model.state.states[trans.from_state]
          else:
              from_state = model.state if is_external else self_model.state
  
          # collect all free from-outcome-combo and from_state which are still valid -> filter all outcome already in use
          free_from_outcomes_dict = {}
          for state in model.state.states.values():
              from_o_combo = state.outcomes.values()
              # print([o.outcome_id for o in from_o_combo], state_model.state.state_id)
              for transition in trans_dict.values():
                  # print(transition, [[o.outcome_id == transition.from_outcome, transition.from_state == state_model.state.state_id] for o in from_o_combo])
                  from_o_combo = [o for o in from_o_combo if not (o.outcome_id == transition.from_outcome and
                                                       transition.from_state == state.state_id)]
                  # print([o.outcome_id for o in from_o_combo])
              if len(from_o_combo) > 0:
                  free_from_outcomes_dict[state.state_id] = from_o_combo
          # check if parent has start_state
          if model.state.start_state_id is None:
              free_from_outcomes_dict[model.state.state_id] = [None]
  
          # for from-state-combo use all states with free outcomes and from_state
          combined_states = [model.state] if is_external else [self_model.state]
          combined_states.extend(model.state.states.values())
          free_from_states = [state for state in combined_states if state.state_id in free_from_outcomes_dict]
  
          if trans is None:
              return None, None, None, None, free_from_states, free_from_outcomes_dict
  
          def append_from_state_combo(possible_state):
              if possible_state.state_id == self_model.state.state_id:
                  from_state_combo.append(['self.' + possible_state.state_id, possible_state.state_id])
              elif is_external and from_state.state_id == model.state.state_id:
                  from_state_combo.append(['parent.' + possible_state.state_id, possible_state.state_id])
              else:
                  from_state_combo.append([possible_state.name + '.' + possible_state.state_id, possible_state.state_id])
  
          append_from_state_combo(from_state)
          for state in free_from_states:
              if from_state is not state:
                  append_from_state_combo(state)
  
          # for from-outcome-combo collect all combos for actual transition
          # -> actual outcome + free outcomes of actual from_state.state_id
          if trans is not None:
              if trans.from_outcome is None:
                  from_outcome_combo.append(["None"])
              else:
                  outcome = from_state.outcomes[trans.from_outcome]
                  from_outcome_combo.append([outcome.name + "." + str(outcome.outcome_id)])
              for outcome in free_from_outcomes_dict.get(from_state.state_id, []):
                  if outcome is None:
                      from_outcome_combo.append(["None"])
                  else:
                      from_outcome_combo.append([outcome.name + "." + str(outcome.outcome_id)])
  
          # get to state
          if trans.to_state == model.state.state_id:
              to_state = model.state if is_external else self_model.state
          else:
              to_state = model.state.states[trans.to_state]
  
          # for to-state-combo filter from_state -> first actual to_state + other optional states
          def generate_to_state_combo(possible_state):
              if possible_state.state_id == self_model.state.state_id:
                  to_state_combo.append(["self." + possible_state.state_id])
              elif is_external and possible_state.state_id == model.state.state_id:
                  to_state_combo.append(['parent.' + possible_state.state_id])
              else:
                  to_state_combo.append([possible_state.name + '.' + possible_state.state_id])
  
          to_states = [model.state] if is_external else [self_model.state]
          to_states.extend(model.state.states.values())
          generate_to_state_combo(to_state)
          for state in to_states:
              if not to_state.state_id == state.state_id:
                  generate_to_state_combo(state)
  
          # for to-outcome-combo use parent combos -> first actual outcome + other outcome
          def append_to_outcome_combo(possible_outcome):
              if is_external:
                  to_outcome_combo.append(['parent.' + possible_outcome.name + "." + str(possible_outcome.outcome_id)])
              else:
                  to_outcome_combo.append(['self.' + possible_outcome.name + "." + str(possible_outcome.outcome_id)])
  
          if trans.to_outcome is not None:
              append_to_outcome_combo(model.state.outcomes[trans.to_outcome])
          for outcome in model.state.outcomes.values():
              if not (trans.to_outcome == outcome.outcome_id and trans.to_state == model.state.state_id):
                  append_to_outcome_combo(outcome)
  
          return from_state_combo, from_outcome_combo, to_state_combo, to_outcome_combo, free_from_states, free_from_outcomes_dict