/ - Diff - HYTOS - 일정관리

                     app._mainWnd.show()
                     sys.exit(app.exec_())
         except Exception as ex:
              print('에러가 발생했습니다.\n', ex)
              print('에러가 발생했습니다.\n', ex)
         except:
             ex = sys.exc_info()[0]
             print('에러가 발생했습니다.\n', ex)

                 cursor.execute(sql)
                 rows = cursor.fetchall()
                 for row in rows:
                     pipeSize = NominalPipeSize(row[0], row[1], float(row[2]) if row[2] is not None else None, float(row[3]) if row[3] is not None else None, row[4], row[5], row[6], row[7])
                     pipeSize = NominalPipeSize(row[0], row[1], float(row[2]) if row[2] else None, float(row[3]) if row[3] else None, row[4], row[5], row[6], row[7])
                     pipeSize.sizeUnit = sizeUnit
                     if forCheckLineNumber:
                         if sizeUnit == 'Inch' and pipeSize.inchStr:

                         kyouho 2018.07.04 edit cofiguration new delimiter (self.delimiter)
         '''
         def accept(self):
             from NominalPipeSize import NomialPipeSizeTable
             from NominalPipeSize import NominalPipeSizeTable
             try:
                 docData = AppDocData.instance()
-...
                 docData.saveConfigs(configs)
                 docData.lineTypeConfigs = None  # clear line type configurations
                 NomialPipeSizeTable.instance().pipe_sizes = None    # clear nominal pipe size table
                 NominalPipeSizeTable.instance().pipe_sizes = None    # clear nominal pipe size table
             except Exception as ex:
                 from App import App
                 from AppDocData import MessageType

             elif type(item) is QEngineeringRunItem:
                 self.initLineRunCell(item)
             """ show tooltip """
             for index in range(self.rowCount()):
                 item = self.item(index, 1)
                 if item is not None:
                     item.setToolTip(item.text())
         '''
             @brief      Initialize Title Cell
             @author     Jeongwoos
-...
                         row = row + 1
                         count = count + 1
                     # up to here
                     for index in range(self.rowCount()):
                         item = self.item(index, 1)
                         if item is not None:
                             item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
                             item.setToolTip(item.text())
                     suppliedItem.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable|Qt.ItemIsEditable)
                 else:
                     self.setRowCount(0)

         def explode_line_no(self, lineNoTreeWidgetItem):
             """ explode line no """
             pass
             try:
                 line_no_item = lineNoTreeWidgetItem.data(0, self.TREE_DATA_ROLE)
                 if line_no_item:
                     connected_items = line_no_item.getConnectedItems()
                     for item in connected_items:
                         self.addTreeItem(self.SymbolsTreeItem, item)
                     for i in reversed(range(lineNoTreeWidgetItem.childCount())):
                         lineNoTreeWidgetItem.takeChild(i)
                     line_no_item.explode()
             finally:
                 pass
         '''
             @brief      pick line type
-...
                             data = item.data(0, self.TREE_DATA_ROLE)
                             if data is not None and (data == child) and (parent is not item.parent()):
                                 parentData = parent.data(0, self.TREE_DATA_ROLE)
                                 if issubclass(type(parentData), QEngineeringLineNoTextItem):
                                 if parentData is not None and issubclass(type(parentData), QEngineeringLineNoTextItem):
                                     for index in range(len(parentData.runs)):
                                         runGroup = parentData.runs[index]
                                         if data in runGroup.items:
-...
                                             break
                                         else:
                                             pass
                                 elif parent is not None:
                                     item.parent().removeChild(item) # remove item from original parent
                                     parent.addChild(item)
                                 break
                 elif type(child) is QEngineeringLineNoTextItem:
                     foundItems = self.findItems(child.text(), Qt.MatchExactly|Qt.MatchRecursive, 0)

             @author humkyung
         '''
         def findSecondaryLines(self, lines):
             from EngineeringAbstractItem import QEngineeringAbstractItem
             from EngineeringLineItem import QEngineeringLineItem
             from EngineeringRunItem import QEngineeringRunItem
-...
                     for line in lines:
                         if line.owner is not None: continue
                         matches = [x for x in self._lines if x.owner is not None and x.is_connectable(line)]
                         matches = [x for x in self._lines if x.owner is not None and x.is_connected(line, QEngineeringAbstractItem.CONNECTED_AT_BODY)]
                         if matches:
                             foundCount += 1
                             connectedItems = self.findConnectedObjects(line, toler=10)
-...
                             notMatches.append(line)
                     lines = notMatches
             except Exception as ex:
                 print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
                 from App import App
                 message = 'error occured({}) 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)
         '''
             @brief      trace line no
-...
                     docData.tracerLineNos.clear()
                     ## 기존에 찾은 것 유지
                     #for lineNo in self._lineNos:
                     #    lineNo.conns.clear()
                     docData.tracerLineNos = self._lineNos
                     remainLineNos = []
                     for lineno in docData.tracerLineNos:

         CONNECTED_AT_PT = 0
         CONNECTED_AT_BODY = 1
         HOVER_ZVALUE = 200
         def __init__(self, parent=None):
             self._color = self.DEFAULT_COLOR # default color
             self._owner = None

     # coding: utf-8
     """ This is engineering arrow item module """
     import os.path
     import copy, sys
     try:
         from PyQt5.QtCore import *
         from PyQt5.QtGui import *
         from PyQt5.QtWidgets import *
     except ImportError:
         try:
             from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR
             from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog
         except ImportError:
             raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")
     from EngineeringAbstractItem import QEngineeringAbstractItem
     from EngineeringLineItem import QEngineeringLineItem
     """
         A {ArrowItem} is the graphical representation of a {Symbol.Arrow}.
     """
     class QEngineeringArrowItem(QGraphicsPolygonItem, QEngineeringAbstractItem):
         """ This is engineering arrow item class """
         SMALL_SIZE = 10
         BIG_SIZE = 16
         HIGHLIGHT = '#BC4438'
         def __init__(self, polygon, parent=None):
             """ initialize arrow """
             QGraphicsPolygonItem.__init__(self, polygon, parent)
             QEngineeringAbstractItem.__init__(self)
             self.setFlag(QGraphicsItem.ItemIsSelectable, False)
             self.setFlag(QGraphicsItem.ItemIsFocusable, False)
             self.setFlag(QGraphicsItem.ItemStacksBehindParent, True)

         '''
         def mouseMoveEvent(self, event):
             import shapely
             from EngineeringArrowItem import QEngineeringArrowItem
             if self.parentItem() is not None and self._savedPos is not None:
                 if event.buttons() == Qt.LeftButton:
                     items = [item for item in self.scene().items(event.scenePos()) if item is not self and item is not self.parent and type(item) is not QGraphicsPixmapItem]
                     items = [item for item in self.scene().items(event.scenePos()) if item is not self and item is not self.parent and \
                         type(item) is not QGraphicsPixmapItem and type(item) is not QEngineeringArrowItem]
                     ## highlight underitem
                     if len(items) > 0:
                         if not hasattr(self, '_underItem') or self._underItem is not items[0]:

     import shapely
     class QEngineeringLineItem(QGraphicsLineItem, QEngineeringAbstractItem):
         """
         This is engineering line item
         """
         """ This is engineering line item """
         ARROW_SIZE = 30
         ZVALUE = 100
-...
                         connector.setZValue(self.zValue() + 1)
                         self.connectors.append(connector)
                     self.update_arrow()
                     self.setToolTip('({},{})-({},{})'.format(vertices[0][0], vertices[0][1], vertices[1][0], vertices[1][1]))
             except Exception as ex:
                 print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
-...
             line = self.line()
             self.setLine(QLineF(line.p2(), line.p1()))
             self.connectors[0], self.connectors[1] = self.connectors[1], self.connectors[0]
             self.update()
         '''
             @brief      add flow arrow
-...
                         self.lineType = 'Connect To Process'
         def hoverEnterEvent(self, event):
             """
             hilight item and it's children
             """
             """ hilight item and it's children """
             self.hover = True
             self.setZValue(QEngineeringAbstractItem.HOVER_ZVALUE)
             self.update()
             for connector in self.connectors:
                 connector.setZValue(self.zValue() + 1)
         def hoverLeaveEvent(self, event):
             """
             restore original color
             """
             """ restore original color """
             self.hover = False
             self.setZValue(QEngineeringLineItem.ZVALUE)
             self.update()
             for connector in self.connectors:
                 connector.setZValue(self.zValue() + 1)
         def hoverMoveEvent(self, event):
             pass
-...
                 self.scene().removeItem(self)
             elif event.key() == Qt.Key_C:
                 self.reverse()
                 rect = self.sceneBoundingRect()
                 rect.setRect(rect.left() - QEngineeringLineItem.ARROW_SIZE, rect.top() - QEngineeringLineItem.ARROW_SIZE,
                     rect.width() + QEngineeringLineItem.ARROW_SIZE*2, rect.height() + QEngineeringLineItem.ARROW_SIZE*2)
                 self.scene().invalidate(rect)
                 self.update_arrow()
         '''
             @brief  draw rect when item is selected
-...
             for child in self.childItems():
                 child.setBrush(self.pen().color())
             """
             if self.lineType == 'Primary' or self.lineType == 'Secondary':
                 ## draw direction mark
                 length = self.length()
-...
                     _dir = [(ptEnd[0] - ptStart[0])/self.length(), (ptEnd[1] - ptStart[1])/self.length()]
                     perpendicular = (-_dir[1], _dir[0])
                     polygon = QPolygonF()
                     polygon.append(QPointF(ptEnd[0] - _dir[0]*QEngineeringLineItem.ARROW_SIZE + perpendicular[0]*QEngineeringLineItem.ARROW_SIZE*0.25,
                                         ptEnd[1] - _dir[1]*QEngineeringLineItem.ARROW_SIZE + perpendicular[1]*QEngineeringLineItem.ARROW_SIZE*0.25))
                     polygon.append(QPointF(ptEnd[0] - _dir[0]*QEngineeringLineItem.ARROW_SIZE - perpendicular[0]*QEngineeringLineItem.ARROW_SIZE*0.25,
                                         ptEnd[1] - _dir[1]*QEngineeringLineItem.ARROW_SIZE - perpendicular[1]*QEngineeringLineItem.ARROW_SIZE*0.25))
                     polygon.append(QPointF(ptEnd[0], ptEnd[1]))
                     polygon.append(polygon[0])
                     _pen = self.pen()
                     _pen.setWidth(1)
                     painter.setPen(_pen)
                     painter.setBrush(QBrush(_pen.color()))
                     painter.drawConvexPolygon(polygon)
                 ## up to here
             """
             if self.isSelected():
                 self.drawFocusRect(painter)
-...
             self.setPen(_pen)
             self.update()
         def update_arrow(self):
             """ update flow arrow """
             from EngineeringArrowItem import QEngineeringArrowItem
             start = self.line().p1()
             end = self.line().p2()
             _dir = [(end.x() - start.x())/self.length(), (end.y() - start.y())/self.length()]
             perpendicular = (-_dir[1], _dir[0])
             polygon = QPolygonF()
             polygon.append(QPointF(end.x() - _dir[0]*QEngineeringLineItem.ARROW_SIZE + perpendicular[0]*QEngineeringLineItem.ARROW_SIZE*0.25,
                                 end.y() - _dir[1]*QEngineeringLineItem.ARROW_SIZE + perpendicular[1]*QEngineeringLineItem.ARROW_SIZE*0.25))
             polygon.append(QPointF(end.x() - _dir[0]*QEngineeringLineItem.ARROW_SIZE - perpendicular[0]*QEngineeringLineItem.ARROW_SIZE*0.25,
                                 end.y() - _dir[1]*QEngineeringLineItem.ARROW_SIZE - perpendicular[1]*QEngineeringLineItem.ARROW_SIZE*0.25))
             polygon.append(end)
             polygon.append(polygon[0])  # close polygon
             if not hasattr(self, '_arrow'):
                 self._arrow = QEngineeringArrowItem(polygon, self)
             else:
                 self._arrow.setPolygon(polygon)
             self._arrow.update()
         '''
             @brief      reshape line
             @author     humkyung
             @date       2018.07.27
         '''
         def onConnectorPosChaned(self, connector):
             from EngineeringArrowItem import QEngineeringArrowItem
             start = self.connectors[0].center()
             end = self.connectors[1].center()
             line = QLineF(QPointF(start[0], start[1]), QPointF(end[0], end[1]))
             self.setLine(line)
             #line = QLineF(QPointF(start[0], start[1]), QPointF(end[0], end[1]))
             self.setLine(start[0], start[1], end[0], end[1])
             self.update()
             self.update_arrow()
         '''
             @brief
             @author     humkyung
-...
             QGraphicsLineItem.mouseReleaseEvent(self, event)
         '''
             @brief      reshape line
             @author     humkyung
             @date       2018.07.24
         '''
         '''
         def mouseMoveEvent(self, event):
             import math
             from EngineeringConnectorItem import QEngineeringConnectorItem
             if event.buttons() == Qt.LeftButton and self._selectedIndex != -1:
                 if self._selectedIndex == 0:
                     item = self.scene().itemAt(event.scenePos(), QTransform())
                     if item is not None and type(item) is QEngineeringLineItem:
                         self.joinTo(item)
                     elif item is not None and type(item) is QEngineeringConnectorItem:
                         center = item.center()
                         line = QLineF(QPointF(center[0], center[1]), QPointF(self.endPoint()[0], self.endPoint()[1]))
                         self.setLine(line)
                     else:
                         pt = [event.scenePos().x(), event.scenePos().y()]
                         dx = abs(pt[0] - self.endPoint()[0])
                         dy = abs(pt[1] - self.endPoint()[1])
                         if dx < dy:
                             pt[0] = self.endPoint()[0]
                         else:
                             pt[1] = self.endPoint()[1]
                         line = QLineF(QPointF(pt[0], pt[1]), QPointF(self.endPoint()[0], self.endPoint()[1]))
                         self.setLine(line)
                 elif self._selectedIndex == 1:
                     item = self.scene().itemAt(event.scenePos(), QTransform())
                     if item is not None and type(item) is QEngineeringLineItem:
                         self.joinTo(item)
                     elif item is not None and type(item) is QEngineeringConnectorItem:
                         center = item.center()
                         line = QLineF(QPointF(self.startPoint()[0], self.startPoint()[1]), QPointF(center[0], center[1]))
                         self.setLine(line)
                     else:
                         pt = [event.scenePos().x(), event.scenePos().y()]
                         dx = abs(pt[0] - self.startPoint()[0])
                         dy = abs(pt[1] - self.startPoint()[1])
                         if dx < dy:
                             pt[0] = self.startPoint()[0]
                         else:
                             pt[1] = self.startPoint()[1]
                         line = QLineF(QPointF(self.startPoint()[0], self.startPoint()[1]), QPointF(pt[0], pt[1]))
                         self.setLine(line)
                 self.update()
             else:
                 self._selectedIndex = -1
                 pos = event.scenePos()
                 ptStart = self.startPoint()
                 dx = ptStart[0] - pos.x()
                 dy = ptStart[1] - pos.y()
                 if math.sqrt(dx*dx + dy*dy) < 10:
                     self._selectedIndex = 0
                 ptEnd = self.endPoint()
                 dx = ptEnd[0] - pos.x()
                 dy = ptEnd[1] - pos.y()
                 if math.sqrt(dx*dx + dy*dy) < 10:
                     self._selectedIndex = 1
                 self.update()
             QGraphicsLineItem.mouseMoveEvent(self, event)
         '''
     '''
         @brief      The class transfer pyqtSignal Event. Cause Subclass of QGraphicsRectItem can't use pyqtSignal
         @author     Jeongwoo

             self._runs = []
         def setVisible(self, visible):
             """
             override visible value
             """
             """ override visible value """
             super(QEngineeringTextItem, self).setVisible(visible)
             for run in self.runs:
                 run.visible = visible
-...
             return visited
         def explode(self):
             """ explode line no """
             try:
                 for run in self.runs:
                     run.explode()
             finally:
                 self.runs.clear()
         '''
             @brief      save Line Data
             @author     kyouho

         @property
         def visible(self):
             """
             return visible
             """
             """ return visible """
             return self._visible
         @visible.setter
-...
         def items(self, value):
             self._items = value
         def explode(self):
             """ explode run """
             try:
                 for item in self.items:
                     item.owner = None
             finally:
                 self.items.clear()
         '''
             @brief  get two points which's length is max
             @author humkyung

ID	9ff6820d2111ad361cfdceee3c7ff984f746dfd9
상위	45a42a9d
하위	092db086, a208ed03

프로젝트

일반

사용자정보

HYTOS

개정판 9ff6820d