HYTOS

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

from EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringStreamlineItem(QGraphicsPathItem, QEngineeringAbstractItem):

    """ This is EngineeringStreamlineItem Class """

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

                    2018.05.25  Jeongwoo    Change self.pen's default color (red → blue)

    '''

    def __init__(self, uid=None, parent=None):

        import uuid

        from EngineeringStreamNoTextItem import QEngineeringStreamNoTextItem

        try:

            QGraphicsPathItem.__init__(self, parent)

            QEngineeringAbstractItem.__init__(self)

            self.setAcceptHoverEvents(True)

            self.setAcceptTouchEvents(True)

            self._vertices = []

            self.isCreated = False

            self._pt = None

            self._stream_no = 0

            self._stream_no_text = None

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

    def __repr__(self):

        self._stream_no = value

        self._stream_no_text = QEngineeringStreamNoTextItem('<{}>'.format(self._stream_no), self)

    @property

    def data(self):

        """ return hmb data"""

        """

        from SymbolSvgItem import SymbolSvgItem

        targets = []

        index = 0

            if pointsUids:

            connector.setPos(vertex)

            connector.setParentItem(self)

            connector.sceneConnectPoint = vertex

            # add connector move ables

            connector.setAcceptTouchEvents(True)

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

        dx = end[0] - start[0]

        dy = end[1] - start[1]

        if length == 0: return

        perpendicular = (-_dir[1], _dir[0])

        polygon = QPolygonF()

        polygon.append(QPointF(end[0], end[1]))

        polygon.append(polygon[0])  # close polygon

    '''

        @brief  construct a polyline

    '''

    def process(self, param):

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

            self._vertices.append(param[2])

    '''

        @brief  clone an object

    '''

    def clone(self):

        clone = QEngineeringStreamlineItem()

        clone._vertices = copy.deepcopy(self._vertices)

        clone.isCreated = self.isCreated

        return clone

    def init(self):

        self._vertices = []

        self._pt = None

        self.isCreated = False

    '''

        @build  build path

        @author humkyung

        @date   2018.04.23

    '''

    '''

        @author     humkyung

        @date       2018.07.23

    '''

    def boundingRect(self):

        rect = QRectF()

        if self.isCreated:

            rect = self.path().boundingRect()

            rect = QRectF(rect.left() - 5, rect.top() - 5, rect.width() + 10, rect.height() + 10)

                    minX = pt[0]

                if minY is None or pt[1] < minY:

                    minY = pt[1]

                if maxX is None or pt[0] > maxX:

                    maxX = pt[0]

                if maxY is None or pt[1] > maxY:

                    maxY = pt[1]

            if self._pt is not None:

                if minX is None or self._pt[0] < minX:

                    minX = self._pt[0]

                if minY is None or self._pt[1] < minY:

                    minY = self._pt[1]

                if maxX is None or self._pt[0] > maxX:

                    maxX = self._pt[0]

                if maxY is None or self._pt[1] > maxY:

            if minX is not None and minY is not None and maxX is not None and maxY is not None:

                rect = QRectF(minX - 5, minY - 5, maxX - minX + 10, maxY - minY + 10)

        return rect

    '''

        @author     humkyung

        @date       2018.07.26

    '''

    def onMouseMoved(self, event, scenePos):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringConnectorItem import QEngineeringConnectorItem

        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[-1][0], self._vertices[-1][1] + dy))

        self._vertices.append(pt)

        self.update()

    def hoverEnterEvent(self, event):

        """ hilight item and it's children """

        self.highlight(True)

        self.highlight(False)

    def highlight(self, flag):

        self.update()

    def paint(self, painter, option, widget):

            color = self.getColor()

            self.setColor(color)

            QGraphicsPathItem.paint(self, painter, option, widget)

    '''

        @brief      Return real item position

        @authro     Jeongwoo

        @date       2018.05.29

    '''

    def boundingRectOnScene(self):

        rect = self.boundingRect()

        sp = self.startPoint()

        @history    2018.05.11  Jeongwoo    Add self.setPen() Method

        @history    humkyung 2018.05.13 call setPen method to apply changed color

    '''

    def setColor(self, color):

        c = QColor()

        c.setNamedColor(color)

    def on_symbol_pos_changed(self, symbol):

        """ rebuild stream line because symbol position is changed """

        self.on_connector_pos_changed(None)

    def on_connector_pos_changed(self, connector):

        self._vertices.append(self.connectors[0].center())

        dx = self.connectors[-1].center()[0] - self._vertices[0][0]

        dy = self.connectors[-1].center()[1] - self._vertices[0][1]

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

        self._vertices.append(self.connectors[-1].center())

        self.update_arrow()

        self.update()

    def mouseDoubleClickEvent(self, event):

        from StreamDataDialog import QStreamDataDialog

        dialog = QStreamDataDialog()

        res = dialog.showDialog(self)

        if res == True:

            self.load_HMB()

        App.mainWnd().load_HMB()

    def keyPressEvent(self, event):

        from App import App

        from AppDocData import AppDocData

        if not self.isSelected(): return

            self.transfer.onRemoved.emit(self)

        elif event.key() == Qt.Key_QuoteLeft:

    def toSql(self):

        """ convert valve data to sql query """

        import uuid

        uid = self.uid

        cols = ['UID', 'Symbols_UID', 'Name']

        param = [str(uid), str(dbUid), str(self.stream_no)]

        sql = 'insert or replace into Components({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

        # save vertices to database

        index = 1

            if index == 1 and self.connectors[0].connectedItem is not None:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y', 'ConnectedItem_UID']

                values = ['?', '?', '?', '?', '?', '?']

            elif index == 4 and self.connectors[1].connectedItem is not None:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y', 'ConnectedItem_UID']

                values = ['?', '?', '?', '?', '?', '?']

            else:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y']

                values = ['?', '?', '?', '?', '?']

                param = [str(uuid.uuid4()), str(uid), index, vertex[0], vertex[1]]

            sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

            res.append((sql, tuple(param)))

            index += 1

        # up to here

        return res

    def fromDatabase(componentInfos):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from AppDocData import AppDocData

        try:

            app_doc_data = AppDocData.instance()

            item = QEngineeringStreamlineItem(uid)

            hmb_data = app_doc_data.activeDrawing.hmbTable.get_hmb_data(uid)

            pointsUids = []

                pointsUids.append(pointsUid)

                item._vertices.append((x, y))

            connectorItems = [componentInfos[0][15], componentInfos[-1][15]]

            item.setVisible(False)

            item.build_connectors(connectorItems, pointsUids)

            item.update()

        except Exception as ex:

            from AppDocData import MessageType

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

        return item

    @author     Jeongwoo

    @date       2018.06.18

'''

class Transfer(QObject):

    onRemoved = pyqtSignal(QGraphicsItem)