개정판 c82b5644
issue #563: set uid type of item to UUID, fixed run flow direction
Change-Id: I9c6299b728fad4cc50c2c08592abe88d5dda6df3
| DTI_PID/DTI_PID/ConnectAttrDialog.py | ||
|---|---|---|
| 47 | 47 |
''' |
| 48 | 48 |
''' |
| 49 | 49 |
class QConnectAttrDialog(QDialog): |
| 50 |
'''
|
|
| 51 |
''' |
|
| 50 |
""" This is connect attr dialog class """
|
|
| 51 |
|
|
| 52 | 52 |
def __init__(self, parent, graphicsView): #Parent is MainWindow |
| 53 | 53 |
import ConnectAttr_UI |
| 54 | 54 |
|
| ... | ... | |
| 58 | 58 |
self.graphicsView = graphicsView |
| 59 | 59 |
self.ui = ConnectAttr_UI.Ui_ConnectAttr() |
| 60 | 60 |
self.ui.setupUi(self) |
| 61 |
self.ui.pushButtonStart.setFocus() |
|
| 61 | 62 |
self.ui.buttonBox.setEnabled(True) |
| 62 | 63 |
self.ui.listWidget.model().rowsInserted.connect(self.rowInserted) ## connect to func rowInserted(self, item) |
| 63 | 64 |
self.isAccepted = False |
| DTI_PID/DTI_PID/ConnectAttr_UI.py | ||
|---|---|---|
| 1 | 1 |
# -*- coding: utf-8 -*- |
| 2 | 2 |
|
| 3 |
# Form implementation generated from reading ui file './UI/dlgConnectAttr.ui'
|
|
| 3 |
# Form implementation generated from reading ui file '.\UI\dlgConnectAttr.ui'
|
|
| 4 | 4 |
# |
| 5 | 5 |
# Created by: PyQt5 UI code generator 5.11.3 |
| 6 | 6 |
# |
| ... | ... | |
| 56 | 56 |
self.retranslateUi(ConnectAttr) |
| 57 | 57 |
self.buttonBox.clicked['QAbstractButton*'].connect(ConnectAttr.accept) |
| 58 | 58 |
QtCore.QMetaObject.connectSlotsByName(ConnectAttr) |
| 59 |
ConnectAttr.setTabOrder(self.pushButtonStart, self.listWidget) |
|
| 59 | 60 |
|
| 60 | 61 |
def retranslateUi(self, ConnectAttr): |
| 61 | 62 |
_translate = QtCore.QCoreApplication.translate |
| 62 | 63 |
ConnectAttr.setWindowTitle(_translate("ConnectAttr", "Connect Attribute"))
|
| 63 | 64 |
self.pushButtonStart.setText(_translate("ConnectAttr", "Start"))
|
| 64 | 65 |
|
| 65 |
|
|
| 66 |
if __name__ == "__main__": |
|
| 67 |
import sys |
|
| 68 |
app = QtWidgets.QApplication(sys.argv) |
|
| 69 |
ConnectAttr = QtWidgets.QDialog() |
|
| 70 |
ui = Ui_ConnectAttr() |
|
| 71 |
ui.setupUi(ConnectAttr) |
|
| 72 |
ConnectAttr.show() |
|
| 73 |
sys.exit(app.exec_()) |
|
| 74 |
|
|
| DTI_PID/DTI_PID/ItemPropertyTableWidget.py | ||
|---|---|---|
| 689 | 689 |
if attr.Attribute == keyCell.text(): |
| 690 | 690 |
items[0].attrs[attr] = None |
| 691 | 691 |
self.show_item_property(items[0]) |
| 692 |
elif (event.key() == Qt.Key_C) and (event.modifiers() & Qt.ControlModifier): |
|
| 693 |
self.copy_cells_to_clipboard() |
|
| 694 |
event.accept() |
|
| 695 |
|
|
| 696 |
def copy_cells_to_clipboard(self): |
|
| 697 |
""" copy selected text to clipboard """ |
|
| 698 |
|
|
| 699 |
selection = self.selectedIndexes() |
|
| 700 |
if selection: |
|
| 701 |
rows = sorted(index.row() for index in selection) |
|
| 702 |
columns = sorted(index.column() for index in selection) |
|
| 703 |
text = self.item(rows[-1], columns[-1]).text() |
|
| 704 |
QApplication.clipboard().setText(text) |
|
| 692 | 705 |
|
| 693 | 706 |
''' |
| 694 | 707 |
@brief int cell check |
| DTI_PID/DTI_PID/ItemTreeWidget.py | ||
|---|---|---|
| 116 | 116 |
event.ignore() |
| 117 | 117 |
except Exception as ex: |
| 118 | 118 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
| 119 |
|
|
| 119 |
|
|
| 120 | 120 |
''' |
| 121 | 121 |
@brief Show Context Menu |
| 122 | 122 |
@author Jeongwoo |
| ... | ... | |
| 148 | 148 |
lineTypeAction = QAction(self.tr("Select Line Type"))
|
| 149 | 149 |
lineTypeAction.triggered.connect(lambda : self.lineTypeClickEvent(item)) |
| 150 | 150 |
menu.addAction(lineTypeAction) |
| 151 |
explode_action = QAction(self.tr("Explode"))
|
|
| 152 |
explode_action.triggered.connect(lambda : self.explode_line_run(item)) |
|
| 153 |
menu.addAction(explode_action) |
|
| 151 | 154 |
menu.exec_(self.viewport().mapToGlobal(position)) |
| 152 | 155 |
|
| 153 | 156 |
''' |
| ... | ... | |
| 172 | 175 |
connectedItem.setColor(color.name()) |
| 173 | 176 |
self.changeTreeWidgetItemColorRecursively(lineNoTreeWidgetItem, color) |
| 174 | 177 |
|
| 178 |
def explode_line_run(self, tree_widget_item): |
|
| 179 |
""" explode line run """ |
|
| 180 |
|
|
| 181 |
try: |
|
| 182 |
line_run = tree_widget_item.data(0, self.TREE_DATA_ROLE) |
|
| 183 |
if line_run: |
|
| 184 |
for item in line_run.items: |
|
| 185 |
if issubclass(type(item), SymbolSvgItem): self.addTreeItem(self.SymbolsTreeItem, item) |
|
| 186 |
|
|
| 187 |
for i in reversed(range(tree_widget_item.childCount())): |
|
| 188 |
tree_widget_item.takeChild(i) |
|
| 189 |
|
|
| 190 |
line_no = tree_widget_item.parent().data(0, self.TREE_DATA_ROLE) |
|
| 191 |
line_no.runs.remove(line_run) |
|
| 192 |
|
|
| 193 |
line_run.explode() |
|
| 194 |
tree_widget_item.parent().takeChild(tree_widget_item.parent().indexOfChild(tree_widget_item)) |
|
| 195 |
finally: |
|
| 196 |
pass |
|
| 197 |
|
|
| 175 | 198 |
def explode_line_no(self, lineNoTreeWidgetItem): |
| 176 | 199 |
""" explode line no """ |
| 177 | 200 |
|
| DTI_PID/DTI_PID/LineNoTracer.py | ||
|---|---|---|
| 99 | 99 |
for item in connectedItems: |
| 100 | 100 |
item.owner = line_matches[0].owner if line_matches else symbol_matches[0].owner # set item's owner |
| 101 | 101 |
|
| 102 |
pipeRun = QEngineeringRunItem() |
|
| 103 |
pipeRun.items = connectedItems |
|
| 104 |
if pipeRun.items is not None and len(pipeRun.items) > 0: |
|
| 105 |
line_matches[0].owner.runs.append(pipeRun) if line_matches else symbol_matches[0].owner.runs.append(pipeRun) |
|
| 102 |
pipe_run = QEngineeringRunItem() |
|
| 103 |
pipe_run.items = connectedItems |
|
| 104 |
pipe_run.arrange_flow_direction() |
|
| 105 |
if pipe_run.items is not None and len(pipe_run.items) > 0: |
|
| 106 |
line_matches[0].owner.runs.append(pipe_run) if line_matches else symbol_matches[0].owner.runs.append(pipe_run) |
|
| 106 | 107 |
else: |
| 107 | 108 |
notMatches.append(line) |
| 108 | 109 |
lines = notMatches |
| DTI_PID/DTI_PID/MainWindow.py | ||
|---|---|---|
| 638 | 638 |
def saveToXml(self, alert = True): |
| 639 | 639 |
import XmlGenerator as xg |
| 640 | 640 |
from AppDocData import AppDocData |
| 641 |
docData = AppDocData.instance() |
|
| 642 |
if docData.imgName is None: |
|
| 643 |
self.showImageSelectionMessageBox() |
|
| 644 |
return |
|
| 645 |
result = xg.writeXmlOnScene(docData.imgName, docData.imgWidth, docData.imgHeight) |
|
| 646 |
|
|
| 647 |
if len(self.removedItems['LINE']): |
|
| 648 |
docData.deleteLineDataList_LineNo(self.removedItems['LINE']) |
|
| 649 |
self.removedItems['LINE'] = [] |
|
| 650 |
|
|
| 651 |
if len(self.removedItems['EQUIP']): |
|
| 652 |
docData.deleteEquipDataList(self.removedItems['EQUIP']) |
|
| 653 |
self.removedItems['EQUIP'] = [] |
|
| 654 |
|
|
| 655 |
if len(self.removedItems['INST']): |
|
| 656 |
docData.deleteInstDataList(self.removedItems['INST']) |
|
| 657 |
self.removedItems['INST'] = [] |
|
| 658 |
|
|
| 659 |
if len(self.removedItems['NOTE']): |
|
| 660 |
docData.deleteNoteDataList(self.removedItems['NOTE']) |
|
| 661 |
self.removedItems['NOTE'] = [] |
|
| 662 | 641 |
|
| 663 |
|
|
| 664 |
if alert: |
|
| 665 |
resultStr = '[저장 결과]' |
|
| 666 |
|
|
| 667 |
for item in result.items(): |
|
| 668 |
itemName = str(item[0]) |
|
| 669 |
itemSuccessCount = str(item[1][0]) |
|
| 670 |
itemFailUidList = item[1][1] |
|
| 671 |
resultStr += "\r\n" + itemName + " Save Count : " + itemSuccessCount |
|
| 672 |
if len(itemFailUidList) > 0: |
|
| 673 |
resultStr += "\r\n" + itemName + " Error List(UID)" |
|
| 674 |
for uid in itemFailUidList: |
|
| 675 |
resultStr += "\r\n" + uid |
|
| 676 |
|
|
| 677 |
QMessageBox.about(self.graphicsView, self.tr('Notice'), resultStr)
|
|
| 642 |
try: |
|
| 643 |
docData = AppDocData.instance() |
|
| 644 |
if docData.imgName is None: |
|
| 645 |
self.showImageSelectionMessageBox() |
|
| 646 |
return |
|
| 647 |
result = xg.writeXmlOnScene(docData.imgName, docData.imgWidth, docData.imgHeight) |
|
| 648 |
|
|
| 649 |
if len(self.removedItems['LINE']): |
|
| 650 |
docData.deleteLineDataList_LineNo(self.removedItems['LINE']) |
|
| 651 |
self.removedItems['LINE'] = [] |
|
| 652 |
|
|
| 653 |
if len(self.removedItems['EQUIP']): |
|
| 654 |
docData.deleteEquipDataList(self.removedItems['EQUIP']) |
|
| 655 |
self.removedItems['EQUIP'] = [] |
|
| 656 |
|
|
| 657 |
if len(self.removedItems['INST']): |
|
| 658 |
docData.deleteInstDataList(self.removedItems['INST']) |
|
| 659 |
self.removedItems['INST'] = [] |
|
| 660 |
|
|
| 661 |
if len(self.removedItems['NOTE']): |
|
| 662 |
docData.deleteNoteDataList(self.removedItems['NOTE']) |
|
| 663 |
self.removedItems['NOTE'] = [] |
|
| 664 |
|
|
| 665 |
if alert: |
|
| 666 |
resultStr = '[저장 결과]' |
|
| 667 |
|
|
| 668 |
for item in result.items(): |
|
| 669 |
itemName = str(item[0]) |
|
| 670 |
itemSuccessCount = str(item[1][0]) |
|
| 671 |
itemFailUidList = item[1][1] |
|
| 672 |
resultStr += "\r\n" + itemName + " Save Count : " + itemSuccessCount |
|
| 673 |
if len(itemFailUidList) > 0: |
|
| 674 |
resultStr += "\r\n" + itemName + " Error List(UID)" |
|
| 675 |
for uid in itemFailUidList: |
|
| 676 |
resultStr += "\r\n" + uid |
|
| 677 |
|
|
| 678 |
QMessageBox.about(self.graphicsView, self.tr('Notice'), resultStr)
|
|
| 679 |
except Exception as ex: |
|
| 680 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
|
| 681 |
self.addMessage.emit(MessageType.Error, message) |
|
| 678 | 682 |
|
| 679 | 683 |
''' |
| 680 | 684 |
@brief refresh resultPropertyTableWidget |
| DTI_PID/DTI_PID/Shapes/EngineeringArrowItem.py | ||
|---|---|---|
| 20 | 20 |
""" |
| 21 | 21 |
A {ArrowItem} is the graphical representation of a {Symbol.Arrow}.
|
| 22 | 22 |
""" |
| 23 |
class QEngineeringArrowItem(QGraphicsPolygonItem, QEngineeringAbstractItem):
|
|
| 23 |
class QEngineeringArrowItem(QGraphicsPolygonItem): |
|
| 24 | 24 |
""" This is engineering arrow item class """ |
| 25 | 25 |
SMALL_SIZE = 10 |
| 26 | 26 |
BIG_SIZE = 16 |
| ... | ... | |
| 30 | 30 |
""" initialize arrow """ |
| 31 | 31 |
|
| 32 | 32 |
QGraphicsPolygonItem.__init__(self, polygon, parent) |
| 33 |
QEngineeringAbstractItem.__init__(self) |
|
| 33 |
#QEngineeringAbstractItem.__init__(self)
|
|
| 34 | 34 |
|
| 35 | 35 |
self.setFlag(QGraphicsItem.ItemIsSelectable, False) |
| 36 | 36 |
self.setFlag(QGraphicsItem.ItemIsFocusable, False) |
| DTI_PID/DTI_PID/Shapes/EngineeringConnectorItem.py | ||
|---|---|---|
| 45 | 45 |
|
| 46 | 46 |
QGraphicsEllipseItem.__init__(self, parent) |
| 47 | 47 |
|
| 48 |
self.uid = uuid.uuid4() if uid is None else uid
|
|
| 48 |
self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)
|
|
| 49 | 49 |
self.parent = parent |
| 50 | 50 |
self.buildItem() |
| 51 | 51 |
self._direction = 'AUTO' |
| ... | ... | |
| 241 | 241 |
''' |
| 242 | 242 |
def mouseReleaseEvent(self, event): |
| 243 | 243 |
import shapely |
| 244 |
if self.parentItem() is not None and self._savedPos is not None: |
|
| 245 |
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] |
|
| 246 |
|
|
| 247 |
if items and type(items[0]) is QEngineeringLineItem: |
|
| 248 |
length = items[0].length()*0.5 |
|
| 249 |
dir = items[0].perpendicular() |
|
| 250 |
if self.parent.isHorizontal(): |
|
| 251 |
start = [event.scenePos().x() - dir[0]*length, self.parent.startPoint()[1] - dir[1]*length] |
|
| 252 |
end = [event.scenePos().x() + dir[0]*length, self.parent.startPoint()[1] + dir[1]*length] |
|
| 244 |
|
|
| 245 |
try: |
|
| 246 |
if self.parentItem() is not None and self._savedPos is not None: |
|
| 247 |
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] |
|
| 248 |
|
|
| 249 |
if items and type(items[0]) is QEngineeringLineItem: |
|
| 250 |
length = items[0].length()*0.5 |
|
| 251 |
dir = items[0].perpendicular() |
|
| 252 |
if self.parent.isHorizontal(): |
|
| 253 |
start = [event.scenePos().x() - dir[0]*length, self.parent.startPoint()[1] - dir[1]*length] |
|
| 254 |
end = [event.scenePos().x() + dir[0]*length, self.parent.startPoint()[1] + dir[1]*length] |
|
| 255 |
else: |
|
| 256 |
start = [self.parent.startPoint()[0] - dir[0]*length, event.scenePos().y() - dir[1]*length] |
|
| 257 |
end = [self.parent.startPoint()[0] + dir[0]*length, event.scenePos().y() + dir[1]*length] |
|
| 258 |
|
|
| 259 |
pt = items[0].intersection([start, end]) |
|
| 260 |
if (pt is not None) and (type(pt) == shapely.geometry.point.Point): |
|
| 261 |
self.setPos((pt.x, pt.y)) |
|
| 262 |
self.connect(items[0], QEngineeringAbstractItem.CONNECTED_AT_BODY) |
|
| 263 |
elif items and type(items[0]) is QEngineeringConnectorItem: |
|
| 264 |
self.setPos(items[0].center()) |
|
| 265 |
|
|
| 266 |
if self.connectedItem is not None: |
|
| 267 |
for connect in self.connectedItem.connectors: |
|
| 268 |
if connect.connectedItem == self.parent: |
|
| 269 |
connect.connect(None) |
|
| 270 |
|
|
| 271 |
self.connect(items[0].parent) |
|
| 272 |
items[0].connect(self.parent) |
|
| 253 | 273 |
else: |
| 254 |
start = [self.parent.startPoint()[0] - dir[0]*length, event.scenePos().y() - dir[1]*length] |
|
| 255 |
end = [self.parent.startPoint()[0] + dir[0]*length, event.scenePos().y() + dir[1]*length] |
|
| 256 |
|
|
| 257 |
pt = items[0].intersection([start, end]) |
|
| 258 |
if (pt is not None) and (type(pt) == shapely.geometry.point.Point): |
|
| 259 |
self.setPos((pt.x, pt.y)) |
|
| 260 |
self.connect(items[0], QEngineeringAbstractItem.CONNECTED_AT_BODY) |
|
| 261 |
elif items and type(items[0]) is QEngineeringConnectorItem: |
|
| 262 |
self.setPos(items[0].center()) |
|
| 263 |
|
|
| 264 |
if self.connectedItem is not None: |
|
| 265 |
for connect in self.connectedItem.connectors: |
|
| 266 |
if connect.connectedItem == self.parent: |
|
| 267 |
connect.connect(None) |
|
| 274 |
pt = [event.scenePos().x(), event.scenePos().y()] |
|
| 275 |
if self._drawing_mode == QEngineeringConnectorItem.AXIS_MODE: |
|
| 276 |
if len(self.parentItem().connectors) == 2: |
|
| 277 |
other = [connector for connector in self.parent.connectors if connector is not self] |
|
| 278 |
if other: |
|
| 279 |
pt = [event.scenePos().x(), event.scenePos().y()] |
|
| 280 |
dx = abs(pt[0] - other[0].center()[0]) |
|
| 281 |
dy = abs(pt[1] - other[0].center()[1]) |
|
| 282 |
if dx < dy: |
|
| 283 |
pt[0] = other[0].center()[0] |
|
| 284 |
else: |
|
| 285 |
pt[1] = other[0].center()[1] |
|
| 268 | 286 |
|
| 269 |
self.connect(items[0].parent) |
|
| 270 |
items[0].connect(self.parent) |
|
| 271 |
else: |
|
| 272 |
pt = [event.scenePos().x(), event.scenePos().y()] |
|
| 273 |
if self._drawing_mode == QEngineeringConnectorItem.AXIS_MODE: |
|
| 274 |
if len(self.parentItem().connectors) == 2: |
|
| 275 |
other = [connector for connector in self.parent.connectors if connector is not self] |
|
| 276 |
if other: |
|
| 277 |
pt = [event.scenePos().x(), event.scenePos().y()] |
|
| 278 |
dx = abs(pt[0] - other[0].center()[0]) |
|
| 279 |
dy = abs(pt[1] - other[0].center()[1]) |
|
| 280 |
if dx < dy: |
|
| 281 |
pt[0] = other[0].center()[0] |
|
| 282 |
else: |
|
| 283 |
pt[1] = other[0].center()[1] |
|
| 284 |
|
|
| 285 |
self.setPos(pt) |
|
| 286 |
if self.connectedItem is not None: |
|
| 287 |
for connect in self.connectedItem.connectors: |
|
| 288 |
if connect.connectedItem == self.parent: |
|
| 289 |
connect.connect(None) |
|
| 290 |
|
|
| 291 |
self.connect(None) |
|
| 292 |
|
|
| 293 |
## unhighlight underitem |
|
| 294 |
if hasattr(self, '_underItem') and self._underItem is not None: |
|
| 295 |
self._underItem.hoverLeaveEvent(event) |
|
| 296 |
## up to here |
|
| 287 |
self.setPos(pt) |
|
| 288 |
if self.connectedItem is not None: |
|
| 289 |
for connect in self.connectedItem.connectors: |
|
| 290 |
if connect.connectedItem == self.parent: |
|
| 291 |
connect.connect(None) |
|
| 297 | 292 |
|
| 298 |
if self.parentItem() is not None: |
|
| 299 |
self._savedPos = None |
|
| 300 |
self._savedConnectedItem = None |
|
| 293 |
self.connect(None) |
|
| 294 |
|
|
| 295 |
## unhighlight underitem |
|
| 296 |
if hasattr(self, '_underItem') and self._underItem is not None: |
|
| 297 |
self._underItem.hoverLeaveEvent(event) |
|
| 298 |
## up to here |
|
| 299 |
|
|
| 300 |
if self.parentItem() is not None: |
|
| 301 |
self._savedPos = None |
|
| 302 |
self._savedConnectedItem = None |
|
| 303 |
self.transfer.onPosChanged.emit(self) |
|
| 304 |
finally: |
|
| 301 | 305 |
self.ungrabKeyboard() |
| 302 |
self.transfer.onPosChanged.emit(self) |
|
| 303 | 306 |
|
| 304 | 307 |
QGraphicsEllipseItem.mouseReleaseEvent(self, event) |
| 305 | 308 |
|
| ... | ... | |
| 373 | 376 |
def keyPressEvent(self, event): |
| 374 | 377 |
if event.key() == Qt.Key_Escape: |
| 375 | 378 |
if hasattr(self, '_savedPos') and self._savedPos is not None: |
| 376 |
self.ungrabKeyboard() |
|
| 377 | 379 |
self.setPos(self._savedPos) |
| 378 | 380 |
self.connectedItem = self._savedConnectedItem |
| 379 | 381 |
self._savedPos = None |
| ... | ... | |
| 405 | 407 |
|
| 406 | 408 |
def parse_xml(self, node): |
| 407 | 409 |
""" parse given node """ |
| 410 |
import uuid |
|
| 411 |
|
|
| 412 |
if 'UID' in node.attrib: self.uid = uuid.UUID(node.attrib['UID'], version=4) |
|
| 413 |
|
|
| 408 | 414 |
if 'CONNECTED_AT' in node.attrib: |
| 409 | 415 |
self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT if node.attrib['CONNECTED_AT'] == '0' else QEngineeringAbstractItem.CONNECTED_AT_BODY |
| 410 | 416 |
else: |
| ... | ... | |
| 432 | 438 |
""" generate xml code for connector """ |
| 433 | 439 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree |
| 434 | 440 |
|
| 435 |
node = Element('CONNECTOR')
|
|
| 436 |
node.attrib['CONNECTED_AT'] = str(self._connected_at) |
|
| 437 |
connectedItemNode = Element('CONNECTEDITEM')
|
|
| 438 |
connectedItemNode.text = str(self.connectedItem.uid) if self.connectedItem is not None else 'None' |
|
| 439 |
connectPointNode = Element('CONNECTPOINT')
|
|
| 440 |
connectPointNode.text = str(self.connectPoint[0]) + ',' + str(self.connectPoint[1]) |
|
| 441 |
sceneConnectPointNode = Element('SCENECONNECTPOINT')
|
|
| 442 |
sceneConnectPointNode.text = str(self.sceneConnectPoint[0]) + ',' + str(self.sceneConnectPoint[1]) |
|
| 443 |
|
|
| 444 |
node.append(connectedItemNode) |
|
| 445 |
node.append(connectPointNode) |
|
| 446 |
node.append(sceneConnectPointNode) |
|
| 441 |
try: |
|
| 442 |
node = Element('CONNECTOR')
|
|
| 443 |
node.attrib['UID'] = str(self.uid) |
|
| 444 |
node.attrib['CONNECTED_AT'] = str(self._connected_at) |
|
| 445 |
connectedItemNode = Element('CONNECTEDITEM')
|
|
| 446 |
connectedItemNode.text = str(self.connectedItem.uid) if self.connectedItem else 'None' |
|
| 447 |
connectPointNode = Element('CONNECTPOINT')
|
|
| 448 |
connectPointNode.text = str(self.connectPoint[0]) + ',' + str(self.connectPoint[1]) |
|
| 449 |
sceneConnectPointNode = Element('SCENECONNECTPOINT')
|
|
| 450 |
sceneConnectPointNode.text = str(self.sceneConnectPoint[0]) + ',' + str(self.sceneConnectPoint[1]) |
|
| 451 |
|
|
| 452 |
node.append(connectedItemNode) |
|
| 453 |
node.append(connectPointNode) |
|
| 454 |
node.append(sceneConnectPointNode) |
|
| 455 |
except Exception as ex: |
|
| 456 |
from App import App |
|
| 457 |
from AppDocData import MessageType |
|
| 458 |
|
|
| 459 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
|
| 460 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
|
| 461 |
return None |
|
| 447 | 462 |
|
| 448 | 463 |
return node |
| 449 | 464 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringEquipmentItem.py | ||
|---|---|---|
| 146 | 146 |
node = SymbolSvgItem.toXml(self) |
| 147 | 147 |
self.toXmlAsAttribute(node) |
| 148 | 148 |
except Exception as ex: |
| 149 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
|
| 149 |
from App import App |
|
| 150 |
from AppDocData import MessageType |
|
| 151 |
|
|
| 152 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
|
| 153 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
|
| 154 |
|
|
| 155 |
return None |
|
| 150 | 156 |
|
| 151 | 157 |
return node |
| 152 | 158 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringInstrumentItem.py | ||
|---|---|---|
| 17 | 17 |
from UserInputAttribute import UserInputAttribute |
| 18 | 18 |
|
| 19 | 19 |
class QEngineeringInstrumentItem(SymbolSvgItem): |
| 20 |
""" |
|
| 21 |
This is Engineering Instrument Item class |
|
| 22 |
""" |
|
| 20 |
""" This is Engineering Instrument Item class """ |
|
| 23 | 21 |
clicked = pyqtSignal(QGraphicsSvgItem) |
| 24 | 22 |
INST_COLUMN_LIST = None |
| 25 | 23 |
INST_COLOR = None |
| DTI_PID/DTI_PID/Shapes/EngineeringLineItem.py | ||
|---|---|---|
| 40 | 40 |
QGraphicsLineItem.__init__(self, parent) |
| 41 | 41 |
QEngineeringAbstractItem.__init__(self) |
| 42 | 42 |
|
| 43 |
self.uid = str(uuid.uuid4()) if uid is None else uuid.UUID(uid)
|
|
| 43 |
self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)
|
|
| 44 | 44 |
self.thickness = thickness |
| 45 | 45 |
|
| 46 | 46 |
self.setPen(QPen(Qt.blue, 4, Qt.SolidLine)) # set default pen |
| ... | ... | |
| 976 | 976 |
@history swap start, end point when user press 'c' key |
| 977 | 977 |
''' |
| 978 | 978 |
def keyPressEvent(self, event): |
| 979 |
if event.key() == Qt.Key_Delete: |
|
| 979 |
if self.isSelected() and event.key() == Qt.Key_Delete:
|
|
| 980 | 980 |
self.scene().removeItem(self) |
| 981 | 981 |
elif event.key() == Qt.Key_C: |
| 982 | 982 |
self.reverse() |
| ... | ... | |
| 1138 | 1138 |
|
| 1139 | 1139 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 1140 | 1140 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 1141 |
return str(self.uid)
|
|
| 1141 |
return None
|
|
| 1142 | 1142 |
|
| 1143 | 1143 |
return node |
| 1144 | 1144 |
|
| ... | ... | |
| 1213 | 1213 |
else: |
| 1214 | 1214 |
self._arrow.setPolygon(polygon) |
| 1215 | 1215 |
|
| 1216 |
self._arrow.setBrush(Qt.blue) |
|
| 1216 | 1217 |
self._arrow.update() |
| 1217 | 1218 |
|
| 1218 | 1219 |
''' |
| DTI_PID/DTI_PID/Shapes/EngineeringLineNoTextItem.py | ||
|---|---|---|
| 321 | 321 |
|
| 322 | 322 |
if self.conns: |
| 323 | 323 |
connNode = Element('CONNLINE')
|
| 324 |
connNode.text = self.conns[0].uid
|
|
| 324 |
connNode.text = str(self.conns[0].uid)
|
|
| 325 | 325 |
node.append(connNode) |
| 326 | 326 |
|
| 327 | 327 |
except Exception as ex: |
| ... | ... | |
| 331 | 331 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 332 | 332 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 333 | 333 |
|
| 334 |
return str(self.uid)
|
|
| 334 |
return None
|
|
| 335 | 335 |
|
| 336 | 336 |
return node |
| 337 | 337 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringNozzleItem.py | ||
|---|---|---|
| 63 | 63 |
minDist = dist |
| 64 | 64 |
selected = attr |
| 65 | 65 |
|
| 66 |
if selected is not None: self.attrs.append(selected) |
|
| 67 |
|
|
| 68 |
''' |
|
| 69 |
@brief generate xml code for nozzle |
|
| 70 |
@author humkyung |
|
| 71 |
@date 2018.07.19 |
|
| 72 |
''' |
|
| 73 |
def toXml(self): |
|
| 74 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree |
|
| 75 |
|
|
| 76 |
try: |
|
| 77 |
node = SymbolSvgItem.toXml(self) |
|
| 78 |
except Exception as ex: |
|
| 79 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
|
| 80 |
|
|
| 81 |
return node |
|
| 66 |
if selected is not None: self.attrs.append(selected) |
|
| DTI_PID/DTI_PID/Shapes/EngineeringOriginItem.py | ||
|---|---|---|
| 139 | 139 |
''' |
| 140 | 140 |
def mouseReleaseEvent(self, event): |
| 141 | 141 |
import shapely |
| 142 |
if type(self.parent) is QEngineeringLineItem and self._savedPos is not None: |
|
| 143 |
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] |
|
| 144 |
|
|
| 145 |
if items and type(items[0]) is QEngineeringLineItem: |
|
| 146 |
length = items[0].length()*0.5 |
|
| 147 |
dir = items[0].perpendicular() |
|
| 148 |
if self.parent.isHorizontal(): |
|
| 149 |
start = [event.scenePos().x() - dir[0]*length, self.parent.startPoint()[1] - dir[1]*length] |
|
| 150 |
end = [event.scenePos().x() + dir[0]*length, self.parent.startPoint()[1] + dir[1]*length] |
|
| 151 |
else: |
|
| 152 |
start = [self.parent.startPoint()[0] - dir[0]*length, event.scenePos().y() - dir[1]*length] |
|
| 153 |
end = [self.parent.startPoint()[0] + dir[0]*length, event.scenePos().y() + dir[1]*length] |
|
| 154 |
|
|
| 155 |
pt = items[0].intersection([start, end]) |
|
| 156 |
if (pt is not None) and (type(pt) == shapely.geometry.point.Point): |
|
| 157 |
self.setPos((pt.x, pt.y)) |
|
| 158 |
self.connectedItem = items[0] |
|
| 159 |
elif items and type(items[0]) is QEngineeringConnectorItem: |
|
| 160 |
self.setPos(items[0].center()) |
|
| 161 |
|
|
| 162 |
if self.connectedItem is not None: |
|
| 163 |
for connect in self.connectedItem.connectors: |
|
| 164 |
if connect.connectedItem == self.parent: |
|
| 165 |
connect.connectedItem = None |
|
| 166 | 142 |
|
| 167 |
self.connectedItem = items[0].parent
|
|
| 168 |
items[0].connectedItem = self.parent
|
|
| 169 |
else:
|
|
| 170 |
other = [connector for connector in self.parent.connectors if connector is not self] |
|
| 171 |
if other:
|
|
| 172 |
pt = [event.scenePos().x(), event.scenePos().y()]
|
|
| 173 |
dx = abs(pt[0] - other[0].center()[0])
|
|
| 174 |
dy = abs(pt[1] - other[0].center()[1])
|
|
| 175 |
if dx < dy:
|
|
| 176 |
pt[0] = other[0].center()[0]
|
|
| 143 |
try:
|
|
| 144 |
if type(self.parent) is QEngineeringLineItem and self._savedPos is not None:
|
|
| 145 |
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]
|
|
| 146 |
|
|
| 147 |
if items and type(items[0]) is QEngineeringLineItem:
|
|
| 148 |
length = items[0].length()*0.5
|
|
| 149 |
dir = items[0].perpendicular()
|
|
| 150 |
if self.parent.isHorizontal():
|
|
| 151 |
start = [event.scenePos().x() - dir[0]*length, self.parent.startPoint()[1] - dir[1]*length]
|
|
| 152 |
end = [event.scenePos().x() + dir[0]*length, self.parent.startPoint()[1] + dir[1]*length]
|
|
| 177 | 153 |
else: |
| 178 |
pt[1] = other[0].center()[1] |
|
| 154 |
start = [self.parent.startPoint()[0] - dir[0]*length, event.scenePos().y() - dir[1]*length] |
|
| 155 |
end = [self.parent.startPoint()[0] + dir[0]*length, event.scenePos().y() + dir[1]*length] |
|
| 179 | 156 |
|
| 180 |
self.setPos(pt) |
|
| 181 |
if self.connectedItem is not None: |
|
| 182 |
for connect in self.connectedItem.connectors: |
|
| 183 |
if connect.connectedItem == self.parent: |
|
| 184 |
connect.connectedItem = None |
|
| 157 |
pt = items[0].intersection([start, end]) |
|
| 158 |
if (pt is not None) and (type(pt) == shapely.geometry.point.Point): |
|
| 159 |
self.setPos((pt.x, pt.y)) |
|
| 160 |
self.connectedItem = items[0] |
|
| 161 |
elif items and type(items[0]) is QEngineeringConnectorItem: |
|
| 162 |
self.setPos(items[0].center()) |
|
| 163 |
|
|
| 164 |
if self.connectedItem is not None: |
|
| 165 |
for connect in self.connectedItem.connectors: |
|
| 166 |
if connect.connectedItem == self.parent: |
|
| 167 |
connect.connectedItem = None |
|
| 168 |
|
|
| 169 |
self.connectedItem = items[0].parent |
|
| 170 |
items[0].connectedItem = self.parent |
|
| 171 |
else: |
|
| 172 |
other = [connector for connector in self.parent.connectors if connector is not self] |
|
| 173 |
if other: |
|
| 174 |
pt = [event.scenePos().x(), event.scenePos().y()] |
|
| 175 |
dx = abs(pt[0] - other[0].center()[0]) |
|
| 176 |
dy = abs(pt[1] - other[0].center()[1]) |
|
| 177 |
if dx < dy: |
|
| 178 |
pt[0] = other[0].center()[0] |
|
| 179 |
else: |
|
| 180 |
pt[1] = other[0].center()[1] |
|
| 185 | 181 |
|
| 186 |
self.connectedItem = None |
|
| 182 |
self.setPos(pt) |
|
| 183 |
if self.connectedItem is not None: |
|
| 184 |
for connect in self.connectedItem.connectors: |
|
| 185 |
if connect.connectedItem == self.parent: |
|
| 186 |
connect.connectedItem = None |
|
| 187 | 187 |
|
| 188 |
## unhighlight underitem |
|
| 189 |
if hasattr(self, '_underItem') and self._underItem is not None: |
|
| 190 |
self._underItem.hoverLeaveEvent(event) |
|
| 191 |
## up to here |
|
| 188 |
self.connectedItem = None |
|
| 192 | 189 |
|
| 193 |
if type(self.parent) is QEngineeringLineItem: |
|
| 194 |
self._savedPos = None |
|
| 195 |
self._savedConnectedItem = None |
|
| 190 |
## unhighlight underitem |
|
| 191 |
if hasattr(self, '_underItem') and self._underItem is not None: |
|
| 192 |
self._underItem.hoverLeaveEvent(event) |
|
| 193 |
## up to here |
|
| 194 |
|
|
| 195 |
if type(self.parent) is QEngineeringLineItem: |
|
| 196 |
self._savedPos = None |
|
| 197 |
self._savedConnectedItem = None |
|
| 198 |
self.transfer.onPosChanged.emit(self) |
|
| 199 |
finally: |
|
| 196 | 200 |
self.ungrabKeyboard() |
| 197 |
self.transfer.onPosChanged.emit(self) |
|
| 198 | 201 |
|
| 199 | 202 |
QGraphicsEllipseItem.mouseReleaseEvent(self, event) |
| 200 | 203 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringRunItem.py | ||
|---|---|---|
| 1 |
# coding: utf-8 |
|
| 2 |
""" This is engineering run item moduel """ |
|
| 3 |
|
|
| 1 | 4 |
import sys |
| 2 | 5 |
import os.path |
| 3 | 6 |
import copy |
| ... | ... | |
| 15 | 18 |
from EngineeringAbstractItem import QEngineeringAbstractItem |
| 16 | 19 |
|
| 17 | 20 |
class QEngineeringRunItem(QEngineeringAbstractItem): |
| 21 |
""" This is engineering run item class """ |
|
| 22 |
|
|
| 18 | 23 |
def __init__(self): |
| 19 | 24 |
import uuid |
| 20 | 25 |
QEngineeringAbstractItem.__init__(self) |
| ... | ... | |
| 55 | 60 |
self._items = value |
| 56 | 61 |
|
| 57 | 62 |
def explode(self): |
| 58 |
""" explode run """ |
|
| 63 |
""" explode run and subtract it from line no """
|
|
| 59 | 64 |
try: |
| 60 | 65 |
for item in self.items: |
| 61 | 66 |
item.owner = None |
| ... | ... | |
| 91 | 96 |
for at in range(len(self.items)): |
| 92 | 97 |
if type(self.items[at]) is QEngineeringLineItem and at > 0: |
| 93 | 98 |
self.items[at].arrange_flow_direction(self.items[at-1]) |
| 99 |
elif type(self.items[at]) is QEngineeringLineItem and len(self.items) > 1: |
|
| 100 |
self.items[at].arrange_flow_direction(self.items[at+1]) |
|
| 101 |
self.items[at].reverse() |
|
| 94 | 102 |
|
| 95 | 103 |
def reverse(self): |
| 96 | 104 |
""" reverse line's flow direction """ |
| 97 | 105 |
from EngineeringLineItem import QEngineeringLineItem |
| 98 | 106 |
|
| 107 |
self.items.reverse() |
|
| 99 | 108 |
for at in range(len(self.items)): |
| 100 | 109 |
if type(self.items[at]) is QEngineeringLineItem: |
| 101 | 110 |
self.items[at].reverse() |
| ... | ... | |
| 153 | 162 |
|
| 154 | 163 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 155 | 164 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 165 |
return None |
|
| 156 | 166 |
|
| 157 | 167 |
return node |
| DTI_PID/DTI_PID/Shapes/EngineeringSpecBreakItem.py | ||
|---|---|---|
| 173 | 173 |
|
| 174 | 174 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 175 | 175 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 176 |
return None |
|
| 176 | 177 |
|
| 177 | 178 |
return node |
| DTI_PID/DTI_PID/Shapes/EngineeringTextItem.py | ||
|---|---|---|
| 32 | 32 |
QGraphicsTextItem.__init__(self, parent) |
| 33 | 33 |
QEngineeringAbstractItem.__init__(self) |
| 34 | 34 |
|
| 35 |
self.uid = uuid.uuid4() if uid is None else uid
|
|
| 35 |
self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)
|
|
| 36 | 36 |
self.loc = None |
| 37 | 37 |
self.size = None |
| 38 | 38 |
self.angle = 0 # angle in radian |
| ... | ... | |
| 152 | 152 |
humkyung 2018.08.18 rotate text when user press 'R' |
| 153 | 153 |
''' |
| 154 | 154 |
def keyPressEvent(self, event): |
| 155 |
if event.key() == Qt.Key_Delete: |
|
| 155 |
if self.isSelected() and event.key() == Qt.Key_Delete:
|
|
| 156 | 156 |
self.deleteTextItemFromScene() |
| 157 | 157 |
elif event.key() == Qt.Key_R: |
| 158 | 158 |
#degree 0 |
| ... | ... | |
| 576 | 576 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 577 | 577 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 578 | 578 |
|
| 579 |
return str(self.uid)
|
|
| 579 |
return None
|
|
| 580 | 580 |
|
| 581 | 581 |
return node |
| 582 | 582 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringUnknownItem.py | ||
|---|---|---|
| 90 | 90 |
@history 2018.06.18 Jeongwoo Call deleteUnknownItemFromScene method |
| 91 | 91 |
''' |
| 92 | 92 |
def keyPressEvent(self, event): |
| 93 |
if event.key() == Qt.Key_Delete: |
|
| 93 |
if self.isSelected() and event.key() == Qt.Key_Delete:
|
|
| 94 | 94 |
self.deleteUnknownItemFromScene() |
| 95 | 95 |
|
| 96 | 96 |
''' |
| ... | ... | |
| 271 | 271 |
lINode.text = 'False' + '#' + 'None' + '#' + 'None' |
| 272 | 272 |
node.append(lINode) |
| 273 | 273 |
except Exception as ex: |
| 274 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
|
| 275 |
return str(self.uid) |
|
| 274 |
from App import App |
|
| 275 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
|
| 276 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
|
| 277 |
return None |
|
| 276 | 278 |
|
| 277 | 279 |
return node |
| 278 | 280 |
|
| DTI_PID/DTI_PID/Shapes/EngineeringVendorItem.py | ||
|---|---|---|
| 29 | 29 |
QGraphicsPolygonItem.__init__(self, polygon, parent) |
| 30 | 30 |
QEngineeringAbstractItem.__init__(self) |
| 31 | 31 |
|
| 32 |
self.uid = str(uuid.uuid4()) if uid is None else uid
|
|
| 32 |
self.uid = str(uuid.uuid4()) if uid is None else uuid.UUID(uid, version=4)
|
|
| 33 | 33 |
self.points = points |
| 34 | 34 |
|
| 35 | 35 |
self.isEntered = False |
| ... | ... | |
| 143 | 143 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 144 | 144 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 145 | 145 |
|
| 146 |
return str(self.uid)
|
|
| 146 |
return None
|
|
| 147 | 147 |
|
| 148 | 148 |
return node |
| 149 | 149 |
|
| DTI_PID/DTI_PID/Shapes/QEngineeringOPCItem.py | ||
|---|---|---|
| 1 | 1 |
# coding: utf-8 |
| 2 |
""" This engineering opc item module """ |
|
| 2 | 3 |
|
| 3 | 4 |
import sys |
| 4 | 5 |
import os |
| ... | ... | |
| 12 | 13 |
from EngineeringConnectorItem import QEngineeringConnectorItem |
| 13 | 14 |
|
| 14 | 15 |
class QEngineeringOPCItem(SymbolSvgItem): |
| 16 |
""" This is engineering opc item class """ |
|
| 17 |
|
|
| 15 | 18 |
clicked = pyqtSignal(QGraphicsSvgItem) |
| 16 |
#removed = pyqtSignal(QGraphicsItem) |
|
| 17 | 19 |
|
| 18 | 20 |
''' |
| 19 | 21 |
''' |
| DTI_PID/DTI_PID/Shapes/QEngineeringTrimLineNoTextItem.py | ||
|---|---|---|
| 59 | 59 |
for run in self.runs: |
| 60 | 60 |
node.append(run.toXml()) |
| 61 | 61 |
except Exception as ex: |
| 62 |
return self.uid |
|
| 63 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
|
| 62 |
return None |
|
| 64 | 63 |
|
| 65 | 64 |
return node |
| DTI_PID/DTI_PID/Shapes/SymbolSvgItem.py | ||
|---|---|---|
| 37 | 37 |
|
| 38 | 38 |
self.setFlags(QGraphicsItem.ItemIsSelectable|QGraphicsItem.ItemIsFocusable)#|QGraphicsItem.ItemIsMovable) |
| 39 | 39 |
|
| 40 |
self.uid = uuid.uuid4() if uid is None else uid
|
|
| 40 |
self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)
|
|
| 41 | 41 |
self.name = '' |
| 42 | 42 |
self.type = '' |
| 43 | 43 |
self.angle = 0 |
| ... | ... | |
| 588 | 588 |
2018.05.25 Jeongwoo Seperate delete item method |
| 589 | 589 |
''' |
| 590 | 590 |
def keyPressEvent(self, event): |
| 591 |
if event.key() == Qt.Key_Delete: |
|
| 591 |
if self.isSelected() and event.key() == Qt.Key_Delete:
|
|
| 592 | 592 |
self.deleteSvgItemFromScene() |
| 593 | 593 |
elif event.key() == Qt.Key_R: |
| 594 | 594 |
self.rotateSymbol() |
| ... | ... | |
| 834 | 834 |
currentPointModeIndexNode = Element('CURRENTPOINTMODEINDEX')
|
| 835 | 835 |
currentPointModeIndexNode.text = str(self.currentPointModeIndex) |
| 836 | 836 |
node.append(currentPointModeIndexNode) |
| 837 |
|
|
| 838 | 837 |
except Exception as ex: |
| 839 | 838 |
from App import App |
| 840 | 839 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
| 841 | 840 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 842 | 841 |
|
| 843 |
return str(self.uid)
|
|
| 842 |
return None
|
|
| 844 | 843 |
|
| 845 | 844 |
return node |
| 846 | 845 |
|
| DTI_PID/DTI_PID/TextItemEditDialog.py | ||
|---|---|---|
| 1 | 1 |
# coding: utf-8 |
| 2 |
""" This is text item edit dialog module """ |
|
| 3 |
|
|
| 2 | 4 |
import os |
| 3 | 5 |
import sys |
| 4 | 6 |
from PyQt5.QtCore import * |
| ... | ... | |
| 11 | 13 |
from EngineeringTextItem import QEngineeringTextItem |
| 12 | 14 |
|
| 13 | 15 |
class QTextItemEditDialog(QDialog): |
| 16 |
""" This is text item edit dialog class """ |
|
| 17 |
|
|
| 14 | 18 |
def __init__(self, parent): |
| 15 | 19 |
QDialog.__init__(self, parent) |
| 16 | 20 |
|
| ... | ... | |
| 34 | 38 |
''' |
| 35 | 39 |
def findTextClicked(self): |
| 36 | 40 |
self.findText() |
| 41 |
|
|
| 42 |
def is_valid_uuid(self, text, version=4): |
|
| 43 |
""" Check if uuid_to_test is a valid UUID. """ |
|
| 44 |
import uuid |
|
| 45 |
|
|
| 46 |
try: |
|
| 47 |
uuid_obj = uuid.UUID(text, version=version) |
|
| 48 |
except: |
|
| 49 |
return False |
|
| 50 |
|
|
| 51 |
return str(uuid_obj) == text |
|
| 37 | 52 |
|
| 38 | 53 |
''' |
| 39 | 54 |
@brief find text |
| ... | ... | |
| 42 | 57 |
''' |
| 43 | 58 |
def findText(self): |
| 44 | 59 |
text = self.ui.lineEditFindText.text() |
| 45 |
if text == '': |
|
| 46 |
return |
|
| 47 |
|
|
| 48 |
self.listIndex += 1 |
|
| 60 |
if not text: return |
|
| 49 | 61 |
|
| 50 |
if self.prevText != text: |
|
| 51 |
self.prevText = text |
|
| 52 |
self.textItems = [item for item in self.mainWindow.graphicsView.scene.items() if type(item) is QEngineeringTextItem and item.text().count(text)] |
|
| 53 |
self.listIndex = 0 |
|
| 54 |
elif self.textItems and self.listIndex == len(self.textItems): |
|
| 55 |
self.listIndex = 0 |
|
| 62 |
if self.is_valid_uuid(text): |
|
| 63 |
matches = [item for item in self.mainWindow.graphicsView.scene.items() if hasattr(item, 'uid') and str(item.uid) == text] |
|
| 64 |
if matches: self.selectTextItem(matches[0]) |
|
| 65 |
else: |
|
| 66 |
self.listIndex += 1 |
|
| 56 | 67 |
|
| 57 |
if self.textItems: |
|
| 58 |
item = self.textItems[self.listIndex] |
|
| 59 |
self.selectTextItem(item) |
|
| 68 |
if self.prevText != text: |
|
| 69 |
self.prevText = text |
|
| 70 |
self.textItems = [item for item in self.mainWindow.graphicsView.scene.items() if type(item) is QEngineeringTextItem and item.text().count(text)] |
|
| 71 |
self.listIndex = 0 |
|
| 72 |
elif self.textItems and self.listIndex == len(self.textItems): |
|
| 73 |
self.listIndex = 0 |
|
| 60 | 74 |
|
| 75 |
if self.textItems: |
|
| 76 |
item = self.textItems[self.listIndex] |
|
| 77 |
self.selectTextItem(item) |
|
| 61 | 78 |
|
| 62 | 79 |
''' |
| 63 | 80 |
@brief replace text |
| DTI_PID/DTI_PID/UI/dlgConnectAttr.ui | ||
|---|---|---|
| 87 | 87 |
</item> |
| 88 | 88 |
</layout> |
| 89 | 89 |
</widget> |
| 90 |
<tabstops> |
|
| 91 |
<tabstop>pushButtonStart</tabstop> |
|
| 92 |
<tabstop>listWidget</tabstop> |
|
| 93 |
</tabstops> |
|
| 90 | 94 |
<resources/> |
| 91 | 95 |
<connections> |
| 92 | 96 |
<connection> |
| DTI_PID/DTI_PID/XmlGenerator.py | ||
|---|---|---|
| 1 |
# coding: utf-8 |
|
| 2 |
""" This is xml generator module """ |
|
| 3 |
|
|
| 1 | 4 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse |
| 2 | 5 |
import symbol |
| 3 | 6 |
import SymbolBase |
| ... | ... | |
| 360 | 363 |
2018.11.26 euisung remove scene dependency |
| 361 | 364 |
''' |
| 362 | 365 |
def writeXmlOnScene(pidName, pidWidth, pidHeight): |
| 366 |
from EngineeringAbstractItem import QEngineeringAbstractItem |
|
| 363 | 367 |
from EngineeringNoteItem import QEngineeringNoteItem |
| 364 | 368 |
from EngineeringTextItem import QEngineeringTextItem |
| 365 | 369 |
from EngineeringLineItem import QEngineeringLineItem |
| ... | ... | |
| 387 | 391 |
unknownListNode = Element(UNKNOWNS_NODE_NAME) |
| 388 | 392 |
vendorListNode = Element(VENDOR_NODE_NAME) |
| 389 | 393 |
|
| 394 |
node_dictionary = {SymbolSvgItem:symbolListNode, QEngineeringTextItem:textInfoListNode, QEngineeringNoteItem:noteTextInfoListNode,
|
|
| 395 |
QEngineeringLineItem:lineListNode, QEngineeringLineNoTextItem:lineNoListNode, QEngineeringUnknownItem:unknownListNode, |
|
| 396 |
QEngineeringSizeTextItem:textInfoListNode, QEngineeringValveOperCodeTextItem:textInfoListNode, QEngineeringVendorItem:vendorListNode} |
|
| 397 |
|
|
| 390 | 398 |
# trim line 추가 |
| 391 | 399 |
trimLineNoListNode = Element(TRIM_LINE_NOS_NODE_NAME) |
| 392 | 400 |
|
| 393 | 401 |
try: |
| 394 | 402 |
resultDic = {}
|
| 395 |
resultDic["Symbol Item"] = [0, []] |
|
| 396 |
resultDic["Line Item"] = [0, []] |
|
| 397 |
resultDic["Line No Text Item"] = [0, []] |
|
| 398 |
resultDic["Text Item"] = [0, []] |
|
| 399 |
resultDic["Note Item"] = [0, []] |
|
| 400 |
resultDic["Unknown Item"] = [0, []] |
|
| 401 |
resultDic["Trim Line Item"] = [0, []] |
|
| 402 |
resultDic["Size Item"] = [0, []] |
|
| 403 |
resultDic["Valve Oper Code"] = [0, []] |
|
| 404 |
resultDic["Vendor Package"] = [0, []] |
|
| 405 | 403 |
|
| 406 | 404 |
for item in items: |
| 407 |
if issubclass(type(item), SymbolSvgItem): |
|
| 408 |
symbolNode = item.toXml() |
|
| 409 |
if symbolNode is None: continue |
|
| 410 |
if type(symbolNode) is str: |
|
| 411 |
resultDic["Symbol Item"][1].append(symbolNode) |
|
| 412 |
else: |
|
| 413 |
resultDic["Symbol Item"][0] += 1 |
|
| 414 |
symbolListNode.append(symbolNode) |
|
| 415 |
elif type(item) is QEngineeringLineItem: |
|
| 416 |
lineNode = item.toXml() |
|
| 417 |
if type(lineNode) is str: |
|
| 418 |
resultDic["Line Item"][1].append(lineNode) |
|
| 419 |
else: |
|
| 420 |
resultDic["Line Item"][0] += 1 |
|
| 421 |
lineListNode.append(lineNode) |
|
| 422 |
elif type(item) is QEngineeringLineNoTextItem: |
|
| 423 |
lineNoNode = item.toXml() |
|
| 424 |
if type(lineNoNode) is str: |
|
| 425 |
resultDic["Line No Text Item"][1].append(lineNoNode) |
|
| 426 |
else: |
|
| 427 |
resultDic["Line No Text Item"][0] += 1 |
|
| 428 |
lineNoListNode.append(lineNoNode) |
|
| 429 |
elif type(item) is QEngineeringTextItem: |
|
| 430 |
textNode = item.toXml() |
|
| 431 |
if type(textNode) is str: |
|
| 432 |
resultDic["Text Item"][1].append(textNode) |
|
| 433 |
else: |
|
| 434 |
resultDic["Text Item"][0] += 1 |
|
| 435 |
textInfoListNode.append(textNode) |
|
| 436 |
elif type(item) is QEngineeringNoteItem: |
|
| 437 |
noteNode = item.toXml(name = 'NOTE') |
|
| 438 |
if type(noteNode) is str: |
|
| 439 |
resultDic["Note Item"][1].append(noteNode) |
|
| 440 |
else: |
|
| 441 |
resultDic["Note Item"][0] += 1 |
|
| 442 |
noteTextInfoListNode.append(noteNode) |
|
| 443 |
elif type(item) is QEngineeringUnknownItem: |
|
| 444 |
unknownNode = item.toXml() |
|
| 445 |
if type(unknownNode) is str: |
|
| 446 |
resultDic["Unknown Item"][1].append(unknownNode) |
|
| 447 |
else: |
|
| 448 |
resultDic["Unknown Item"][0] += 1 |
|
| 449 |
unknownListNode.append(unknownNode) |
|
| 405 |
key = str(type(item)) |
|
| 406 |
if not key in resultDic: |
|
| 407 |
resultDic[key] = [0, []] |
|
| 408 |
|
|
| 409 |
node = None |
|
| 410 |
if type(item) is QEngineeringNoteItem: |
|
| 411 |
node = item.toXml(name = 'NOTE') |
|
| 450 | 412 |
elif type(item) is QEngineeringSizeTextItem: |
| 451 |
sizeNode = item.toXml(name='SIZE') |
|
| 452 |
if type(sizeNode) is str: |
|
| 453 |
resultDic["Size Item"][1].append(sizeNode) |
|
| 454 |
else: |
|
| 455 |
resultDic["Size Item"][0] += 1 |
|
| 456 |
textInfoListNode.append(sizeNode) |
|
| 413 |
node = item.toXml(name='SIZE') |
|
| 457 | 414 |
elif type(item) is QEngineeringValveOperCodeTextItem: |
| 458 |
valve_oper_code = item.toXml(name='VALVE OPER CODE') |
|
| 459 |
if type(valve_oper_code) is str: |
|
| 460 |
resultDic["Valve Oper Code"][1].append(valve_oper_code) |
|
| 461 |
else: |
|
| 462 |
resultDic["Valve Oper Code"][0] += 1 |
|
| 463 |
textInfoListNode.append(valve_oper_code) |
|
| 464 |
elif type(item) is QEngineeringVendorItem: |
|
| 465 |
vendor_package = item.toXml() |
|
| 466 |
if type(vendor_package) is str: |
|
| 467 |
resultDic["Vendor Package"][1].append(vendor_package) |
|
| 468 |
else: |
|
| 469 |
resultDic["Vendor Package"][0] += 1 |
|
| 470 |
vendorListNode.append(vendor_package) |
|
| 415 |
node = item.toXml(name='VALVE OPER CODE') |
|
| 416 |
elif issubclass(type(item), QEngineeringAbstractItem): |
|
| 417 |
node = item.toXml() |
|
| 418 |
else: |
|
| 419 |
continue |
|
| 420 |
|
|
| 421 |
if node: |
|
| 422 |
resultDic[key][0] += 1 |
|
| 423 |
if type(item) in node_dictionary: node_dictionary[type(item)].append(node) |
|
| 424 |
else: |
|
| 425 |
resultDic[key][1].append(str(item.uid)) |
|
| 426 |
|
|
| 471 | 427 |
for line in appDocData.tracerLineNos: |
| 472 | 428 |
if type(line) is QEngineeringTrimLineNoTextItem: |
| 473 | 429 |
trimNode = line.toXml() |
| 474 |
if type(trimNode) is str: |
|
| 475 |
resultDic["Trim Line Item"][1].append(trimNode) |
|
| 476 |
else: |
|
| 477 |
resultDic["Trim Line Item"][0] += 1 |
|
| 430 |
if trimNode: |
|
| 431 |
resultDic[str(type(item))][0] += 1 |
|
| 478 | 432 |
trimLineNoListNode.append(trimNode) |
| 433 |
else: |
|
| 434 |
resultDic[str(type(item))][1].append(str(line.uid)) |
|
| 479 | 435 |
|
| 480 |
except Exception as ex: |
|
| 481 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
|
| 482 |
finally: |
|
| 483 | 436 |
xml.append(symbolListNode) |
| 484 | 437 |
xml.append(textInfoListNode) |
| 485 | 438 |
xml.append(noteTextInfoListNode) |
| ... | ... | |
| 489 | 442 |
xml.append(trimLineNoListNode) |
| 490 | 443 |
xml.append(vendorListNode) |
| 491 | 444 |
ElementTree(xml).write(path) |
| 445 |
except Exception as ex: |
|
| 446 |
from App import App |
|
| 447 |
from AppDocData import MessageType |
|
| 448 |
|
|
| 449 |
message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)
|
|
| 450 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
|
| 492 | 451 |
|
| 493 | 452 |
return resultDic |
| 494 | 453 |
|
내보내기 Unified diff
