/ - Diff - HYTOS - 일정관리

             self._symbolType = {}
             self._lineNoPropertiesUID = {}
             self._attributeByType = {}
             self._connected_items_lists = []
             self._connected_items_lists = None
             # for load drawing data from database
             self._connecterss = {}
-...
                 @author     euisung
                 @date       2018.11.28
             '''
             from QEngineeringInstLineNoTextItem import QEngineeringInstLineNoTextItem
             self.equipments.clear()
             self.symbols.clear()
             self.lineNos.clear()
-...
             if trim:
                 self.tracerLineNos.clear()
                 self.lines.clear()
                 self._connected_items_lists = QEngineeringInstLineNoTextItem()
         '''
             @brief      clear
-...
         '''
         def clear(self):
             from QEngineeringInstLineNoTextItem import QEngineeringInstLineNoTextItem
             if self.activeDrawing and self.activeDrawing.UID:
                 self.clear_occupying_drawing(self.activeDrawing.UID)
-...
             self._symbolType = {}
             self._lineNoPropertiesUID = {}
             self._attributeByType = {}
             self._connected_items_lists.clear()
             self._connected_items_lists = QEngineeringInstLineNoTextItem()
             self._connecterss = {}
             self._associationss = {}
-...
                         rows = cursor.fetchall()
                         if property.upper() in [name[0].upper() for name in rows]:
                         """
                         if not symbol_attribute_uid and not custom_table_uid and not custom and not inst_table_uid:
                         if not symbol_attribute_uid and not custom_table_uid and not custom and not inst_table_uid and not inst:
                             sql = 'select uid, code, description, Allowables from [{}] order by code DESC'.format(property)
                         elif symbol_attribute_uid and not custom_table_uid and not inst_table_uid:
                         elif symbol_attribute_uid and not custom_table_uid and not inst_table_uid and not inst:
                             sql = "select uid, code, description, Allowables from [{}] where SymbolAttribute_UID='{}' " \
                                   "order by code DESC".format(property, symbol_attribute_uid)
                         elif not symbol_attribute_uid and custom_table_uid and not inst_table_uid:

                 return CodeTable.TABLES[_table_name]
             elif _table_name not in CodeTable.TABLES and inst:
                 # custom code table using
                 # inst code table using
                 appDocData = AppDocData.instance()
                 values = appDocData.getCodeTable(_table_name, False, inst=True)
                 CodeTable.TABLES[_table_name] = CodeTable(custom_table_uid, values, inst=True)

     from EngineeringEndBreakItem import QEngineeringEndBreakItem
     from EngineeringReducerItem import QEngineeringReducerItem
     from EngineeringFlowMarkItem import QEngineeringFlowMarkItem
     from EngineeringRunItem import QEngineeringRunItem
     from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem
     from QEngineeringInstLineNoTextItem import QEngineeringInstLineNoTextItem
     class LoadCommand(AbstractCommand):
-...
             import concurrent.futures as futures
             from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse
             from App import App
             from EngineeringRunItem import QEngineeringRunItem
             from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem
             from EngineeringGraphicsLineItem import QEngineeringGraphicsLineItem
             app_doc_data = AppDocData.instance()
-...
                         value = value + 1
                         self.show_progress.emit(value)
                     # for inst attribute
                     for trimLineNo in root.iter('INST_LINE_NO'):
                         line_no = QEngineeringInstLineNoTextItem()
                         line_no.uid = uuid.UUID(trimLineNo.find('UID').text)
                         if symbol and line:
                             runs_node = trimLineNo.findall('RUN')
                             if runs_node is None: continue
                             for run in runs_node:
                                 line_run = QEngineeringRunItem()
                                 uids = []
                                 for child in run:
                                     uidElement = child.find('UID')
                                     if uidElement is not None:
                                         uid = uidElement.text
                                         uids.append(uid)
                                 run_items = find_items(scene, uids)
                                 for run_item in run_items:
                                     line_run.items.append(run_item)
                                 line_run.owner = line_no
                                 line_no.runs.append(line_run)
                             app_doc_data._connected_items_lists = line_no
                         value = value + 1
                         self.show_progress.emit(value)
                     QApplication.processEvents()
                 if package:
-...
         def load_data_from_database(self, drawing, scene, symbol, text, line, unknown, package) -> int:
             """load drawing data from database"""
             from App import App
             from EngineeringRunItem import QEngineeringRunItem
             from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem
             def find_item(scene, uid):
                 items = [item for item in scene.items() if hasattr(item, 'uid') and str(item.uid) == str(uid)]
-...
                         value = value + 1
                         self.show_progress.emit(value)
                     # for inst attribute
                     for component in [component for component in components if
                                       component['Name'] == 'Inst Line NO' and component['SymbolType_UID'] == -1]:
                         line_no = QEngineeringInstLineNoTextItem()
                         line_no.uid = uuid.UUID(component['UID'])
                         if symbol and line:
                             runs = app_doc_data.get_pipe_runs(str(line_no.uid))
                             if not runs: continue
                             for run in runs:
                                 line_run = QEngineeringRunItem()
                                 run_items = app_doc_data.get_pipe_run_items(run['UID'])
                                 uids = []
                                 for record in run_items:
                                     uid = record['Components_UID']
                                     uids.append(uid)
                                 run_items = find_items(scene, uids)
                                 for run_item in run_items:
                                     line_run.items.append(run_item)
                                 line_run.owner = line_no
                                 line_no.runs.append(line_run)
                             app_doc_data._connected_items_lists = line_no
                         value = value + 1
                         self.show_progress.emit(value)
                     QApplication.processEvents()
                 if package:
                     for component in [component for component in components if
                                     component['Name'] == 'VendorPackage' and component['SymbolType_UID'] == -1]:

             from EngineeringTextItem import QEngineeringTextItem
             from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem
             from EngineeringLineNoTextItem import QEngineeringLineNoTextItem
             from EngineeringUnknownItem import QEngineeringUnknownItem
             try:
                 appDocData = AppDocData.instance()
-...
                             type(item) is not QEngineeringLineNoTextItem]
                 db_items.extend([item for item in items if type(item) is QEngineeringLineNoTextItem])
                 db_items.extend([line for line in appDocData.tracerLineNos if type(line) is QEngineeringTrimLineNoTextItem])
                 db_items.append(appDocData._connected_items_lists)
                 configs = appDocData.getConfigs('Data Save', 'Unknown Xml Only')
                 if configs and int(configs[0].value) is -1:
                     db_items.extend([item for item in items if type(item) is QEngineeringUnknownItem])
                 appDocData.saveToDatabase(db_items, self.show_progress)
-...
             app_doc_data = AppDocData.instance()
             path = os.path.join(app_doc_data.getCurrentProject().getTempPath(), app_doc_data.imgName + '.xml')
             xml, result = xg.write_to_xml(path, app_doc_data.activeDrawing.width, app_doc_data.activeDrawing.height,
                                         allItems, app_doc_data.tracerLineNos)
                                         allItems, app_doc_data.tracerLineNos + [app_doc_data._connected_items_lists])
             if xml:
                 from xml.etree import ElementTree
                 ElementTree.ElementTree(xml).write(path)

         from EngineeringErrorItem import QEngineeringErrorItem
         from EngineeringTextItem import QEngineeringTextItem
         from SpecialItemTypesDialog import SpecialItemTracer
         from QEngineeringInstLineNoTextItem import QEngineeringInstLineNoTextItem
         from EngineeringRunItem import QEngineeringRunItem
         try:
             docdata = AppDocData.instance()
-...
             QApplication.processEvents()
             # trace connected items
             docdata._connected_items_lists.clear()
             docdata._connected_items_lists = QEngineeringInstLineNoTextItem()
             connected_items_lists = docdata._connected_items_lists
             items = symbols + lines
-...
                 for item in connected_items_list:
                     items.remove(item)
                 connected_items_lists.append(connected_items_list)
                 line_run = QEngineeringRunItem()
                 for run_item in connected_items_list:
                     line_run.items.append(run_item)
                 line_run.owner = connected_items_lists
                 connected_items_lists.runs.append(line_run)
             # up to here
             # connect attribute

         def EvaluatedSize(self):
             from EngineeringReducerItem import QEngineeringReducerItem
             from EngineeringLineNoTextItem import QEngineeringLineNoTextItem
             from AppDocData import AppDocData
             try:
                 if self.Size: return self.Size
-...
                 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, str(self.uid) + self.name + message)
                 #App.mainWnd().addMessage.emit(MessageType.Error, str(self.uid) + self.name + message)
                 App.mainWnd().addMessage.emit(MessageType.Error, message)
         def EvaluatedLineNo(self, prop):
             """ return line no attr """

     # coding: utf-8
     """
     This is engineering trim line no text item module
     """
     import os.path
     import sys
     import copy
     try:
         from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QRect
         from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont
         from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsTextItem
     except ImportError:
         try:
             from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect
             from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QFont
         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     from AppDocData import AppDocData
     from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem
     class QEngineeringInstLineNoTextItem(QEngineeringTrimLineNoTextItem):
         """
         for instrument attibute, saving connected items
         """
         def __init__(self, parent=None):
             QEngineeringTrimLineNoTextItem.__init__(self, parent)
         def toXml(self):
             from xml.etree.ElementTree import Element, SubElement, dump, ElementTree
             try:
                 node = Element('INST_LINE_NO')
                 uidNode = Element('UID')
                 uidNode.text = str(self.uid)
                 node.append(uidNode)
                 for run in self.runs:
                     node.append(run.toXml())
             except Exception as ex:
                 return None
             return node
         def toSql(self):
             """ generate sql phrase to save to database """
             import uuid
             res = []
             resLater = []
             app_doc_data = AppDocData.instance()
             cols = ['UID', 'Drawings_UID', 'Symbol_UID']
             rect = self.sceneBoundingRect()
             values = ['?', '?', "(select UID from Symbol where Name='Inst Line NO' and SymbolType_UID=-1)"]
             params = [(str(self.uid), str(app_doc_data.activeDrawing.UID))]
             sql = 'insert into Components({}) values({})'.format(','.join(cols), ','.join(values))
             res.append((sql, tuple(params)))
             _index = 1
             for run in self.runs:
                 resLater.extend(run.to_sql(_index, self))
                 _index += 1
             return res, resLater
         def explode(self, dummy=None):
             from App import App
             super().explode()
             treeWidget = App.mainWnd().itemTreeWidget
             treeWidget.findItemByData(self).parent().removeChild(treeWidget.findItemByData(self))
             tracerLineNos = AppDocData.instance().tracerLineNos
             if self in tracerLineNos:
                 tracerLineNos.pop(tracerLineNos.index(self))

         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     from EngineeringPolylineItem import QEngineeringPolylineItem
     from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem
     import OcrResultDialog
     from AppDocData import AppDocData
     from EngineeringLineNoTextItem import QEngineeringLineNoTextItem
-...
         """
         def __init__(self, parent=None):
             import uuid
             QEngineeringLineNoTextItem.__init__(self, parent)
             self.loc = (0, 0)
             self.size = (1, 1)
-...
         '''
         def toXml(self):
             from xml.etree.ElementTree import Element, SubElement, dump, ElementTree
             from EngineeringLineItem import QEngineeringLineItem
             from SymbolSvgItem import SymbolSvgItem
             try:
                 node = Element('TRIM_LINE_NO')

         def EvaluatedCode(self, old_code, code_name):
             """ return new attribute code """
             #from LineNoTracer import LineNoTracer
             #from EngineeringLineNoTextItem import QEngineeringLineNoTextItem
             from AppDocData import AppDocData
             from CodeTables import CodeTable
             try:
                 start_item = None
                 if self.iType == 19:    # Labels - Symbol
                     matches = [assoc for assoc in self.associations() if type(assoc) is SymbolSvgItem]
                     matches = [assoc for assoc in self.associations() if issubclass(type(assoc), SymbolSvgItem)]
                     start_item = matches[0] if matches else None
                 else:
                     start_item = self
-...
                 if not start_item:
                     return ''
                 #container = QEngineeringLineNoTextItem()
                 #container.conns.append(start_item)
                 #symbols = [item for item in worker.scene.items() if issubclass(type(item), SymbolSvgItem) and not (type(item) is QEngineeringErrorItem) and not \
                 #                            (type(item) is QEngineeringUnknownItem) and item.type != 'Notes' and not (type(item) is QEngineeringEndBreakItem)]
                 #lines = [item for item in worker.scene.items() if type(item) is QEngineeringLineItem]
                 #tracer = LineNoTracer(symbols, lines, [container], [], [], [], [])
                 app_doc_data = AppDocData.instance()
                 connected_items_lists = app_doc_data._connected_items_lists
                 items = [connected_items_list.items for connected_items_list in connected_items_lists.runs if start_item in connected_items_list.items]
                 if len(items) != 1:
                     return ''
                 else:
                     items = [item.name for item in items[0] if issubclass(type(item), SymbolSvgItem)]
                 table = CodeTable.instance(code_name, inst=True)
                 new_code = None
                 for value in table.values:
                     if old_code == value[1] and [item for item in value[2] if item in items]:
                         return value[3]
                 return 'new_code'
                 return ''
             except Exception as ex:
                 from App import App
                 from AppDocData import MessageType
                 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, str(self.uid) + self.name + message)
                 #App.mainWnd().addMessage.emit(MessageType.Error, str(self.uid) + self.name + message)
                 App.mainWnd().addMessage.emit(MessageType.Error, message)
     def recursiveChangeAttributes(node, attName, attValue):
         while not node.isNull():

         @author     Jeongwoo
         @date       2018.05.28
     '''
     def appendLineInfo(xmlPath, lineInfo):
         tree = parse(xmlPath)
         root = tree.getroot()
-...
 .06.14  Jeongwoo    Add if-statement for QEngineeringUnknownItem data node
 .11.26  euisung     remove scene dependency
     '''
     def write_to_xml(path, pidWidth, pidHeight, items, tracer_line_nos):
         from EngineeringAbstractItem import QEngineeringAbstractItem
         from EngineeringNoteItem import QEngineeringNoteItem
-...
                     resultDic[key][1].append(str(item.uid))
             for line in tracer_line_nos:
                 if type(line) is QEngineeringTrimLineNoTextItem:
                 if issubclass(type(line), QEngineeringTrimLineNoTextItem):
                     trimNode = line.toXml()
                     if trimNode:
                         resultDic[str(type(item))][0] += 1

ID	6a5a526e97a2ef9f588376f9bb221a820376d8ed
상위	e93a1840
하위	9bcaea3f

프로젝트

일반

사용자정보

HYTOS

개정판 6a5a526e