/ - Diff - HYTOS - 일정관리

개정판 8a40f6ee

ID	8a40f6ee8685f9e687c399f7e8753b26d35ab4e8
상위	1eed6634
하위	e618acaf

백흠경이(가) 약 5년 전에 추가함

issue #1052: 스트림 라인 태그 배치 기능 업데이트

Change-Id: I70d5b49e42e0e656af588810dc16e5124b906a6c

                     QApplication.processEvents()
                 self.rebuild_label()
                 # """ update scene """
                 self.graphicsView.scene.update(self.graphicsView.sceneRect())
                 for item in self.graphicsView.scene.items():

     '''
         @history    2018.05.15  Jeongwoo    Remove Parent Object [QObject]
     '''
     class QEngineeringAbstractItem:
         '''
             @history    2018.05.15  Jeongwoo    Remove call super
 .05.17  Jeongwoo    Add DEFAULT_COLOR Variable
         '''
         DEFAULT_COLOR = '#0000FF'
         HOVER_COLOR   = '#BC4438'
         HOVER_COLOR = '#BC4438'
         CONNECTED_AT_PT = 0
         CONNECTED_AT_BODY = 1
-...
             self._area = None
             self.connectors = []
             self.attrs = {}  # attributes
             self._associations = {'Text Item':[], 'Symbol Item':[]} # associated items
             self._associations = {'Text Item': [], 'Symbol Item': []}  # associated items
         @property
         def hover(self):
             """ return hover """
-...
             @author     Jeongwoo
             @date       2018.05.11
         '''
         def setColor(self, color):
             raise NotImplementedError
-...
             @author Jeongwoo
             @date   2018.05.11
         '''
         def getColor(self):
             return QEngineeringAbstractItem.HOVER_COLOR if self.hover else (self.owner.getColor() if (self.owner and hasattr(self.owner, '_color')) else self._color)
             return QEngineeringAbstractItem.HOVER_COLOR if self.hover else (
                 self.owner.getColor() if (self.owner and hasattr(self.owner, '_color')) else self._color)
         '''
             @brief  getter of owner
             @author humkyung
             @date   2018.05.12
         '''
         @property
         def owner(self):
             return self._owner
             return self._owner
         '''
             @brief  setter of owner
             @author humkyung
             @date   2018.05.12
         '''
         @owner.setter
         def owner(self, value):
             self._owner = value
-...
             """ check this is connected to other """
             for connector in self.connectors:
                 if connector.connectedItem: return True
             return False
         def validate(self):
-...
             @author humkyung
             @date   2018.09.06
         '''
         @property
         def area(self):
             return self._area if self._area is not None else 'None'
-...
             @author humkyung
             @date   2018.09.06
         '''
         @area.setter
         def area(self, value):
             self._area = value
-...
             @author humkyung
             @date   2018.05.16
         '''
         def toXml(self):
             pass
-...
             @author humkyung
             @date   2018.05.16
         '''
         def toXmlAsAttribute(self, parent):
             pass
-...
                     if assoc and type(assoc) is uuid.UUID:
                         matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]
                         if matches:
                             res.append(matches[0]) # TODO: need to update association with instance
                             res.append(matches[0])  # TODO: need to update association with instance
                             self._associations[key][index] = matches[0]
                         index += 1
                     # up to here
-...
                     res.append(symbol)
             return res
         def getAttributes(self):
             _attrs = {}
             try:
-...
                 """ get attributes of item from database """
                 docData = AppDocData.instance()
                 symbolAttrs = docData.getSymbolAttribute(self.type) if type(self) is not QEngineeringLineItem else docData.getSymbolAttribute('Line')
                 symbolAttrs = docData.getSymbolAttribute(self.type) if type(
                     self) is not QEngineeringLineItem else docData.getSymbolAttribute('Line')
                 targetAttrs = []
                 if type(self) is not QEngineeringLineItem:
                     for attr in symbolAttrs:
                         if attr.Target is None or attr.Target == 'ALL' or [target for target in attr.Target.split(',') if self.dbUid is int(target)]:
                         if attr.Target is None or attr.Target == 'ALL' or [target for target in attr.Target.split(',') if
                                                                            self.dbUid is int(target)]:
                             targetAttrs.append(attr)
                 _texts = self.texts()
                 _symbols = self.symbols()
                 for attr in targetAttrs:
                     matches = [_attr for _attr,_ in self.attrs.items() if _attr.UID == attr.UID]
                     matches = [_attr for _attr, _ in self.attrs.items() if _attr.UID == attr.UID]
                     if matches:
                         attr.Freeze = matches[0].Freeze         ### update freeze value
                         attr.Freeze = matches[0].Freeze  ### update freeze value
                         attr.AssocItem = matches[0].AssocItem
                         _attrs[attr] = self.attrs[matches[0]]   ### copy attribute value
                         _attrs[attr] = self.attrs[matches[0]]  ### copy attribute value
                     else:
                         _attrs[attr] = ''
                     if attr.Freeze: continue    ### do not evalulate value if attribute is frozen
                     if attr.Freeze: continue  ### do not evalulate value if attribute is frozen
                     if attr.AttributeType == 'Text Item' or attr.AttributeType == 'Valve Oper Code':
                         at = int(attr.AttrAt)
                         items = [text for text in _texts if QEngineeringAbstractItem.assoc_type(text) == attr.AttributeType]
-...
                             _attrs[attr] = eval(attr.Expression) if attr.Expression else ''
                         else:
                             item = attr.AssocItem
                             _attrs[attr] = eval(attr.Expression) if attr.Expression and ((item and 'item' in attr.Expression) or 'self' in attr.Expression) else ''
                             _attrs[attr] = eval(attr.Expression) if attr.Expression and (
                                         (item and 'item' in attr.Expression) or 'self' in attr.Expression) else ''
                     elif attr.AttributeType == 'Symbol Item':
                         at = int(attr.AttrAt)
                         if not attr.AssocItem and len(_symbols) > at:
-...
                         else:
                             _attrs[attr] = ''
                 for _attr,_value in _attrs.items():
                 for _attr, _value in _attrs.items():
                     if _value is None or _value == '':
                         _attr.AssocItem = None
                 self.attrs = _attrs ### assign self.attrs
                 self.attrs = _attrs  ### assign self.attrs
             except Exception as ex:
                 from App import App
                 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)
                 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)
             return self.attrs
         def attrib(self, name):
             """ return the value of given attribute with name """
             matches = [(attr,value) for attr,value in self.getAttributes().items() if attr.Attribute == name]
             matches = [(attr, value) for attr, value in self.getAttributes().items() if attr.Attribute == name]
             if matches: return matches[0][1]
             return None
         def set_attrib(self, attrib, value):
             """ set attribute with given value """
             matches = [attr for attr,_ in self.attrs.items() if attr.UID == attrib.UID]
             matches = [attr for attr, _ in self.attrs.items() if attr.UID == attrib.UID]
             if len(matches) == 1: self.attrs[matches[0]] = value
         @staticmethod
         def assoc_type(item):
             """ return association type of given item """
             from EngineeringTextItem import QEngineeringTextItem
             from SymbolSvgItem import SymbolSvgItem
             from SymbolSvgItem import SymbolSvgItem
             from QEngineeringSizeTextItem import QEngineeringSizeTextItem
             from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem
-...
                         break
                 if freeze:
                     pass
                     #for assoc in self.associations():
                     # for assoc in self.associations():
                     #    assoc.owner = self
                 else:
-...
             """ add given item to association """
             from EngineeringTextItem import QEngineeringTextItem
             from SymbolSvgItem import SymbolSvgItem
             from SymbolSvgItem import SymbolSvgItem
             from QEngineeringSizeTextItem import QEngineeringSizeTextItem
             for key in self.attrs.keys():
-...
             if _type is not None:
                 if not _type in self._associations:
                     self._associations[_type] = []
                 if item in self._associations[_type]: return True
                 if at is None:
                     self._associations[_type].append(item)
                 else:
                     while len(self._associations[_type]) <= at: self._associations[_type].append(None)
                     #if len(self._associations[_type]) > at and self._associations[_type][at] is not None:
                     # if len(self._associations[_type]) > at and self._associations[_type][at] is not None:
                     #    self._associations[_type][at].owner = None
                     self._associations[_type][at] = item

         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     from AppDocData import *
     from EngineeringAbstractItem import QEngineeringAbstractItem
-...
         AXIS_MODE = 0
         FREE_MODE = 1
         '''
             @brief
             @author
             @date
             @history        humkyung 2018.07.27 add member for connectedItem
                             humkyung 2018.09.03 remove code to add connector item
         '''
         def __init__(self, uid=None, parent=None, index=-1):
             """constructor of connector"""
             import uuid
             from SymbolSvgItem import SymbolSvgItem
             from EngineeringEqpDescTextItem import QEngineeringEqpDescTextItem
             QGraphicsEllipseItem.__init__(self, parent)
-...
                 elif self.connectedItem and parent.name in ['CV_H', 'CV_V']:
                     if self.data is None or self.data.elevation is None:
                         res.extend([self, 'need to check elevation'])
                 elif parent.name == 'Line Splitter':    # set default value for line splitter
                 elif parent.name == 'Line Splitter':  # set default value for line splitter
                     if self.connectedItem:
                         if self.data.pressure_drop is None:
                             self.data.pressure_drop = 0
-...
             if self.connectedItem and type(self.parentItem()) is SymbolSvgItem:
                 self.setBrush(Qt.red) if res else self.setBrush(Qt.yellow)
             else:
                 self.setBrush(Qt.blue)
                 self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)
             # up to here
             return res
         '''
             @brief      return direction vector
             @author     humkyung
             @date       2018.09.01
         '''
         def dir(self):
             """return direction vector"""
             if self._direction == 'LEFT':
                 return (-1, 0)
                 return -1, 0
             elif self._direction == 'RIGHT':
                 return (1, 0)
                 return 1, 0
             elif self._direction == 'UP':
                 return (0, -1)
                 return 0, -1
             elif self._direction == 'DOWN':
                 return (0, 1)
                 return 0, 1
             return None
-...
                 c = QColor()
                 c.setNamedColor(QEngineeringConnectorItem.HIGHLIGHT)
                 self.setPen(Qt.red)
                 #self.setBrush(c)
                 # self.setBrush(c)
                 if hasattr(self, '_label'):
                     font = self._label.font()
                     font.setBold(True)
-...
                 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.setPen(Qt.black)
                 #self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)
                 # self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)
                 if hasattr(self, '_label'):
                     font = self._label.font()
                     font.setBold(False)

     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, QColor
         from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsTextItem
         from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, \
             QGraphicsTextItem
     except ImportError:
         try:
             from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect
-...
         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     class QEngineeringEqpDescTextItem(QGraphicsTextItem):
         """ This is engineering equipment description text item class """
-...
         def set_font_color(self, color):
             self.setDefaultTextColor(QColor(color))

     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, QPainter, QPolygonF, QBrush, QPen, QTransform, QFont
         from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsTextItem
         from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QPainter, QPolygonF, QBrush, QPen, QTransform, QFont, QColor
         from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, \
             QGraphicsTextItem
     except ImportError:
         try:
             from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect
-...
         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     from AppDocData import AppDocData,MessageType
     from AppDocData import AppDocData, MessageType
     from EngineeringAbstractItem import QEngineeringAbstractItem
     class QEngineeringStreamNoTextItem(QGraphicsTextItem):
         """ This is engineering stream no text item class """
-...
             font.setPointSizeF(4)
             self.setFont(font)
         def highlight(self, flag):
             if flag:
                 self.setDefaultTextColor(QColor(QEngineeringAbstractItem.HOVER_COLOR))
             else:
                 self.setDefaultTextColor(Qt.black)
             self.update()
         def paint(self, painter, option, widget):
             """ override paint method """
             painter.setPen(QPen(Qt.black, 1))
             painter.drawPolygon(self.create_poly(4, 7, 0))
             QGraphicsTextItem.paint(self, painter, option, widget)
-...
                 t = w * i + s
                 x = r * math.cos(math.radians(t))
                 y = r * math.sin(math.radians(t))
                 polygon.append(QPointF(rect.width()*0.5 + x, rect.height()*0.5 + y))
                 polygon.append(QPointF(rect.width() * 0.5 + x, rect.height() * 0.5 + y))
             return polygon

                     option.setAlignment(Qt.AlignCenter)
                     doc.setDefaultTextOption(option)
                     if max_length_line[0] is not None and max_length_line[1] is not None:
                         padding = 2
                         self._stream_no_text.setTextWidth(doc.idealWidth())
                         dx = max_length_line[0][0] - max_length_line[1][0]
                         dy = max_length_line[0][1] - max_length_line[1][1]
                         if abs(dx) >= abs(dy):
                         if abs(dx) >= abs(dy):  # horizontal line
                             rect = self._stream_no_text.boundingRect()
                             x = (max_length_line[0][0] + max_length_line[1][0] - self._stream_no_text.textWidth()) * 0.5
                             y = (max_length_line[0][1] + max_length_line[1][1]) * 0.5
                             y = (max_length_line[0][1] + max_length_line[1][1]) * 0.5 - rect.height() - padding
                             self._stream_no_text.setPos(QPointF(x, y))
                         else:
                             x = (max_length_line[0][0] + max_length_line[1][0]) * 0.5
                         else:   # vertical line
                             x = (max_length_line[0][0] + max_length_line[1][0]) * 0.5 + padding
                             y = (max_length_line[0][1] + max_length_line[1][1] - self._stream_no_text.textWidth()) * 0.5
                             self._stream_no_text.setPos(QPointF(x, y))
-...
             self.highlight(False)
         def highlight(self, flag):
             from EngineeringStreamNoTextItem import QEngineeringStreamNoTextItem
             self.hover = flag
             self.setZValue(QEngineeringAbstractItem.HOVER_ZVALUE) if flag else \
                 self.setZValue(QEngineeringStreamlineItem.ZVALUE)
             self._stream_no_text.highlight(flag)
             self.update()
         def paint(self, painter, option, widget):

                 App.mainWnd().addMessage.emit(MessageType.Error, message)
             self.setZValue(SymbolSvgItem.ZVALUE)
             self._desc_label = QEngineeringEqpDescTextItem('eqp name<br>pressure drop<br>elevation', self)
             self.desc_labels = []
         def has_attribute(self):
             if len(self.attribute) > 0:
-...
             return None
         @property
         def desc_label(self):
             """ return equipment description label """
             return self._desc_label
         def validate(self):
             """validate symbol data"""
-...
                                                                sys.exc_info()[-1].tb_lineno)
                 App.mainWnd().addMessage.emit(MessageType.Error, message)
         def get_label_pos_of_connector(self, conn, label):
             """return label position of given connector"""
             res = None
             label_rect = label.boundingRect()
             conn_rect = conn.mapRectFromParent(conn.boundingRect())
             dx, dy = conn.dir()
             if dx == 1:
                 res = QPointF(conn_rect.x() + conn_rect.width() * 0.5, conn_rect.y())
             elif dy == -1:
                 res = QPointF(conn_rect.x() + conn_rect.width()*0.5, conn_rect.y() - label_rect.height())
             elif dy == 1:
                 res = QPointF(conn_rect.x() + conn_rect.width()*0.5, conn_rect.y() + conn_rect.height()*0.5)
             elif dx == -1:
                 res = QPointF(conn_rect.x() - label_rect.width() - conn_rect.width()*0.5,
                               conn_rect.y() + conn_rect.height()*0.5)
             return res
         def build_label(self):
             """ build equipment label """
             """build equipment label"""
             rect = self.boundingRect()
             app_doc_data = AppDocData.instance()
             units = [attr[1] for attr in app_doc_data.activeDrawing.attrs if attr[0] == 'Units'][0]
             # clear labels
             for label in self.desc_labels:
                 label.setHtml('')
             if self.category == 'Equipment - [ Pressure Drop ]':
                 if self.type == 'Air Fin Cooler':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                     index = 0
                     for conn in self.connectors:
                         if self.tag_no:
                             if conn.data:
                                 conn_rect = conn.boundingRect()
                                 self.desc_labels[index].setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(conn.data.pressure_drop)} {units['Pressure']}<br>"
                                     f"{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                 self.desc_labels[index].setPos(QPointF(conn_rect.width(), 0))
                         index += 1
                 elif self.type == 'Filter':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         index = 0
                         for conn in self.connectors:
                             if conn.data:
                                 conn_rect = conn.boundingRect()
                                 self.desc_labels[index].setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(conn.data.pressure_drop)} {units['Pressure']}<br>"
                                     f"{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                 self.desc_labels[index].setPos(QPointF(conn_rect.width(), 0))
                             index += 1
                 elif self.type == 'Heat Exchanger':
                     if self.tag_no:
                         data = [conn.data for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data[0].pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data[0].elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} {units['Pressure']}<br>"
                                 f"{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             pos = self.get_label_pos_of_connector(conns[0], self.desc_labels[0])
                             self.desc_labels[0].setPos(pos)
                 elif self.type == 'Miscellaneous':
                     if self.name == 'M_Coil':
                         if self.tag_no:
                             data = self.connectors[0].data
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
                             index = 0
                             for conn in self.connectors:
                                 if conn.data:
                                     conn_rect = conn.boundingRect()
                                     self.desc_labels[index].setHtml(
                                         f"{self.tag_no}<br>{convert_to_fixed_point(conn.data.pressure_drop)} {units['Pressure']}<br>"
                                         f"{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                     self.desc_labels[index].setPos(QPointF(conn_rect.width(), 0))
                                 index += 1
                     elif self.name in ('M_DP_E', 'M_React'):
                         if self.tag_no:
                             data = [conn.data for conn in self.connectors
                                     if
                                     conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(data[0].pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data[0].elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
                             conns = [conn for conn in self.connectors
                                     if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                             if conns:
                                 self.desc_labels[0].setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} {units['Pressure']}"
                                     f"<br>{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                                 label_rect = self.desc_labels[0].boundingRect()
                                 self.desc_labels[0].setPos(
                                     QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
                 elif self.type == 'Strainer':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} {units['Pressure']}<br>"
                                 f"{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(
                                 QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
             elif self.category == 'Equipment - [ Pressurized ]':
                 if self.type == 'Battery Limit':
                     if self.tag_no:
                         data = [conn.data for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data[0].pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data[0].elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                     if self.tag_no and self.connectors[0].data:
                         index = 0
                         data = self.connectors[0].data
                         if data and (data.pressure_drop is not None or data.elevation is not None):
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>"
                                 f"{convert_to_fixed_point(data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
                 elif self.type == 'Column':
                     if self.tag_no:
                         conn = [conn for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if conn:
                             data = conn[0].data
                             nozzle = str(conn[0]).rsplit('_', 1)[1]
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         index = 0
                         for conn in self.connectors:
                             if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None):
                                 nozzle = str(conn).rsplit('_', 1)[1]
                                 self.desc_labels[index].setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(conn.data.pressure)} "
                                     f"{units['Pressure']}(g)<br>{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                 pos = self.get_label_pos_of_connector(conn, self.desc_labels[index])
                                 self.desc_labels[index].setPos(pos)
                             index += 1
                 elif self.type == 'Drum':
                     if self.tag_no:
                         conn = [conn for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if conn:
                             data = conn[0].data
                             nozzle = str(conn[0]).rsplit('_', 1)[1]
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         index = 0
                         for conn in self.connectors:
                             if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None):
                                 nozzle = str(conn).rsplit('_', 1)[1]
                                 self.desc_labels[index].setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(conn.data.pressure)} "
                                     f"{units['Pressure']}(g)<br>{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                 pos = self.get_label_pos_of_connector(conn, self.desc_labels[index])
                                 self.desc_labels[index].setPos(pos)
                             index += 1
                 elif self.type == 'Miscellaneous':
                     if self.tag_no:
                         conn = [conn for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if conn:
                             data = conn[0].data
                             nozzle = str(conn[0]).rsplit('_', 1)[1]
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         index = 0
                         for conn in self.connectors:
                             if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None):
                                 nozzle = str(conn).rsplit('_', 1)[1]
                                 if conn.data:
                                     self.desc_labels[index].setHtml(
                                         f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(conn.data.pressure)} "
                                         f"{units['Pressure']}(g)<br>{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                             index += 1
                 elif self.type == 'Tank':
                     if self.tag_no:
                         conn = [conn for conn in self.connectors
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                         if conn:
                             data = conn[0].data
                             nozzle = str(conn[0]).rsplit('_', 1)[1]
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         index = 0
                         for conn in self.connectors:
                             if conn.data and conn.connectedItem and \
                                     (conn.data.pressure_drop is not None or conn.data.elevation is not None):
                                 nozzle = str(conn).rsplit('_', 1)[1]
                                 self.desc_labels[index].setHtml(
                                     f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(conn.data.pressure)} "
                                     f"{units['Pressure']}(g)<br>{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                 pos = self.get_label_pos_of_connector(conn, self.desc_labels[index])
                                 self.desc_labels[index].setPos(pos)
                             index += 1
             elif self.category == 'Equipment - [ Rotating ]':
                 if self.type == 'Compressor':
                     if self.name in ('L_Comp', 'R_Comp'):
                         if self.tag_no:
                             conn = [conn for conn in self.connectors
                                     if
                                     conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]
                             if conn:
                                 data = conn[0].data
                                 nozzle = str(conn[0]).rsplit('_', 1)[1]
                                 if data:
                                     self.desc_label.setHtml(
                                         f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(data.pressure)} {units['Pressure']}(g)<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
                             index = 0
                             for conn in self.connectors:
                                 if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None):
                                     nozzle = str(conn).rsplit('_', 1)[1]
                                     self.desc_labels[index].setHtml(
                                         f"{self.tag_no}_{nozzle}<br>{convert_to_fixed_point(conn.data.pressure)} "
                                         f"{units['Pressure']}(g)<br>{convert_to_fixed_point(conn.data.elevation)} {units['Length']}")
                                     pos = self.get_label_pos_of_connector(conn, self.desc_labels[index])
                                     self.desc_labels[index].setPos(pos)
                                 index += 1
                     elif self.name in ('L_Komp', 'R_Komp'):
                         if self.tag_no:
                             data = self.connectors[0].data
                             if data:
                                 self.desc_label.setHtml(
                                 self.desc_labels[0].setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop) if data.pressure_drop is not None else 0} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
                 elif self.type == 'Pump':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop) if data.pressure_drop is not None else 0} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         conns = [conn for conn in self.connectors if conn.data and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>"
                                 f"{convert_to_fixed_point(conns[0].data.pressure_drop) if conns[0].data.pressure_drop is not None else 0} {units['Pressure']}<br>"
                                 f"{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(
                                 QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
             elif self.category == 'Instrument':
                 if self.type == 'Flowmeter':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} "
                                 f"{units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
                 elif self.type == 'Line Splitter':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} "
                                 f"{units['Pressure']}<br>{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
                 elif self.type == 'Reducer':
                     if self.tag_no:
                         data = self.connectors[0].data
                         if data:
                             self.desc_label.setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                     else:
                         self.desc_label.setHtml('')
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} "
                                 f"{units['Pressure']}<br>{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
                 elif self.type == 'Valve':
                     if self.name in ('CV_H', 'CV_V'):
                         if self.tag_no:
                             data = self.connectors[0].data
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop) if data.pressure_drop is not None else 0} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
                     elif self.name in ('MV_H', 'MV_V'):
                         if self.tag_no:
                             data = self.connectors[0].data
                             if data:
                                 self.desc_label.setHtml(
                                     f"{self.tag_no}<br>{convert_to_fixed_point(data.pressure_drop)} {units['Pressure']}<br>{convert_to_fixed_point(data.elevation)} {units['Length']}")
                         else:
                             self.desc_label.setHtml('')
             else:
                 if self.tag_no:
                     self.desc_label.setHtml(f"{self.tag_no}")
                 else:
                     self.desc_label.setHtml('')
             self.desc_label.setPos(QPointF(rect.width(), 0))
             app_doc_data = AppDocData.instance()
                     if self.tag_no and self.name in ('CV_H', 'CV_V'):
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop) if conns[0].data.pressure_drop is not None else 0} {units['Pressure']}<br>"
                                 f"{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width())*0.5, rect.height()))
                     elif self.tag_no and self.name in ('MV_H', 'MV_V'):
                         conns = [conn for conn in self.connectors
                                  if conn.data and conn.data.pressure_drop is not None and conn.data.elevation is not None]
                         if conns:
                             self.desc_labels[0].setHtml(
                                 f"{self.tag_no}<br>{convert_to_fixed_point(conns[0].data.pressure_drop)} "
                                 f"{units['Pressure']}<br>{convert_to_fixed_point(conns[0].data.elevation)} {units['Length']}")
                             label_rect = self.desc_labels[0].boundingRect()
                             self.desc_labels[0].setPos(QPointF((rect.width() - label_rect.width()) * 0.5, rect.height()))
             font_size = None
             configs = app_doc_data.getAppConfigs('option', 'TagFontSize')
             if configs and len(configs) == 1:
                 self.desc_label.set_font_size(configs[0].value)
                 font_size = configs[0].value
             font_color = None
             configs = app_doc_data.getAppConfigs('option', 'TagFontColor')
             if configs and len(configs) == 1:
                 self.desc_label.set_font_color(configs[0].value)
                 font_color = configs[0].value
         '''
             @brief  return bounding box of symbol
             @author humkyung
             @date   2018.04.08
         '''
             for label in self.desc_labels:
                 if font_size:  label.set_font_size(font_size)
                 if font_color:  label.set_font_color(font_color)
         def rect(self):
             """return bounding box of symbol"""
             return self.sceneBoundingRect()
         '''
-...
             painter.setPen(self.focuspen)
             painter.drawRect(self.boundingRect())
         '''
             @brief  override paint(draw connection points)
             @author humkyung
             @date   2018.04.21
         '''
         def paint(self, painter, options=None, widget=None):
             """override paint(draw connection points)"""
             from EngineeringAbstractItem import QEngineeringAbstractItem
             from EngineeringTextItem import QEngineeringTextItem
-...
         def onConnectorPosChaned(self, connector):
             pass
         '''
             @brief      set connector
             @author     kyouho
             @date       2018.07.26
         '''
         def set_connector(self, uid, index=None):
             """set connector"""
             from AppDocData import AppDocData
             app_doc_data = AppDocData.instance()
-...
             connector.data = app_doc_data.get_nozzle_data(uid)
             self.connectors.append(connector)
             label = QEngineeringEqpDescTextItem('eqp name<br>pressure drop<br>elevation', self)
             self.desc_labels.append(label)
         '''
         '''
-...
             rect.moveTo(self.loc[0], self.loc[1])
             return rect
         def flipSymbol(self):
             '''
                 @brief  remove item when user press delete key
                 @author humkyung
                 @date   2018.04.23
             '''
             if self.flip is 0:
                 self.flip = 1
             else:
                 self.flip = 0
             currentPoint = self.getCurrentPoint()
             self.reSettingSymbol(currentPoint, self.angle)
         '''
             @brief      rotate Symbol
             @author     kyouho
-...
                 if 0 == self.angle:
                     self.angle = 1.57
                 # degree 90
                 elif (1.57 == self.angle):
                 elif 1.57 == self.angle:
                     self.angle = 3.14
                 # degree 180
                 elif 3.14 == self.angle:

내보내기 Unified diff

프로젝트

일반

사용자정보

HYTOS

개정판 8a40f6ee