HYTOS

            #print('main : ' + str(event.key()))

            elif event.key() == Qt.Key_M:  # merge text, line

                from EngineeringConnectorItem import QEngineeringConnectorItem

                from LineDetector import LineDetector

                # line merge

                lineItems = [line for line in self.graphicsView.scene().selectedItems() if

                             issubclass(type(line), QEngineeringLineItem)]

                lineValidation = True

                if len(lineItems) > 1:

                    x = []

                    y = []

                    connectedItems = []

                    isVertical = None

                    for line in lineItems:

                        if isVertical == None:

                            isVertical = line.isVertical()

                        elif isVertical != line.isVertical():

                            lineValidation = False

                        x.append(line.start_point()[0])

                        y.append(line.start_point()[1])

                        x.append(line.end_point()[0])

                        y.append(line.end_point()[1])

                        if line.connectors[0].connectedItem:

                            connectedItems.append(line.connectors[0].connectedItem)

                        if line.connectors[1].connectedItem:

                            connectedItems.append(line.connectors[1].connectedItem)

                    if lineValidation:

                        startPoint = [min(x), min(y)]

                        endPoint = [max(x), max(y)]

                        lineItem = QEngineeringLineItem(vertices=[startPoint, endPoint])

                        lineItem.transfer.onRemoved.connect(self.itemRemoved)

                        lineItem.lineType = lineItems[0].lineType

                        for line in lineItems:

                            line.transfer.onRemoved.emit(line)

                        detector = LineDetector(None)

                        for pt in [startPoint, endPoint]:

                            selected = [item for item in self.graphicsView.scene().items(QPointF(pt[0], pt[1])) if

                                        type(item) is QEngineeringConnectorItem or type(item) is QEngineeringLineItem]

                            if selected:

                                if type(selected[0]) is QEngineeringConnectorItem and selected[0].parent in connectedItems:

                                    lineItem.connect_if_possible(selected[0].parent, 5)

                                else:

                                    detector.connectLineToLine(selected[0], lineItem, 5)

                        self.graphicsView.scene().addItem(lineItem)

                # up to here

                # text merge

                if len(textItems) > 1:

                    angle = None

                    for item in textItems:

                        if angle is None:

                            angle = item.angle

                        else:

                            if angle != item.angle:

                                return

                    modifiers = QApplication.keyboardModifiers()

                    enter_or_space = ' ' if modifiers == Qt.ControlModifier else '\n'

                    x_or_y = 0 if (modifiers == Qt.ControlModifier and angle == 0) or (modifiers != Qt.ControlModifier and angle == 1.57) else 1

                    textItems = sorted(textItems, key=lambda text: text.loc[x_or_y]) if textItems[0].angle == 0 else ( \

                        sorted(textItems, key=lambda text: text.loc[x_or_y]) if textItems[0].angle == 1.57 else ( \

                            sorted(textItems, key=lambda text: text.loc[x_or_y], reverse=True) if textItems[0].angle == 4.71 else \

                                sorted(textItems, key=lambda text: text.loc[x_or_y], reverse=True)))

                    if textItems[0].angle == 1.57 and modifiers == Qt.ControlModifier:

                        textItems.reverse()

                    minX = sys.maxsize

                    minY = sys.maxsize

                    maxX = 0

                    maxY = 0

                    newText = ''

                    for text in textItems:

                        if text.loc[0] < minX: minX = text.loc[0]

                        if text.loc[1] < minY: minY = text.loc[1]

                        if text.loc[0] + text.size[0] > maxX: maxX = text.loc[0] + text.size[0]

                        if text.loc[1] + text.size[1] > maxY: maxY = text.loc[1] + text.size[1]

                        newText = newText + text.text() + enter_or_space

                        text.transfer.onRemoved.emit(text)

                    newText = newText[:-1]

                    textInfo = TextInfo(newText, minX, minY, maxX - minX, maxY - minY, textItems[0].angle)

                    x = textInfo.getX()

                    y = textInfo.getY()

                    angle = textInfo.getAngle()

                    text = textInfo.getText()

                    width = textInfo.getW()

                    height = textInfo.getH()

                    item = TextItemFactory.instance().createTextItem(textInfo)

                    if item is not None:

                        item.loc = [x, y]

                        item.size = (width, height)

                        item.angle = angle

                        item.area = textItems[0].area

                        item.setDefaultTextColor(Qt.blue)

                        item.addTextItemToScene(self.graphicsView.scene())

                        item.transfer.onRemoved.connect(self.itemRemoved)

                # up to here

                if len(symbolItems) is not 1:

            #print('view : ' + str(event.key()))

            #print('scene : ' + str(event.key()))

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

            from App import App

            App.mainWnd().keyPressEvent(event)

        #print('item :' + str(event.key()))

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

            from App import App

            App.mainWnd().keyPressEvent(event)