HYTOS

        self.ui.pushButtonStart.setEnabled(False)

        self.ui.progressBar.setValue(0)

        self.startThread()

    '''

        @brief      QListWidget Row Inserted Listener

        itemPosition = self.mapTo(self, position)

        item = self.itemAt(itemPosition)

        if item is not None:

                menu = QMenu()

                explode_action = QAction(self.tr("Explode"))

                menu.addAction(explode_action)

                menu.exec_(self.viewport().mapToGlobal(position))

    '''

        @brief      Pick Color for Line No

                for i in reversed(range(tree_widget_item.childCount())):

                    tree_widget_item.takeChild(i)

                line_run.explode()

                tree_widget_item.parent().takeChild(tree_widget_item.parent().indexOfChild(tree_widget_item))

        finally:

            pass

    def explode_line_no(self, lineNoTreeWidgetItem):

        """ explode line no """

        self.root.setIcon(0, QIcon(':newPrefix/objects.png'))

        self.root.setData(0, self.TREE_DATA_ROLE, appDocData.activeDrawing)

        child = self.root.addChild(QTreeWidgetItem(['LINE NO']))

        self.LineNoTreeItem = self.root.child(self.root.childCount() - 1)

        self.root.addChild(QTreeWidgetItem(['EQUIPMENTS']))

        self.EqpTreeItem = self.root.child(self.root.childCount() - 1)

        self.root.addChild(QTreeWidgetItem(['SYMBOLS']))

    def __init__(self, symbols, lines, lineNos, specBreak, lineIndicator, vendor):

        try:

            self._symbols = symbols

            self._lines = lines

            self._lineNos = lineNos

            self._spec_breaks = specBreak

            self._lineIndicator = lineIndicator

            self._vendor = vendor

                        self._specBreakUID.append(attr[1])

            """

        except Exception as ex:

    '''

        @brief  find primary lines connected to given line no

        @author humkyung

    '''

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

                item.owner = lineno # set item's owner

    '''

        @brief  find secondary lines

        @author humkyung

    '''

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

                    symbol_matches = [x for x in self._symbols if x.owner and line.is_connected(x)]

                    if line_matches or symbol_matches:

                        foundCount += 1

                    else:

                        notMatches.append(line)

                lines = notMatches

            if 1 == len(configs):

                configs = docData.getConfigs('Line No', 'Configuration')

                    minDist = None

                    startLine = None

                    for line in self._lines:

                            startLine = line

                    if (startLine is not None) and (minDist < toler):

                        lineno.conns.append(startLine)

                """

                ## lineIndicator

                ## up to here

                """

                maxValue = len(self._lineNos) + 1   ## line no's count + secondary line

                # find primary lines

                # find secondary lines

                lines = self._lines

            ### make trim lines

            """

                    docData.tracerLineNos.append(trimLineNo)

            """

        except Exception as ex:

            from App import App 

                    humkyung 2018.05.17 try to connect both symbol and line

                    humkyung 2018.06.22 order connected objects

    '''

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            pool = []

            while len(pool) > 0:

                sign, obj = pool.pop()

                if matches or issubclass(type(obj), QEngineeringEquipmentItem): continue

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.owner is None) and (x not in visited) and obj.is_connected(x)]

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif issubclass(type(item), SymbolSvgItem):

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

            elif type(item) is QEngineeringLineItem:

                lines.append(item)

            elif type(item) is QEngineeringUnknownItem and item.lineIndicator != 'False':

                lineIndicator.append(item)

            self.itemTreeWidget.InitLineNoItems()

            # construct line no item

                for connectedItem in connectedItems:

                    if issubclass(type(connectedItem), SymbolSvgItem): 

                        self.itemTreeWidget.addTreeItem(item, connectedItem)

        from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

        try:

            symbols = []

            xml = parse(xmlPath)

            maxValue = maxValue + len(list(root.iter('TRIM_LINE_NO')))

            self.progress.setMaximum(maxValue)

            for symbol in root.find('SYMBOLS').iter('SYMBOL'):

                item = SymbolSvgItem.fromXml(symbol)

                if item[0] is not None:

            # set symbol's owner

            childItems = [item for item in symbols if item[1] is not None]

            for item in childItems:

                if len(matches) == 1:

                    item[0].owner = matches[0][0]

            # up to here

            for item in symbols:

                self.addSvgItemToScene(item[0])

                docData.symbols.append(item[0])

            # parse texts

            for text in root.find('TEXTINFOS').iter('ATTRIBUTE'):

            QApplication.processEvents()

                connLine = line_no.find('CONNLINE')

                if connLine is not None:

                    lineUID = connLine.text

                    connLine = self.graphicsView.findItemByUid(lineUID)

                    if connLine is not None:

                        item.conns.append(connLine)

                        line_run = QEngineeringRunItem()

                            if uidElement is not None:

                                uid = uidElement.text

                                run_item = self.graphicsView.findItemByUid(uid)

                                if run_item is not None:

                                    run_item._owner = item

                                    line_run.items.append(run_item)

                        for connectedItem in line_run.items:

                            if issubclass(type(connectedItem), SymbolSvgItem): self.itemTreeWidget.addTreeItem(treeItem, connectedItem)

                    docData.tracerLineNos.append(item)

                    if type(symbol.attrs[key]) is not UserInputAttribute and type(symbol.attrs[key]) is not tuple:

                        symbol.attrs[key] = self.graphicsView.findItemByUid(symbol.attrs[key])

            self.graphicsView.scene.update(self.graphicsView.sceneRect())

            for item in self.graphicsView.scene.items():

                item.setVisible(True)

        except Exception as ex:

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

            self.addMessage.emit(MessageType.Error, message)

    '''

        @brief      Remove added item on same place and Add GraphicsItem

    def get_property(self, property):

        """ return property with given value """

    def set_property(self, property, value):

        """ set property with given value """

        matches = [prop for prop,_ in self._properties.items() if prop.Attribute == property]

        if matches: self._properties[matches[0]] = value

    def setVisible(self, visible):

        """ override visible value """

        super(QEngineeringTextItem, self).setVisible(visible)

                    attr = SymbolAttr.fromXml(attr_node)

                    item.attrs[attr] = attr_node.text

                item.loc = (x, y)

                item.size = (width, height)

                item.angle = angle

                run.explode()

        finally:

            self.runs.clear()

    '''

        @brief      save Line Data

        self.uid = uuid.uuid4() # generate UUID

        self._items = []

        self._visible = False

    @property

    def visible(self):

                item.owner = None

        finally:

            self.items.clear()

    '''

        @brief  get two points which's length is max