docs: def handle_no_transition(self, state):
          """ This function handles the case that there is no transition for a specific outcome of a sub-state.
  
          The method waits on a condition variable to a new transition that will be connected by the programmer or
          GUI-user.
  
          :param state: The sub-state to find a transition for
          :return: The transition for the target state.
          :raises exceptions.RuntimeError: if the execution engine is stopped
                                          (this will be caught at the end of the run method)
          """
          transition = None
          while not transition:
  
              # (child) state preempted or aborted
              if self.preempted or state.final_outcome.outcome_id in [-2, -1]:
                  if self.concurrency_queue:
                      self.concurrency_queue.put(self.state_id)
                  self.state_execution_status = StateExecutionStatus.WAIT_FOR_NEXT_STATE
  
                  if state.final_outcome.outcome_id == -1:
                      self.final_outcome = Outcome(-1, "aborted")
                  else:
                      self.final_outcome = Outcome(-2, "preempted")
  
                  logger.debug("{0} of {1} not connected, using default transition to parental {2}".format(
                      state.final_outcome, state, self.final_outcome))
                  return None
  
              # depending on the execution mode pause execution
              execution_signal = state_machine_execution_engine.handle_execution_mode(self)
              if execution_signal is StateMachineExecutionStatus.STOPPED:
                  # this will be caught at the end of the run method
                  self.last_child.state_execution_status = StateExecutionStatus.INACTIVE
                  logger.warning("State machine was stopped, while state {} waited for the next transition.".format(
                      state.name
                  ))
                  return None
  
              # wait until the user connects the outcome of the state with a transition
              logger.warning("Waiting for new transition at {1} of {0} ".format(state, state.final_outcome))
              self._transitions_cv.acquire()
              self._transitions_cv.wait(3.0)
              self._transitions_cv.release()
  
              transition = self.get_transition_for_outcome(state, state.final_outcome)
  
          return transition