HYTOS

    def saveSymbolAttributes(self, type, attrs, type_str):

        from CodeTables import CodeTable

            try:

                # Get a cursor object

                cursor = conn.cursor()

        try:

            if not self.isCopy:

                    self.imageViewer.setDragMode(QGraphicsView.ScrollHandDrag)

                    QGraphicsView.mousePressEvent(self.imageViewer, QMouseEvent(QEvent.MouseButtonPress, event.pos(), Qt.LeftButton, event.buttons(), Qt.NoModifier))

                    try:

                        self.imageViewer.setDragMode(QGraphicsView.NoDrag)

                    finally:

'''

'''

class Worker(QObject):

    """ This is Worker class """

    from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout, QListWidget

        @author humkyung

        @date   2018.06.17

    '''

        from LineNoTracer import connectAttrImpl

        try:

            connectAttrImpl(self, self._update_line_type, self._update_flow_mark, self._update_spec)

        except Exception as ex:

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

class QConnectAttrDialog(QDialog):

    """ This is connect attr dialog class """

        import ConnectAttr_UI

        QDialog.__init__(self, parent)

        self.ui.setupUi(self)

        self.ui.pushButtonStart.setFocus()

        self.ui.buttonBox.setEnabled(True)

        self.isRunned = False

        self.ui.pushButtonStart.clicked.connect(self.connStart)

    def connStart(self):

        self.ui.buttonBox.setEnabled(False)

        self.ui.pushButtonStart.setEnabled(False)

        self.ui.progressBar.setValue(0)

        @author     Jeongwoo

        @date       18.04.12

    '''

    def rowInserted(self, item):

        self.ui.listWidget.scrollToBottom()

        @author humkyung

        @date   2018.06.17

    '''

    def addListItem(self, msg):

        self.ui.listWidget.addItem(msg)

        @date       2018.06.17

        @history    humkyung 2018.06.27 reset value if maxValue is -1

    '''

    def updateProgress(self, maxValue):

        if maxValue != -1:

            self.ui.progressBar.setMaximum(maxValue)

        @author humkyung

        @date   2018.06.17

    '''

    def startThread(self):

        import timeit

            self.ui.buttonBox.setDisabled(True)

            # 1 - create Worker and Thread inside the Form

            self.thread = QThread()

            # 2 - Move the Worker object to the Thread object

            self.tmStart = timeit.default_timer()

        except Exception as ex:

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

        finally:

            pass

        @history    humkyung 2018.06.17 add flow mark for pipe run

                    humkyung 2018.08.16 don't update line type according to connected items

    '''

    def dlgExit(self):

        import timeit

        try:

            self.ui.progressBar.setValue(self.ui.progressBar.maximum())

        except Exception as ex:

            from App import App

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

        finally:

            seconds = self.tmStop - self.tmStart

            elif item is None:

                self.setRowCount(0)

        except Exception as ex:

            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)

        self.setRowCount(13)

        self.verticalHeader().hide()

        self.horizontalHeader().setStretchLastSection(True)

    '''

        @brief      Slot to accept item click event

        @author     Jeongwoo

            self.lineNoChanged(item)

        finally:

            self.blockSignals(False)

    '''

        @brief      Reset table with new SymbolSvgItem

        @author     Jeongwoo

                self._areaComboBox.tag = widgetItem

                self._areaComboBox.addItem('None')

                title_list = []

                for area in area_list + title_list:

                    self._areaComboBox.addItem(area.name)

                self.setCellWidget(4, 3, self._areaComboBox)

                    item.setFlags(Qt.ItemIsEnabled)

                    #item.setBackground(Qt.lightGray)

        except Exception as ex:

            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)

                            self.setItem(row, 3, value_item)

                    checkbox.state_changed(checkbox.isChecked())

                    row = row + 1

                except Exception as ex:

                    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)

                    row = row + 1

                except Exception as ex:

                        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)

            connector_item = QTableWidgetItem('{}'.format('None' if connector.connectedItem is None else str(connector.connectedItem)))

            connector_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

            self.setItem(row, 3, connector_item)

            row = row + 1

            count = count + 1

                if type(self._item) is QEngineeringSpecBreakItem:

                    self.show_item_properties(self._item)

                for index in range(self.rowCount()):

                    item = self.item(index, 3)

                    if item is not None: item.setToolTip(item.text())

                self.show_item_connectors(self._item)

            else:

                self.setRowCount(0)

        except Exception as ex:

            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)

                    self._item.attrs[index] = (self._item.attrs[index][0], text)

                    find = True

                    break

            if not find:

                self._item.attrs.append(('Up Stream', text))

                    self._item.attrs[index] = (self._item.attrs[index][0], text)

                    find = True

                    break

            if not find:

                self._item.attrs.append(('Down Stream', text))

        self.setItem(0, 3, item)

        self.show_item_properties(lineNoItem)

        row = self.rowCount()

        attrs = lineNoItem.getAttributes()

        self.setRowCount(row + len(attrs))

                    if keyStr[0].UID in configs: valueCell.setFlags(Qt.ItemIsEnabled)

                else:

                    valueCell.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

                if key.Attribute.upper() == 'STREAM_NO':

                    self.streamNoComboBox = QComboBox()

                    self.streamNoComboBox.tag = key

                    self.streamNoComboBox.currentIndexChanged.connect(self.onStreamNoChanged)

                    streamNos = sorted(list(appDocData.hmbTable.streamNos()))

                    for streamNo in streamNos:

                        self.streamNoComboBox.addItem(streamNo)

                    cmd = SelectAttributeCommand.SelectAttributeCommand(items[0], attr, self.mainWindow.graphicsView)

                    cmd.onSuccess.connect(self.onSuccessSelectAttribute)

                    self.mainWindow.graphicsView.command = cmd

                    self.editItem(self.item(row, column))

            elif keyCell.text() == 'CONN' and type(items[0]) is QEngineeringLineNoTextItem:

                # unused code

                    direction = connector.dir()

                    if direction is None:

                        # calculate direction of connector

                    else:

                        dx, dy = direction[0], direction[1]

                    # up to here

                        if abs(dx) < 0.1:  # vertical line

                            dir = [0, 1 if dy > 0 else -1]

                            pt, thickness = self.adjust_start_point(pt, dir)

                            if thickness != -1:

                                pool.append([dir, pt, thickness, True if not pool else False])

                        elif abs(dy) < 0.1:  # horizontal line

                            dir = [1 if dx > 0 else -1, 0]

                            pt, thickness = self.adjust_start_point(pt, dir)

                            if thickness != -1:

                                pool.append([dir, pt, thickness, True if not pool else False])

    def connectLineToSymbol(self, line, symbol, toler):

        startPt = list(line.startPoint())

                     symbol.connectors]

        distStart.sort()

        endPt = list(line.endPoint())

                   symbol.connectors]

        distEnd.sort()

        (type1, value, traceback) = sys.exc_info()

        sys.excepthook(type1, value, traceback)

    finally:

        worker.finished.emit()

        #   Qt.ScrollBarAsNeeded: Shows a scroll bar only when zoomed.

        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        # Stack of QRectF zoom boxes in scene coordinates.

        self.zoomStack = []

                if QT_VERSION_STR[0] == '4':

                    file_path = QFileDialog.getOpenFileName(self, "Open image file",

                                                            app_doc_data.project.getDrawingFilePath(),

                elif QT_VERSION_STR[0] == '5':

                    file_path, _ = QFileDialog.getOpenFileName(self, "Open image file",

                                                               app_doc_data.project.getDrawingFilePath(),

                _bytes = None

                with open(file_path.encode('utf-8'), 'rb') as stream:

                    self.fitInView(self.zoomStack[-1], Qt.KeepAspectRatio)  # Show zoomed rect (ignore aspect ratio).

            else:

                self.zoomStack = []  # Clear the zoom stack (in case we got here because of an invalid zoom).

    def zoomImageInit(self):

        if self.hasImage():

                self.command.execute(['mouseMoveEvent', event, scenePos])

                if self.command.name == "SelectAttribute":

                    QGraphicsView.mouseMoveEvent(self, event)

        except Exception as ex:

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

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

            if self.command is not None:

                scenePos = self.mapToScene(event.pos())

                self.command.execute(['mousePressEvent', event, scenePos])

        except Exception as ex:

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

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

        strConnPts = symbol.getConnectionPoint()

        if strConnPts is not None and strConnPts != '':

            connPts = [(float(x.split(',')[0]), float(x.split(',')[1])) if len(x.split(',')) == 2 else (

                       for x in strConnPts.split('/')]

        svg.buildItem(svg_file_name, symbol.getType(), 0, None, None, None, connPts, symbol.getBaseSymbol(),

            arr = np.array(ptr).reshape(height, width, 4)  # Copies the data

            return arr

        except Exception as ex:

if __name__ == '__main__':

    @staticmethod

    def executeRecognition(createDetectedItems, path, listWidget, isLineChecked, worker, batch, createUnknownItems):

        """

        @author     Jeongwoo

        @date

        @history    humkyung 2018.04.06 change error display from message box to print

                                   round(noteArea.x):round(noteArea.x + noteArea.width)].copy()

                    cv2.rectangle(app_doc_data.imgSrc, (round(noteArea.x), round(noteArea.y)),

                                  (round(noteArea.x + noteArea.width), round(noteArea.y + noteArea.height)), 255, -1)

                # up to here

                area = app_doc_data.getArea('Drawing')

                        worker.updateBatchProgress.emit(len(srcList), 4)

                        continue

                    searchedTextSymList = []

                    for sym in searchedSymbolList:

                else:

                    '''

                    import math

                # draw contour with white color

                roiItem = cv2.drawContours(roiItem, selected_contours, -1, (255, 255, 255), -1)

            # try to recognize symbol twice(first one is normal, second on is flipped)

            steps = [False, True] if detectFlip else [False]

        sh = sym.getHeight()

        angle = sym.getRotatedAngle()

        # get symbol image

        if sym.getDetectFlip() is 1:

        for i in range(angle // 90):

        # up to here

        threadLock.acquire()

        temp = imgSrc[sp[1]:sp[1] + sh, sp[0]:sp[0] + sw]

        imgXOR = cv2.bitwise_xor(temp, mask)

        imgSrc[sp[1]:sp[1] + sh, sp[0]:sp[0] + sw] = cv2.bitwise_not(imgXOR)

        threadLock.release()

        self._spec_break = None

        self._connectedItem = None

        self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT  # default value is connected at pt

        self.connectPoint = None

        self._hoverItem = None

        self._label.setPlainText(value)

    @property

    def connectedItem(self):

        """ getter of connectedItem """

        import uuid

        return None

    def __repr__(self):

    '''

        @brief  build connector item

            self.setZValue(self.parent.zValue() + 1)

    '''

        @brief  set position of connector

        @author humkyung

        @date   2018.05.02

        self._loc = [pos[0], pos[1]]

        self.setRect(self._loc[0] - round(self.SMALL_SIZE * 0.5), self._loc[1] - round(self.SMALL_SIZE * 0.5),

                     self.SMALL_SIZE, self.SMALL_SIZE)

        self.update()

        self._label.setPos(QPointF(self._loc[0], self._loc[1]))

    def connect(self, item, at=QEngineeringAbstractItem.CONNECTED_AT_PT):

        import uuid

        try:

            connectedItemStr = record['Connected']

            connectPointStr = [record['X'], record['Y']]

            sceneConnectPointStr = [record['X'], record['Y']]

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

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

        except Exception as ex:

            self._connectedItem = uuid.UUID(connectedItemStr) if connectedItemStr != 'None' else None

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

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

        except Exception as ex:

            center = self.boundingRect().center()

            connectPointNode.text = str(center.x()) + ',' + str(center.y())

            sceneConnectPointNode = Element('SCENECONNECTPOINT')

            sceneConnectPointNode.text = str(center[0]) + ',' + str(center[1])

            node.append(connectedItemNode)

        cols = ['Components_UID', '[Index]', 'X', 'Y', 'Connected', 'Connected_At']

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

        param = [  # str(self.uid),

            str(self.connectedItem.uid) if self.connectedItem else None, \

            str(self._connected_at)]

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

        return (sql, tuple(param))

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

                    connector.setPos(vertex)

                    connector.setParentItem(self)

                    connector.connectPoint = vertex

                    # add connector move able

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

                        break

        else:

            if len(item.connectors) == 2:

                # startPoint와 같은 connPts 찾음

                if startPoint[0] == connector1Point[0] and startPoint[1] == connector1Point[1]:

        try:

            if issubclass(type(obj), SymbolSvgItem):

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

                        if self.connectors[0].connectedItem is None and obj.connectors[i].connectedItem is None:

                            self.connectors[0].connect(obj)

                            obj.connectors[i].connect(self)

                            # line, start, end

                            res.append(obj)

                            res.append(endPt)

                        if self.connectors[1].connectedItem is None and obj.connectors[i].connectedItem is None:

                            self.connectors[1].connect(obj)

                            obj.connectors[i].connect(self)

                            # line, start, end

                            res.append(obj)

                            res.append(startPt)

            elif type(obj) is QEngineeringLineItem:

                _startPt = obj.startPoint()

                _endPt = obj.endPoint()

                rotatedPt = affinity.rotate(Point(symbol.connectors[i].connectPoint[0] - symbol.symbolOrigin[0],

                                                  symbol.connectors[i].connectPoint[1] - symbol.symbolOrigin[1]),

                                            -angle, Point(0, 0), use_radians=True)

            length1 = math.sqrt(dx1 * dx1 + dy1 * dy1)

            length2 = math.sqrt(dx2 * dx2 + dy2 * dy2)

            if length1 < length2:

                processLine.connectors[0].connectedItem = symbol

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

                self.setLine(line)

                self.connectors[1].connectedItem = symbol

                symbol.connectors[0].connectedItem = self

                symbol.connectors[1].connectedItem = processLine

            else:

                processLine.connectors[0].connectedItem = symbol

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

                self.setLine(line)

                self.connectors[1].connectedItem = symbol

                    item.connectors[iterIndex].parse_record(connector)

                    iterIndex += 1

            associations = app_doc_data.get_component_associations(uid)

            if associations:

                for assoc in associations:

                    item.connectors[iterIndex].parse_xml(connector)

                    iterIndex += 1

            attributeValue = node.find('ASSOCIATIONS')

            if attributeValue is not None:

                for assoc in attributeValue.iter('ASSOCIATION'):

        index = 1

        for connector in self.connectors:

            params.append((  # str(connector.uid),

                str(connector.connectedItem.uid) if connector.connectedItem else None, \

                str(connector._connected_at)))

            index += 1

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

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

                startPoint = line.endPoint()

                for index in range(30):

            connector.setPos((point.x(), point.y()))

            connector.setParentItem(self)

            connector.connectPoint = (point.x(), point.y())

            connector.setZValue(QEngineeringVendorItem.ZVALUE)

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

            connector.setAcceptTouchEvents(True)

                connector.setPos((x, y))

                connector.setParentItem(self)

                connector.connectPoint = (x, y)

                connector.setZValue(QEngineeringVendorItem.ZVALUE)

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

                connector.setAcceptTouchEvents(True)

        if not self.scene(): return super().itemChange(change, value)

        if change == QGraphicsItem.ItemPositionHasChanged or change == QGraphicsItem.ItemRotationChange:

            from EngineeringLineItem import QEngineeringLineItem

            for connector in self.connectors:

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

            for connector in self.connectors:

                params.append( \

                    (  # str(connector.uid),

                        str(connector.connectedItem.uid) if connector.connectedItem else None, \

                        str(connector._connected_at)) \

                    )

        from SpecialItemTypesDialog import SpecialItemTypes

        try:

            self.name = name

            self.type = _type

            self.angle = angle

            self.size = size if size else [0, 0]

            self.origin = origin

            if dbUid is None:

            else:

            self.dbUid = symbolInfo.uid

            self.iType = symbolInfo.iType

            originalPoint = symbolInfo.getOriginalPoint().split(',')

                    x = float(tokens[0])

                    y = float(tokens[1])

                elif len(tokens) >= 3:

                    x = float(tokens[1])

                    y = float(tokens[2])

                if len(tokens) >= 4:

                self.connectors[index].symbol_idx = symbol_idx

                self.connectors[index].setPos((x, y))

                self.connectors[index].connectPoint = (x, y)

                    len(connPts[index]) == 2 else (connPts[index][1], connPts[index][2]) if \

                    len(connPts[index]) == 3 else (connPts[index][1], connPts[index][2]) if \

                    len(connPts[index]) == 4 else None

            self.parentSymbol = parentSymbol

            self.childSymbol = childSymbol

            self.hasInstrumentLabel = hasInstrumentLabel

        '''

        for connector in self.connectors:

            for iConnector in item.connectors:

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

        return False

                startPt = obj.startPoint()

                endPt = obj.endPoint()

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

                        if self.connectors[i].connectedItem is None and obj.connectors[0].connectedItem is None:

                            self.connectors[i].connect(obj)

                            obj.connectors[0].connect(self)

                            # line, start, end

                            res.append(obj)

                            res.append(endPt)

                        if self.connectors[i].connectedItem is None and obj.connectors[1].connectedItem is None:

                            self.connectors[i].connect(obj)

                            obj.connectors[1].connect(self)

                            # line, start, end

                            res.append(obj)

                            res.append(startPt)

            elif issubclass(type(obj), SymbolSvgItem):

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

                    if i > 3: break

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

                        if j > 3: break

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

                                self.connectors[i].connect(obj)

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

        import math

        for connector in self.connectors:

        return None

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

            ratio = float(configs[0].value) if 1 == len(configs) else 1.5

            dist = max(self.sceneBoundingRect().height(), self.sceneBoundingRect().width()) * ratio

            center = self.sceneBoundingRect().center()

            minDist = None

            selected = None

            for attr in attributes:

                if False:  # type(attr) is QEngineeringSizeTextItem or type(attr) is QEngineeringValveOperCodeTextItem:

                    dx = attr.center().x() - center.x()

                    dy = attr.center().y() - center.y()

                        if math.sqrt(dx * dx + dy * dy) < dist:

                            if self.add_assoc_item(attr):

                                attr.owner = self

            if selected is not None:

                if self.add_assoc_item(selected):

        self.rotate(self.getCurrentPoint(), self.angle)

        scene.addItem(self)

        self.size[0], self.size[1] = round(self.sceneBoundingRect().width()), round(self.sceneBoundingRect().height())

    '''

        @brief      

            self.connectors[1].connectedItem = conn1Item

            currentPoint = self.getCurrentPoint()

    '''

        @brief      change standard point

            self.currentPointModeIndex = 0

        currentPoint = self.getCurrentPoint()

    '''

        @brief      get standard point

import SymbolAttrEditor_UI

class QSymbolAttrEditorDialog(QDialog):

    """ This is symbol attribute editor dialog class """

    LINE_NO_ATTR_TYPES = ['Code Table', 'Int', 'String', 'Symbol']

        QDialog.__init__(self, parent)

        self.ui = SymbolAttrEditor_UI.Ui_SymbolAttrEditorDialog()

    def cell_double_clicked(self, row, column):

        if self._symbolType is None or not (column is 6 or column is 7): return

        from SymbolAttrTargetDialog import SymbolAttrTargetDialog

        from SymbolAttrCodeTableDialog import SymbolAttrCodeTableDialog

        from App import App

        try:

            # code table setting

            if column == 7:

                (isAccept, code_data) = dialog.showDialog()

                if isAccept:

                    self.ui.tableWidgetAttr.item(row, 7).tag = code_data

                dialog = SymbolAttrTargetDialog(self, symbolType, self.ui.tableWidgetAttr.item(row, 6).tag)

                (isAccept, target) = dialog.showDialog()

                if isAccept:

                    self.ui.tableWidgetAttr.item(row, 6).tag = target

                    if target == 'ALL':

            from App import App

            from AppDocData import MessageType

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

    '''

        @author     kyouho

        @date       2018.08.16

    '''

    def settingComboBoxSymbolType(self, selectedType):

        docData = AppDocData.instance()

        comboBox = self.ui.comboBoxSymbolType

        @author     kyouho

        @date       2018.08.16

    '''

    def changeSymbolType(self):

        self._symbolType = self.ui.comboBoxSymbolType.currentText()

        self.ui.tableWidgetAttr.setRowCount(0)

        """

        appDocData = AppDocData.instance()

        self.currentTypeId = appDocData.getSymbolTypeId(symbolType)

        attrs = appDocData.getSymbolAttribute(symbolType)

        row = 0

        for attr in attrs:

            item.tag = attr

            self.ui.tableWidgetAttr.setItem(row, 0, item)

            if attr.IsProp >= 2:

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(Qt.lightGray)

            self.ui.tableWidgetAttr.setItem(row, 1, item)

            self.ui.tableWidgetAttr.setItem(row, 2, item)

            attrTypeComboBox = QComboBox()

                attrTypeComboBox.addItem(key)

                attrTypeComboBox.setEnabled(False)

                self.ui.tableWidgetAttr.setCellWidget(row, 3, attrTypeComboBox)

                attrTypeComboBox.setCurrentIndex(result)

            else:

                    item = QTableWidgetItem(attr.AttributeType)

                    item.setFlags(Qt.ItemIsEnabled)

                self.ui.tableWidgetAttr.setItem(row, 3, item)

            if attr.IsProp >= 2:

                item.setFlags(Qt.ItemIsEnabled)

            self.ui.tableWidgetAttr.setItem(row, 4, item)

            if attr.IsProp >= 2:

                item.setFlags(Qt.ItemIsEnabled)

            self.ui.tableWidgetAttr.setItem(row, 5, item)

    def saveData(self):

        """save symbol attributes"""

        attrs = []

        table = self.ui.tableWidgetAttr

        for index in range(table.rowCount()):

            attr = []

            attr.append(table.item(index, 0).text() if table.item(index, 0) is not None else '')

            attr.append(table.item(index, 1).text() if table.item(index, 1) is not None else '')

            attr.append(table.item(index, 2).text() if table.item(index, 2) is not None else '')

            attr.append(index)

            attr.append(table.item(index, 0).tag.IsProp) if hasattr(table.item(index, 0), 'tag') else attr.append(0)

            attrs.append(attr)

    '''

        @brief  add a attribute

        @author humkyung

        @date   2018.08.13

    '''

    def onAddAttr(self):

        import uuid

        from SymbolAttr import SymbolAttr

        self.ui.tableWidgetAttr.setRowCount(rows + 1)

        attrTypeComboBox = QComboBox()

            attrTypeComboBox.addItem(key)

        self.ui.tableWidgetAttr.setCellWidget(rows, 3, attrTypeComboBox)

        @author humkyung

        @date   2018.08.13

    '''

    def onDelAttr(self):

        model = self.ui.tableWidgetAttr.model()

        row = self.ui.tableWidgetAttr.currentRow()

            model.removeRow(row)

    '''

        @author     humkyung

        @date       2018.08.13

    '''

    def accept(self):

        if self._symbolType is not None:

        else:

            self.saveLineAttrData()

        QDialog.accept(self)

    '''

        @author kyoyho

        @date   2018.08.21

    '''

    def settingLineNoAttributeTable(self):

        table = self.ui.tableWidgetAttr

        docData = AppDocData.instance()

            item = QTableWidgetItem(attr.UID if attr.UID is not None else '')

            self.ui.tableWidgetAttr.setItem(row, 0, item)

            item = QTableWidgetItem(attr.Attribute if attr.Attribute is not None else '')

            self.ui.tableWidgetAttr.setItem(row, 1, item)

            item = QTableWidgetItem(attr.DisplayAttribute if attr.DisplayAttribute is not None else '')

            self.ui.tableWidgetAttr.setItem(row, 2, item)

        @author kyoyho

        @date   2018.08.21

    '''

    def onAddLineNoAttr(self):

        rows = self.ui.tableWidgetAttr.rowCount()

        self.ui.tableWidgetAttr.setRowCount(rows + 1)

        attrTypeComboBox = QComboBox()

        for _type in QSymbolAttrEditorDialog.LINE_NO_ATTR_TYPES:

            attrTypeComboBox.addItem(_type)

        self.ui.tableWidgetAttr.setCellWidget(rows, 3, attrTypeComboBox)

        import uuid

        self.ui.tableWidgetAttr.setItem(rows, 0, QTableWidgetItem(str(uuid.uuid4())))

    '''

        @brief  delete selected attribute 

        @author kyoyho

        @date   2018.08.21

    '''

    def onDelLineNoAttr(self):

        model = self.ui.tableWidgetAttr.model()

        row = self.ui.tableWidgetAttr.currentRow()

        if row != -1:

            model.removeRow(row)

        @author     kyouho

        @date       2018.08.20

    '''

    def isNumber(self, num):

        p = re.compile('(^[0-9]+$)')

        result = p.match(num)

        @author     kyouho

        @date       2018.08.21

    '''

    def saveLineAttrData(self):

        appDocData = AppDocData.instance()

        attrs = []

        table = self.ui.tableWidgetAttr

        for index in range(table.rowCount()):

            attr = []

            attr.append(table.item(index, 0).text() if table.item(index, 0) is not None else '')

            attr.append(table.item(index, 1).text() if table.item(index, 1) is not None else '')

            attr.append(table.item(index, 2).text() if table.item(index, 2) is not None else '')

            attr.append(index)

            attrs.append(attr)