docs: def outputPoint(self):
          """
          Returns a scene space point that the connection \
          will draw to as its output source.  If the connection \
          has a node defined, then it will calculate the output \
          point based on the position of the node, factoring in \
          preference for output location and fixed positions.  If \ 
          there is no node connected, then the point defined using \
          the setOutputPoint method will be used.
          
          :return     <QPointF>
          """
          node = self.outputNode()
  
          # return the set point
          if not node:
              return self._outputPoint
  
          # test for the hotspot
          hotspot = self.outputHotspot()
  
          # otherwise, calculate the point based on location and fixed positions
          olocation = self.outputLocation()
          ofixedx = self.outputFixedX()
          ofixedy = self.outputFixedY()
  
          loc_left = XNodeConnection.Location.Left
          loc_right = XNodeConnection.Location.Right
          loc_top = XNodeConnection.Location.Top
          loc_bot = XNodeConnection.Location.Bottom
  
          irect = self.inputRect()
          orect = self.outputRect()
  
          # return the right location
          if olocation & loc_right and orect.right() < irect.left():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().right(),
                                                 hotspot.rect().center().y()))
              else:
                  return node.positionAt(loc_right, ofixedx, ofixedy)
  
          # return the left location
          elif olocation & loc_left and irect.right() < orect.left():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().left(),
                                                 hotspot.rect().center().y()))
              else:
                  return node.positionAt(loc_left, ofixedx, ofixedy)
  
          # return the bottom location
          elif olocation & loc_bot and orect.bottom() < irect.top():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                                 hotspot.rect().bottom()))
              else:
                  return node.positionAt(loc_bot, ofixedx, ofixedy)
  
          # return the top location
          elif olocation & loc_top and irect.bottom() < orect.top():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                                 hotspot.rect().top()))
              else:
                  return node.positionAt(loc_top, ofixedx, ofixedy)
  
          # return the center point
          else:
              if hotspot:
                  return node.mapToScene(hotspot.rect().center())
              else:
                  return node.positionAt(olocation, ofixedx, ofixedy)