Returns a scene space point that the connection \
        will draw to as its input target.  If the connection \
        has a node defined, then it will calculate the input \
        point based on the position of the node, factoring in \
        preference for input location and fixed information. \
        If there is no node connected, then the point defined \
        using the setInputPoint method will be used.
        
        :return     <QPointF>

def inputPoint(self):
        """
        Returns a scene space point that the connection \
        will draw to as its input target.  If the connection \
        has a node defined, then it will calculate the input \
        point based on the position of the node, factoring in \
        preference for input location and fixed information. \
        If there is no node connected, then the point defined \
        using the setInputPoint method will be used.
        
        :return     <QPointF>
        """
        node = self.inputNode()

        # return the set point
        if not node:
            return self._inputPoint

        # test for the hotspot
        hotspot = self.inputHotspot()

        # otherwise, calculate the point based on location and fixed info
        ilocation = self.inputLocation()
        ifixedx = self.inputFixedX()
        ifixedy = self.inputFixedY()

        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 left location
        if ilocation & loc_left and orect.right() < irect.left():
            if hotspot:
                return node.mapToScene(QPointF(hotspot.rect().left(),
                                               hotspot.rect().center().y()))
            else:
                return node.positionAt(loc_left, ifixedx, ifixedy)

        # return the right location
        elif ilocation & loc_right and irect.left() < orect.right():
            if hotspot:
                return node.mapToScene(QPointF(hotspot.rect().right(),
                                               hotspot.rect().center().y()))
            else:
                return node.positionAt(loc_right, ifixedx, ifixedy)

        # return the top location
        elif ilocation & loc_top and orect.bottom() < irect.top():
            if hotspot:
                return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                               hotspot.rect().top()))
            else:
                return node.positionAt(loc_top, ifixedx, ifixedy)

        # return the bottom location
        elif ilocation & loc_bot and irect.bottom() < orect.top():
            if hotspot:
                return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                               hotspot.rect().bottom()))
            else:
                return node.positionAt(loc_bot, ifixedx, ifixedy)

        # return the center location
        else:
            if hotspot:
                return node.mapToScene(hotspot.rect().center())
            else:
                return node.positionAt(ilocation, ifixedx, ifixedy)