HYTOS

        event = param[1]

        if 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            selected = self.imageViewer.scene.itemAt(param[2], QTransform())

            if self._streamline is None:

                if selected is not None and (type(selected) is QEngineeringConnectorItem or type(

                        selected.parentItem()) is QEngineeringConnectorItem):

                    if selected.hasConnectedItem() == False:

                        self._streamline = QEngineeringStreamlineItem()

                        self._streamline._vertices.append(selected.center() if type(

                            selected) is QEngineeringConnectorItem else selected.parentItem().center())

                        self.imageViewer.scene.addItem(self._streamline)

                        self.imageViewer.scene.setFocusItem(self._streamline)

                        self.connectorItems.append(

                            selected if type(selected) is QEngineeringConnectorItem else selected.parentItem())

            else:

                try:

                            self._streamline._vertices[-1] = selected.center() if type(

                                selected) is QEngineeringConnectorItem else selected.parentItem().center()

                        else:

                            return

                    # QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    connectorItems = [conn.uid for conn in self.connectorItems]

                    self._streamline.build_connectors(connectorItems)

                    # self._streamline.build_connectors(self.connectorItems)

                    self._streamline.update()

                    self.onSuccess.emit()

                    self.connectorItems.clear()

                finally:

                    pass

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton:

            self.onRejected.emit(self)

        elif 'mouseMoveEvent' == param[0] and self._streamline is not None:

            self._streamline.onMouseMoved(event, param[2])

        elif 'keyPressEvent' == param[0]:

            if event.key() == Qt.Key_Escape:

                self.isTreated = False

            if hasattr(self, '_underItem') and self._underItem is not None:

                self._underItem.hoverLeaveEvent(event)

                self._underItem = None

        parent = self.parentItem()

        if type(parent) is SymbolSvgItem:

            if parent.category == 'Equipment - [ Pressurized ]':

                if self.connectedItem and \

                        (self.data is None or (self.data.pressure is None or self.data.elevation is None)):

                    res.extend([self, 'pressure or elevation is invalid'])

            elif parent.category == 'Equipment - [ Pressure Drop ]' or parent.type == 'Flowmeter':

                if self.connectedItem and \

                        (self.data is None or (self.data.pressure_drop is None or self.data.elevation is None)):

                    res.extend([self, 'pressure drop or elevation is invalid'])

            elif parent.category == 'Equipment - [ Rotating ]':

                if self.connectedItem and parent.name.upper() in ['L_KOMP', 'R_KOMP', 'R_PUMP', 'L_PUMP', 'V_PUMP']:

                elif self.connectedItem and parent.name.upper() in ['L_COMP', 'R_COMP']:

                    if self.data.pressure is None:

                        res.extend([self, 'need to check pressure'])

                    elif self.data.elevation is None:

                        res.extend([self, 'need to check elevation'])

                elif self.connectedItem and (self.data.pressure_drop is None or self.data.elevation is None):

                    res.extend([self, 'need to check pressure drop and elevation'])

            elif self.connectedItem and parent.name in ['CV_H', 'CV_V']:

                if self.data is None or self.data.elevation is None:

                    res.extend([self, 'need to check elevation'])

            elif parent.name == 'Line Splitter':  # set default value for line splitter

                if self.connectedItem:

                    if self.data.pressure_drop is None:

                        self.data.pressure_drop = 0

                    if self.data.elevation is None:

                        self.data.elevation = 0

        elif type(parent) is QEngineeringStreamlineItem:

            pass

        # update connector's color

        if self.connectedItem and type(self.parentItem()) is SymbolSvgItem:

            self.setBrush(Qt.red) if res else self.setBrush(Qt.yellow)

        else:

            self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)

        # up to here

    def findOwner(self, lines):

        import sys

        try:

            # find line onwer parallel

            self.onwer = None

            dist = min(self.sceneBoundingRect().height(), self.sceneBoundingRect().width()) * 2

            center = self.sceneBoundingRect().center()

            maxOverlap = 0

            minDist = sys.maxsize

            selected = None

            hLines = []

            vLines = []

            for line in lines:

                if line.sceneBoundingRect().height() > line.sceneBoundingRect().width():

                    vLines.append(line)

                else:

                    hLines.append(line)

            if self.sceneBoundingRect().height() > self.sceneBoundingRect().width():

                lines = vLines

            else:

                lines = hLines

            axisText = range(round(self.sceneBoundingRect().x()), round(

                self.sceneBoundingRect().x() + self.sceneBoundingRect().width())) if lines is hLines else range(

                round(self.sceneBoundingRect().y()),

                round(self.sceneBoundingRect().y() + self.sceneBoundingRect().height()))

            # print(axisText)

            for line in lines:

                intercept = line.sceneBoundingRect().center().y() if lines is hLines else line.sceneBoundingRect().center().x()

                length = abs(intercept - center.y()) if lines is hLines else abs(intercept - center.x())

                if (length < dist):

                    overlap = 0

                    axisLine = range(round(line.sceneBoundingRect().x()), round(

                        line.sceneBoundingRect().x() + line.sceneBoundingRect().width())) if lines is hLines else range(

                        round(line.sceneBoundingRect().y()),

                        round(line.sceneBoundingRect().y() + line.sceneBoundingRect().height()))

                    # print(axisLine)

                    for onLine in axisLine:

                        for onText in axisText:

                            if onLine - onText is 0:

                                overlap += 1

                    # print(overlap)

                    if overlap == maxOverlap and length < minDist:

                        selected = line

                        maxOverlap = overlap

                        minDist = length

                    elif overlap > maxOverlap:

                        selected = line

                        maxOverlap = overlap

                        minDist = length

            if selected is not None:

                self.owner = selected

                return

                # print(self.owner)

            ## up to here

            # fine line owner orthogonal

            if self.sceneBoundingRect().height() < self.sceneBoundingRect().width():

                lines = vLines

            else:

                lines = hLines

            minDist = 30

            for line in lines:

                if line.connectors[1].connectedItem is not None: continue

                dl = min(self.sceneBoundingRect().height(), self.sceneBoundingRect().width()) / 10

                dx = dl if (line.connectors[0].sceneConnectPoint[0] - line.connectors[1].sceneConnectPoint[

                    0]) > 0 else -dl

                dy = -dl if (line.connectors[0].sceneConnectPoint[1] - line.connectors[1].sceneConnectPoint[

                    1]) > 0 else dl

                startPoint = line.endPoint()

                for index in range(30):

                    point = (startPoint[0] + index * dx, startPoint[1] + index * dy)

                    if self.sceneBoundingRect().contains(point[0], point[1]):

                        if index < minDist:

                            minDist = index

                            selected = line

                            break

            if selected is not None:

                self.owner = selected

        except Exception as ex:

            from App import App 

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        painter.drawPolygon(self.create_poly(4, 7, 0))

        targets = []

        index = 0

        for vertex in [self._vertices[0], self._vertices[-1]]:

            if pointsUids:

                connector = QEngineeringConnectorItem(pointsUids[index], parent=self, index=index + 1)

            else:

                connector = QEngineeringConnectorItem(uid=None, parent=self, index=index + 1)

            connector.setPos(vertex)

            connector.connectPoint = vertex

            connector.sceneConnectPoint = vertex

            # add connector move ables

            connector.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable)

            connector.setAcceptTouchEvents(True)

            connector.transfer.onPosChanged.connect(self.on_connector_pos_changed)

            #connector.setZValue(self.zValue() + 1)

            self.connectors.append(connector)

            if len(connected) > index:

                connected_item_uid = connected[index]

                if connected_item_uid:

                    target = QEngineeringConnectorItem.find_connector(connected_item_uid)

                    connector.connect(target)

                    if target:

                        target.connect(connector)

                        targets.append(target)

            index = index + 1

        """ connect symbol's on_pos_changed signal """

        for symbol in [conn.parentItem() for conn in targets if type(conn.parentItem()) is SymbolSvgItem]:

            symbol.transfer.on_pos_changed.connect(self.on_symbol_pos_changed)

            symbol.transfer.on_size_changed.connect(self.on_symbol_pos_changed)

        # get connection point near by mouse point

        pt = (scenePos.x(), scenePos.y())

        item = self.scene().itemAt(scenePos, QTransform())

        if (item is not None) and (type(item) is SymbolSvgItem):

            connPt = item.getConnectionPointCloseTo(pt, 5)

            if connPt is not None: pt = connPt

        elif (item is not None) and (type(item) is QEngineeringConnectorItem):

            pt = item.center()

        # up to here

        del self._vertices[1:]

        dx = pt[0] - self._vertices[0][0]

        dy = pt[1] - self._vertices[0][1]

        self._vertices.append((self._vertices[0][0] + dx * 0.5, self._vertices[0][1]))

        self._vertices.append((self._vertices[-1][0], self._vertices[-1][1] + dy))

        self._vertices.append(pt)

        self.build_path()

        self.update()

    '''

        @brief      connect line and symbol is able to be connected and return line

        @author     humkyung

        @date       2018.04.16

        @history    humkyung 2018.05.08 check if symbol is possible to be connected

                    Jeongwoo 2018.05.15 Connect each symbol and line

    '''

    def connect_if_possible(self, obj, toler=10):

        from shapely.geometry import Point

        from EngineeringLineItem import QEngineeringLineItem

        res = []

        try:

            if type(obj) is QEngineeringLineItem:

                startPt = obj.startPoint()

                endPt = obj.endPoint()

                for i in range(len(self.connectors)):

                    if (Point(startPt[0], startPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0],

                                                                     self.connectors[i].sceneConnectPoint[1])) < toler):

                        if self.connectors[i].connectedItem is None:

                            self.connectors[i].connect(obj)

                        if obj.connectors[0].connectedItem is None:

                            obj.connectors[0].connect(self)

                        res.append(obj)

                    if (Point(endPt[0], endPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0],

                                                                 self.connectors[i].sceneConnectPoint[1])) < toler):

                        if self.connectors[i].connectedItem is None:

                            self.connectors[i].connect(obj)

                        if obj.connectors[1].connectedItem is None:

                            obj.connectors[1].connect(self)

                        res.append(obj)

            elif issubclass(type(obj), SymbolSvgItem):

                for i in range(len(self.connectors)):

                    for j in range(len(obj.connectors)):

                        _pt = Point(obj.connectors[j].sceneConnectPoint[0], obj.connectors[j].sceneConnectPoint[1])

                        if (_pt.distance(Point(self.connectors[i].sceneConnectPoint[0],

                                               self.connectors[i].sceneConnectPoint[1])) < toler):

                            if self.connectors[i].connectedItem is None:

                                self.connectors[i].connect(obj)

                            if obj.connectors[j].connectedItem is None:

                                obj.connectors[j].connect(self)

                            res.append(obj)

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return res

    '''

        @brief  get connection point close to given point in tolerance

        @author humkyung

        @dat

    '''

            dx = connector.sceneConnectPoint[0] - pt[0]

            dy = connector.sceneConnectPoint[1] - pt[1]

            if math.sqrt(dx * dx + dy * dy) < toler: return connPt

        @brief      rotate Symbol

        @author     kyouho

        @date       2018.07.24

    '''

    def rotateSymbol(self, angle=None):

        if angle is None:

            # degree 0

            if 0 == self.angle:

                self.angle = 1.57

            # degree 90

            elif 1.57 == self.angle:

                self.angle = 3.14

            # degree 180

            elif 3.14 == self.angle:

                self.angle = 4.71

            # degree 270

            elif 4.71 == self.angle:

                self.angle = 0

            else:

                self.angle = 0

            self.size[0], self.size[1] = self.size[1], self.size[0]

        else:

            self.angle = angle

        # scene = self.scene()

        # self.scene().removeItem(self)

        # self.addSvgItemToScene(scene)

        currentPoint = self.getCurrentPoint()

        self.reSettingSymbol(currentPoint, self.angle)

    '''

        @brief      resetting rotate Symbol

        @author     kyouho

        @date       2018.07.24

    '''

    def reSettingSymbol(self, standardPoint, angle):

        transform = QTransform()

        transform.translate(self.loc[0] + self.symbolOrigin[0], self.loc[1] + self.symbolOrigin[1])

        transform.rotateRadians(-angle)

        transform.translate(-standardPoint[0], -standardPoint[1])

        if self.flip is 1:

            transform.scale(-1.0, 1.0)

            transform.translate(-self.size[0], 0)

        self.setTransform(transform)

        self.reSettingConnetors()

    def reSettingConnetors(self):

        for conn in self.connectors:

            conn.sceneConnectPoint = (conn.sceneBoundingRect().center().x(), conn.sceneBoundingRect().center().y())

        from EngineeringLineItem import QEngineeringLineItem

        for connector in self.connectors:

            if connector.connectedItem is not None and type(connector.connectedItem) == QEngineeringLineItem:

                line = connector.connectedItem

                line.reDrawLine(self, connector.center())

                line.update_arrow()

    '''

        @brief      change Conn point 

        @author     kyouho

        @date       2018.07.25

    '''

    def changeConnPoint(self):

        if len(self.connectors) == 2:

            conn1Item = self.connectors[0].connectedItem

            conn2Item = self.connectors[1].connectedItem

            self.connectors[0].connectedItem = conn2Item

            self.connectors[1].connectedItem = conn1Item

            currentPoint = self.getCurrentPoint()

            self.reSettingSymbol(currentPoint, self.angle)

    '''

        @brief      change standard point

        @author     kyouho

        @date       2018.07.24

    '''

    def changeStandardPoint(self):

        connPtsCount = len(self.connectors)

        if self.currentPointModeIndex < connPtsCount:

            self.currentPointModeIndex += 1

        else:

            self.currentPointModeIndex = 0

        currentPoint = self.getCurrentPoint()

        self.reSettingSymbol(currentPoint, self.angle)

    '''