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>

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)