docs: def get_nice_info_dict_string(self, info, level='\t', overview=None):
          """ Inserts all elements of a notification info-dictionary of gtkmvc3 or a Signal into one string and indicates
          levels of calls defined by 'kwargs'. Additionally, the elements get structured into a dict that holds all levels
          of the general notification key-value pairs in faster accessible lists. The dictionary has the element 'type'
          and the general elements {'model': [], 'prop_name': [], 'instance': [], 'method_name': [], 'args': [],
          'kwargs': []}) plus specific elements according the type. Type is always one of the following list
          ['before', 'after', 'signal'].
          """
          def get_nice_meta_signal_msg_tuple_string(meta_signal_msg_tuple, level, overview):
              meta_signal_dict = {}
              # origin
              s = "\n{0}origin={1}".format(level + "\t", meta_signal_msg_tuple.origin)
              meta_signal_dict['origin'] = meta_signal_msg_tuple.origin
              # change
              s += "\n{0}change={1}".format(level + "\t", meta_signal_msg_tuple.change)
              meta_signal_dict['change'] = meta_signal_msg_tuple.change
              # affects_children
              s += "\n{0}affects_children={1}".format(level + "\t", meta_signal_msg_tuple.affects_children)
              meta_signal_dict['affects_children'] = meta_signal_msg_tuple.affects_children
              overview['signal'].append(meta_signal_dict)
  
              # notification (tuple)
              notification_dict = {}
              meta_signal_dict['notification'] = notification_dict
              if meta_signal_msg_tuple.notification is None:
                  s += "\n{0}notification={1}".format(level + "\t", meta_signal_msg_tuple.notification)
              else:
                  s += "\n{0}notification=Notification(".format(level + "\t")
                  # model
                  notification_dict['model'] = meta_signal_msg_tuple.notification.model
                  s += "\n{0}model={1}".format(level + "\t\t", meta_signal_msg_tuple.notification.model)
                  # prop_name
                  notification_dict['prop_name'] = meta_signal_msg_tuple.notification.prop_name
                  s += "\n{0}prop_name={1}".format(level + "\t\t", meta_signal_msg_tuple.notification.prop_name)
                  # info
                  notification_dict['info'] = meta_signal_msg_tuple.notification.info
                  overview['kwargs'].append(meta_signal_msg_tuple.notification.info)
                  s += "\n{0}info=\n{1}{0}\n".format(level + "\t\t",
                                                 self.get_nice_info_dict_string(meta_signal_msg_tuple.notification.info,
                                                                                level+'\t\t\t',
                                                                                overview))
              return s
  
          def get_nice_action_signal_msg_tuple_string(meta_signal_msg_tuple, level, overview):
              meta_signal_dict = {}
              # after
              s = "\n{0}after={1}".format(level + "\t", meta_signal_msg_tuple.after)
              meta_signal_dict['after'] = meta_signal_msg_tuple.after
              # action
              s += "\n{0}action={1}".format(level + "\t", meta_signal_msg_tuple.action)
              meta_signal_dict['action'] = meta_signal_msg_tuple.action
              # origin
              s += "\n{0}origin={1}".format(level + "\t", meta_signal_msg_tuple.origin)
              meta_signal_dict['origin'] = meta_signal_msg_tuple.origin
              # origin
              s += "\n{0}action_parent_m={1}".format(level + "\t", meta_signal_msg_tuple.action_parent_m)
              meta_signal_dict['action_parent_m'] = meta_signal_msg_tuple.origin
              # change
              s += "\n{0}affected_models={1}".format(level + "\t", meta_signal_msg_tuple.affected_models)
              meta_signal_dict['affected_models'] = meta_signal_msg_tuple.affected_models
              if meta_signal_msg_tuple.after:
                  s += "\n{0}result={1}".format(level + "\t", meta_signal_msg_tuple.result)
                  meta_signal_dict['result'] = meta_signal_msg_tuple.result
  
              return s
  
  
          overview_was_none = False
          if overview is None:
              overview_was_none = True
              overview = dict({'model': [], 'prop_name': [], 'instance': [], 'method_name': [], 'args': [], 'kwargs': []})
              overview['others'] = []
              overview['info'] = []
              if 'before' in info:
                  overview['type'] = 'before'
              elif 'after' in info:
                  overview['type'] = 'after'
                  overview['result'] = []
              else:  # 'signal' in info:
                  overview['type'] = 'signal'
                  overview['signal'] = []
  
          if ('after' in info or 'before' in info or 'signal' in info) and 'model' in info:
              if 'before' in info:
                  s = "{0}'before': {1}".format(level, info['before'])
              elif 'after' in info:
                  s = "{0}'after': {1}".format(level, info['after'])
              else:
                  s = "{0}'signal': {1}".format(level, info['signal'])
          else:
              return str(info)
          overview['info'].append(info)
          # model
          s += "\n{0}'model': {1}".format(level, info['model'])
          overview['model'].append(info['model'])
          # prop_name
          s += "\n{0}'prop_name': {1}".format(level, info['prop_name'])
          overview['prop_name'].append(info['prop_name'])
          if not overview['type'] == 'signal':
              # instance
              s += "\n{0}'instance': {1}".format(level, info['instance'])
              overview['instance'].append(info['instance'])
              # method_name
              s += "\n{0}'method_name': {1}".format(level, info['method_name'])
              overview['method_name'].append(info['method_name'])
              # args
              s += "\n{0}'args': {1}".format(level, info['args'])
              overview['args'].append(info['args'])
  
              overview['kwargs'].append(info['kwargs'])
              if overview['type'] == 'after':
                  overview['result'].append(info['result'])
              # kwargs
              s += "\n{0}'kwargs': {1}".format(level, self.get_nice_info_dict_string(info['kwargs'],
                                                                                     level + "\t",
                                                                                     overview))
              if overview['type'] == 'after':
                  s += "\n{0}'result': {1}".format(level, info['result'])
              # additional elements not created by gtkmvc3 or common function calls
              overview['others'].append({})
              for key, value in info.items():
                  if key in ['before', 'after', 'model', 'prop_name', 'instance', 'method_name', 'args', 'kwargs', 'result']:
                      pass
                  else:
                      s += "\n{0}'{2}': {1}".format(level, info[key], key)
                      overview['others'][len(overview['others'])-1][key] = info[key]
          else:
              overview['kwargs'].append({})
              # print(info)
              # print(info['arg'])
              if isinstance(info['arg'], MetaSignalMsg):
                  overview['signal'].append(info['arg'])
                  s += "\n{0}'arg': MetaSignalMsg({1}".format(level,
                                                              get_nice_meta_signal_msg_tuple_string(info['arg'],
                                                                                                    level,
                                                                                                    overview))
              elif isinstance(info['arg'], ActionSignalMsg):
                  overview['instance'].append(info['arg'].action_parent_m.core_element)
                  overview['method_name'].append(info['arg'].action)
                  overview['signal'].append(info['arg'])
                  overview['kwargs'].append(info['arg'].kwargs)
                  # TODO check again this stuff
                  args = [info['arg'].action_parent_m.core_element, ]
                  args.extend(info['arg'].kwargs.values())
                  overview['args'].append(args)
                  s += "\n{0}'arg': ActionSignalMsg({1}".format(level,
                                                                get_nice_action_signal_msg_tuple_string(info['arg'],
                                                                                                        level,
                                                                                                        overview))
              else:
                  raise str(info)
  
          if overview_was_none:
              return s, overview
          else:
              return s