def _constructTree(self, node, x, y, par_x, par_y, text, squared=True, depth=1, h_index=0):
if squared:
node_item = BinTreeSquareNodeGraphicsItem(text, depth=depth)
else:
node_item = BinTreeNodeGraphicsItem(text, depth=depth)
self.nodeCount += 1
node_item.setBrush(Qt.white)
if node.data in self.regionPoints:
node_item.setPen(Qt.green)
self.addItem(node_item)
node_item.moveBy(x, y)
dx, dy = self.width() / (2 ** (depth + 2)), 2 * self.nodeWidth
text_item = QGraphicsTextItem(text)
text_item.moveBy(x-self.nodeWidth/4, y-self.nodeWidth/4)
self.addItem(text_item)
edge = QGraphicsLineItem(x, y, par_x, par_y)
edge.setZValue(-1)
self.addItem(edge)
if node.left:
self._constructTree(node.left, x-dx, y+dy, x, y, str(node.left.data), not squared, depth+1, 2*h_index)
if node.right:
self._constructTree(node.right, x+dx, y+dy, x, y, str(node.right.data), not squared, depth+1, 2*h_index+1)
def add_text(self, key, cond, text, x,
y): # key - к какому состоянию привязать текст не сцене
text_item = QGraphicsTextItem(text) # cond куда произойдет переход
text_item.moveBy(x, y)
f = QFont("Times", 15)
text_item.setFont(f)
self.scene.addItem(text_item)
self.conditions[key]["text"][cond] = text_item
def refresh(self):
self.clearTextFields()
self.loci = Loci()
self.loci.append_points(*self.point_model.points)
for key, value in self.loci.repr.items():
text = QGraphicsTextItem(str(value))
text.moveBy(*key.coords)
self.textFields.append(text)
self.addItem(text)
def constructTree(self):
root_item = BinTreeNodeGraphicsItem("S", self.tree.root.data)
root_item.setBrush(Qt.white)
self.addItem(root_item)
x, y = self.width() / 2 - self.rad, self.rad
root_item.moveBy(x, y)
text_item = QGraphicsTextItem("S")
text_item.moveBy(x-self.rad/2, y-self.rad/2)
self.addItem(text_item)
self._constructTree(self.tree.root.left, x-self.width()/4, 4*self.rad, x, y, "S<sub>1")
self._constructTree(self.tree.root.right, x+self.width()/4, 4*self.rad, x, y, "S<sub>2")
def constructTree(self):
root_item = BinTreeNodeGraphicsItem(str(self.tree.root.data))
root_item.setBrush(Qt.white)
if self.tree.root.data in self.regionPoints:
root_item.setPen(Qt.green)
self.addItem(root_item)
x, y = (self.width() - self.nodeWidth) / 2, self.nodeWidth / 2
root_item.moveBy(x, y)
text_item = QGraphicsTextItem(root_item.text)
text_item.moveBy(x-self.nodeWidth/4, y-self.nodeWidth/4)
self.addItem(text_item)
self._constructTree(self.tree.root.left, x-self.width()/4, 2*self.nodeWidth, x, y, str(self.tree.root.left.data))
self._constructTree(self.tree.root.right, x+self.width()/4, 2*self.nodeWidth, x, y, str(self.tree.root.right.data))
def paint_circle(self, x, y, r, name): # добавляет круг на сцену
ell = QGraphicsEllipseItem(
x - r // 2, y - r // 2, r,
r) # поправка смещения(в qt x,y - правый левый угол)
ell.setBrush(QColor(192, 192, 192))
self.scene.addItem(ell)
self.conditions[name]["scene_items"].append(ell)
if self.conditions[name]["is_final"] == 'yes':
ell = QGraphicsEllipseItem(x - r // 2 + r // 10,
y - r // 2 + r // 10, r - r // 5,
r - r // 5)
ell.setBrush(QColor(192, 192, 192))
self.scene.addItem(ell)
self.conditions[name]["scene_items"].append(ell)
text_item = QGraphicsTextItem(name)
text_item.moveBy(x - 11, y - 12)
self.scene.addItem(text_item)
def _constructTree(self, node, x, y, par_x, par_y, text, depth=1, h_index=0):
node_item = BinTreeNodeGraphicsItem(text, node.data, depth)
node_item.setBrush(Qt.white)
self.addItem(node_item)
node_item.moveBy(x, y)
dx, dy = self.width() / (2 ** (depth + 2)), 4 * self.rad
text_item = QGraphicsTextItem()
text_item.setHtml(text+"</sub>")
text_item.moveBy(x-self.rad/2, y-self.rad/2)
self.addItem(text_item)
edge = QGraphicsLineItem(x, y, par_x, par_y)
edge.setZValue(-1)
self.addItem(edge)
if node.left:
new_text = text + "1"
self._constructTree(node.left, x-dx, y+dy, x, y, new_text, depth+1, 2*h_index)
if node.right:
new_text = text + "2"
self._constructTree(node.right, x+dx, y+dy, x, y, new_text, depth+1, 2*h_index+1)
class NodeTemplateItem():
'''
This represents one node template on the diagram. A node template can be on many diagrams
This class creates the rectangle graphics item and the text graphics item and adds them to the scene.
'''
def __init__(self, scene, x, y, nodeTemplateDict=None, NZID=None):
self.scene = scene
self.logMsg = None
self.x = x
self.y = y
self.nodeTemplateDict = nodeTemplateDict
# self.name = self.nodeTemplateDict.get("name", "") THIS HAS BEEN REPLACED BY THE name FUNCTION - SEE BELOW
self.diagramType = "Node Template"
self.displayText = None
self.model = self.scene.parent.model
self.gap = 100
self.relList = []
# assign a unique key if it doesn't already have one
if NZID == None:
self.NZID = str(uuid.uuid4())
else:
self.NZID = NZID
# init graphics objects to none
self.TNode = None
self.TNtext = None
# draw the node template on the diagram
self.drawIt()
def name(self, ):
return self.nodeTemplateDict.get("name", "")
def getX(self, ):
return self.TNode.boundingRect().x()
def getY(self, ):
return self.TNode.boundingRect().y()
def getHeight(self, ):
return self.TNode.boundingRect().height()
def getWidth(self, ):
return self.TNode.boundingRect().width()
def getRelList(self, ):
'''return a list of all relationitems that are inbound or outbound from this node template.
do not include self referencing relationships
'''
return [
diagramItem
for key, diagramItem in self.scene.parent.itemDict.items()
if diagramItem.diagramType == "Relationship Template" and (
diagramItem.startNZID == self.NZID
or diagramItem.endNZID == self.NZID)
]
def getPoint(self, offset=None):
'''
This function is used by the template diagram to calculate the location to drop a node template on the diagram
'''
if offset is None:
return QPointF(self.x, self.y)
else:
return QPointF(self.x + offset, self.y + offset)
def getFormat(self, ):
'''
determine if the Node Template has a template format or should use the project default format
'''
# get the node Template custom format
customFormat = self.nodeTemplateDict.get("TNformat", None)
if not customFormat is None:
# get the template custom format
self.nodeFormat = TNodeFormat(formatDict=customFormat)
else:
# get the project default format
self.nodeFormat = TNodeFormat(
formatDict=self.model.modelData["TNformat"])
def clearItem(self, ):
if (not self.TNode is None and not self.TNode.scene() is None):
self.TNode.scene().removeItem(self.TNode)
if (not self.TNtext is None and not self.TNtext.scene() is None):
self.TNtext.scene().removeItem(self.TNtext)
def drawIt(self, ):
# get current format as it may have changed
self.getFormat()
# create the qgraphicsItems if they don't exist
if self.TNode is None:
# create the rectangle
self.TNode = QGraphicsRectItem(QRectF(
self.x, self.y, self.nodeFormat.formatDict["nodeWidth"],
self.nodeFormat.formatDict["nodeHeight"]),
parent=None)
self.TNode.setZValue(NODELAYER)
self.TNode.setFlag(QGraphicsItem.ItemIsMovable, True)
self.TNode.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
self.TNode.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.TNode.setSelected(True)
self.TNode.setData(1, self.NZID) # get with self.INode.data(1)
self.TNode.setData(ITEMTYPE, NODETEMPLATE)
# create the text box
self.TNtext = QGraphicsTextItem("", parent=None)
self.TNtext.setPos(self.x, self.y)
self.TNtext.setFlag(QGraphicsItem.ItemIsMovable, True)
self.TNtext.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.TNtext.setData(NODEID, self.NZID)
self.TNtext.setData(ITEMTYPE, NODETEMPLATETEXT)
self.TNtext.setZValue(NODELAYER)
# save the location
self.x = self.TNode.sceneBoundingRect().x()
self.y = self.TNode.sceneBoundingRect().y()
# generate the html and resize the rectangle
self.formatItem()
# add the graphics items to the scene
self.scene.addItem(self.TNode)
self.scene.addItem(self.TNtext)
else:
# generate the html and resize the rectangle
self.formatItem()
def formatItem(self, ):
# configure the formatting aspects of the qgraphics item
pen = self.nodeFormat.pen()
brush = self.nodeFormat.brush()
self.TNode.setBrush(brush)
self.TNode.setPen(pen)
# generate the HTML
genHTML = self.generateHTML()
self.TNtext.prepareGeometryChange()
# print("before html bounding rectangle width:{}".format(self.TNtext.boundingRect().width()))
# print("before html text width:{}".format(self.TNtext.textWidth()))
self.TNtext.setTextWidth(
-1
) # reset the width to unkonwn so it will calculate a new width based on the new html
self.TNtext.setHtml(genHTML)
# print("after html bounding rectangle width:{}".format(self.TNtext.boundingRect().width()))
# print("after html text width:{}".format(self.TNtext.textWidth()))
# make sure minimum width of 120
if self.TNtext.boundingRect().width() < 120:
self.TNtext.setTextWidth(120)
else:
self.TNtext.setTextWidth(
self.TNtext.boundingRect().width()
) # you have to do a setTextWidth to get the html to render correctly.
# set the rectangle item to the same size as the formatted html
self.TNode.prepareGeometryChange()
currentRect = self.TNode.rect()
# insure minimum height of 120
if self.TNtext.boundingRect().height() < 120:
currentRect.setHeight(120)
else:
currentRect.setHeight(self.TNtext.boundingRect().height())
currentRect.setWidth(self.TNtext.boundingRect().width())
self.TNode.setRect(currentRect)
def generateHTML(self, ):
'''
Generate the HTML that formats the node template data inside the rectangle
'''
# generate the html
prefix = "<!DOCTYPE html><html><body>"
# head = "<head><style>table, th, td {border: 1px solid black; border-collapse: collapse;}</style></head>"
suffix = "</body></html>"
# blankRow = "<tr><td><left>{}</left></td><td><left>{}</left></td><td><left>{}</left></td><td><left>{}</left></td></tr>".format("", "", "", "")
name = "<center><b>{}</b></center>".format(
self.nodeTemplateDict.get("name", ""))
lbls = self.genLblHTML()
props = self.genPropHTML()
genHTML = "{}{}<hr>{}<br><hr>{}{}".format(prefix, name, lbls, props,
suffix)
# print("{} html: {}".format(self.name(), genHTML))
return genHTML
def genLblHTML(self):
# html = '<table width="90%">'
html = '<table style="width:90%;border:1px solid black;">'
if len(self.nodeTemplateDict.get("labels", [])) > 0:
for lbl in self.nodeTemplateDict.get("labels", []):
if lbl[NODEKEY] == Qt.Checked:
nk = "NK"
else:
nk = " "
if lbl[REQUIRED] == Qt.Checked:
rq = "R"
else:
rq = ""
html = html + '<tr align="left"><td width="15%"><left>{}</left></td><td width="65%"><left>{}</left></td><td width="10%"><left>{}</left></td><td width="10%"><left>{}</left></td></tr>'.format(
nk, lbl[LABEL], "", rq)
html = html + "</table>"
else:
html = '<tr align="left"><td width="15%"><left>{}</left></td><td width="65%"><left>{}</left></td><td width="10%"><left>{}</left></td><td width="10%"><left>{}</left></td></tr>'.format(
" ", "NO{}LABELS".format(" "), "", "")
html = html + "</table>"
return html
def genPropHTML(self):
# PROPERTY, DATATYPE, PROPREQ, DEFAULT, EXISTS, UNIQUE, PROPNODEKEY
html = '<table style="width:90%;border:1px solid black;">'
if len(self.nodeTemplateDict.get("properties", [])) > 0:
for prop in self.nodeTemplateDict.get("properties", []):
if prop[PROPNODEKEY] == Qt.Checked:
nk = "NK"
else:
nk = " "
if prop[PROPREQ] == Qt.Checked:
rq = "R"
else:
rq = ""
if prop[EXISTS] == Qt.Checked:
ex = "E"
else:
ex = ""
if prop[UNIQUE] == Qt.Checked:
uq = "U"
else:
uq = ""
html = html + '<tr align="left"><td width="15%"><left>{}</left></td><td width="65%"><left>{}</left></td><td width="10%"><left>{}</left></td><td width="10%"><left>{}</left></td><td width="10%"><left>{}</left></td></tr>'.format(
nk, prop[PROPERTY], rq, ex, uq)
html = html + "</table>"
else:
html = html + '<tr align="left"><td width="15%"><left>{}</left></td><td width="65%"><left>{}</left></td><td width="10%"><left>{}</left></td><td width="10%"><left>{}</left></td></tr>'.format(
" ", "NO{}PROPERTIES".format(" "), "", "", "")
html = html + "</table>"
return html
def moveIt(self, dx, dy):
'''
Move the node rectangle and the node textbox to the delta x,y coordinate.
'''
# print("before moveIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
self.TNode.moveBy(dx, dy)
self.x = self.TNode.sceneBoundingRect().x()
self.y = self.TNode.sceneBoundingRect().y()
self.TNtext.moveBy(dx, dy)
# print("after moveIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
# now redraw all the relationships
self.drawRels()
def drawRels(self, ):
'''Redraw all the relationship lines connected to the Node Template Rectangle'''
# get a list of the relationship items connected to this node template
self.relList = self.getRelList()
# assign the correct inbound/outbound side for the rel
for rel in self.relList:
if rel.endNodeItem.NZID != rel.startNodeItem.NZID: # ignore bunny ears
rel.assignSide()
# get a set of all the nodes and sides involved
nodeSet = set()
for rel in self.relList:
if rel.endNodeItem.NZID != rel.startNodeItem.NZID: # ignore bunny ears
nodeSet.add((rel.endNodeItem, rel.inboundSide))
nodeSet.add((rel.startNodeItem, rel.outboundSide))
# tell each node side to assign rel locations
for nodeSide in nodeSet:
nodeSide[0].assignPoint(nodeSide[1])
############################################
# now tell them all to redraw
for rel in self.relList:
rel.drawIt2()
def calcOffset(self, index, totRels):
offset = [-60, -40, -20, 0, 20, 40, 60]
offsetStart = [3, 2, 2, 1, 1, 0, 0]
if totRels > 7:
totRels = 7
return offset[offsetStart[totRels - 1] + index]
def assignPoint(self, side):
# go through all the rels on a side and assign their x,y coord for that side
self.relList = self.getRelList()
sideList = [
rel for rel in self.relList
if ((rel.startNZID == self.NZID and rel.outboundSide == side) or (
rel.endNZID == self.NZID and rel.inboundSide == side))
]
totRels = len(sideList)
if totRels > 0:
if side == R:
# calc center of the side
x = self.x + self.getWidth()
y = self.y + self.getHeight() / 2
# sort the rels connected to this side by the y value
sideList.sort(key=self.getSortY)
# assign each of them a position on the side starting in the center and working out in both directions
for index, rel in enumerate(sideList):
if rel.startNZID == self.NZID:
rel.outboundPoint = QPointF(
x, y + (self.calcOffset(index, totRels)))
if rel.endNZID == self.NZID:
rel.inboundPoint = QPointF(
x, y + (self.calcOffset(index, totRels)))
elif side == L:
x = self.x
y = self.y + self.getHeight() / 2
sideList.sort(key=self.getSortY)
for index, rel in enumerate(sideList):
if rel.startNZID == self.NZID:
rel.outboundPoint = QPointF(
x, y + (self.calcOffset(index, totRels)))
if rel.endNZID == self.NZID:
rel.inboundPoint = QPointF(
x, y + (self.calcOffset(index, totRels)))
elif side == TOP:
x = self.x + self.getWidth() / 2
y = self.y
sideList.sort(key=self.getSortX)
for index, rel in enumerate(sideList):
if rel.startNZID == self.NZID:
rel.outboundPoint = QPointF(
x + (self.calcOffset(index, totRels)), y)
if rel.endNZID == self.NZID:
rel.inboundPoint = QPointF(
x + (self.calcOffset(index, totRels)), y)
elif side == BOTTOM:
x = self.x + self.getWidth() / 2
y = self.y + self.getHeight()
sideList.sort(key=self.getSortX)
for index, rel in enumerate(sideList):
if rel.startNZID == self.NZID:
rel.outboundPoint = QPointF(
x + (self.calcOffset(index, totRels)), y)
if rel.endNZID == self.NZID:
rel.inboundPoint = QPointF(
x + (self.calcOffset(index, totRels)), y)
else:
print("error, no side")
def getSortY(self, rel):
# if this node is the start node then return the end node's Y
if rel.startNZID == self.NZID:
return rel.endNodeItem.TNode.sceneBoundingRect().center().y()
# if this node is the end node then return the start node's Y
if rel.endNZID == self.NZID:
return rel.startNodeItem.TNode.sceneBoundingRect().center().y()
# this should never happen
return 0
def getSortX(self, rel):
# if this node is the start node then return the end node's X
if rel.startNZID == self.NZID:
return rel.endNodeItem.TNode.sceneBoundingRect().center().x()
# if this node is the end node then return the start node's X
if rel.endNZID == self.NZID:
return rel.startNodeItem.TNode.sceneBoundingRect().center().x()
# this should never happen
return 0
def getObjectDict(self, ):
'''
This function returns a dictionary with all the data that represents this node template item.
The dictionary is added to the Instance Diagram dictionary.'''
objectDict = {}
objectDict["NZID"] = self.NZID
objectDict["name"] = self.nodeTemplateDict.get("name", "")
objectDict["displayText"] = self.displayText
objectDict["x"] = self.TNode.sceneBoundingRect().x()
objectDict["y"] = self.TNode.sceneBoundingRect().y()
objectDict["diagramType"] = self.diagramType
objectDict["labels"] = self.nodeTemplateDict.get("labels", [])
objectDict["properties"] = self.nodeTemplateDict.get("properties", [])
return objectDict
def setLogMethod(self, logMethod=None):
if logMethod is None:
if self.logMsg is None:
self.logMsg = self.noLog
else:
self.logMsg = logMethod
def noLog(self, msg):
return
class NodeItem():
'''
This represents one node on the diagram.
This class creates the ellipse graphics item and the text graphics item and adds them to the scene.
'''
def __init__(self, scene, x, y, nodeInstance=None):
self.scene = scene
self.logMsg = None
self.x = x
self.y = y
self.itemInstance = nodeInstance
self.diagramType = self.itemInstance.diagramType
self.displayText = None
self.model = self.scene.parent.model
self.neoCon = self.scene.parent.model.modelNeoCon
self.getFormat()
# remember current width and height
self.oldNodeWidth = 0
self.oldNodeHeight = 0
# init graphics objects to none
self.INode = None
self.INtext = None
# # init list of qgrapphicellipseitems to none
# self.ellipsePoints = []
# self.ellipseGraphicItems = []
# draw the ellipse
self.drawIt()
def name(self, ):
return self.itemInstance.NZID
def NZID(self, ):
return self.itemInstance.NZID
def getFormat(self, ):
'''
determine the format to use to draw the instance node
- start with the project default
- if the instance node has a template then use the instance format defined on the template
'''
# get the default
self.nodeFormat = INodeFormat(
formatDict=self.model.modelData["INformat"])
# get a custom template format if there is one
if not self.itemInstance.nodeTemplate is None:
index, nodeTemplateDict = self.model.getDictByName(
topLevel="Node Template",
objectName=self.itemInstance.nodeTemplate)
if not nodeTemplateDict is None:
self.instanceNodeFormatDict = nodeTemplateDict.get(
"INformat", None)
if not self.instanceNodeFormatDict is None:
self.nodeFormat = INodeFormat(
formatDict=self.instanceNodeFormatDict)
def clearItem(self, ):
if (not self.INode is None and not self.INode.scene() is None):
self.INode.scene().removeItem(self.INode)
if (not self.INtext is None and not self.INtext.scene() is None):
self.INtext.scene().removeItem(self.INtext)
# # remove the points on the ellipse - this code is only for debugging
# for point in self.ellipseGraphicItems:
# if (not point is None and not point.scene() is None):
# point.scene().removeItem(point)
def drawIt(self, ):
# force the node instance to update its values in case it has been updated from another diagram or the tree view
self.itemInstance.reloadDictValues()
# get current format as it may have changed
self.getFormat()
if self.oldNodeWidth != self.nodeFormat.formatDict[
"nodeWidth"] or self.oldNodeHeight != self.nodeFormat.formatDict[
"nodeHeight"]:
# remove graphic items that already exist
self.clearItem()
# create the node ellipse
self.INode = QGraphicsEllipseItem(QRectF(
self.x, self.y, self.nodeFormat.formatDict["nodeWidth"],
self.nodeFormat.formatDict["nodeHeight"]),
parent=None)
# create the node text
self.INtext = QGraphicsTextItem("", parent=None)
self.INtext.setPos(self.x, self.y)
self.x = self.INode.sceneBoundingRect().x()
self.y = self.INode.sceneBoundingRect().y()
# print("after create items before drawIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
# print("x:{} y:{}".format(self.x, self.y))
self.formatItem()
self.scene.addItem(self.INode)
self.scene.addItem(self.INtext)
# # add points
# for point in self.ellipseGraphicItems:
# self.scene.addItem(point)
# redraw all the rels associated to this node.
self.moveRels()
else:
# print("before drawIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
# print("x:{} y:{}".format(self.x, self.y))
self.formatItem()
# remember current width and height
self.oldNodeWidth = self.nodeFormat.formatDict["nodeWidth"]
self.oldNodeHeight = self.nodeFormat.formatDict["nodeHeight"]
# print("after drawIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
# print("x:{} y:{}".format(self.x, self.y))
# def genPoints(self, ):
# '''Ellipse Constructor - not sure of these, need to verify
# def __init__(self, mx, my, rh, rv):
# mx - center point x
# my - center point y
# rh - height of ellipse
# rv - width of ellipse'''
# x = self.INode.sceneBoundingRect().center().x()
# y = self.INode.sceneBoundingRect().center().y()
# w = self.INode.sceneBoundingRect().width()/2.0
# h = self.INode.sceneBoundingRect().height()/2.0
# myEllipse = Ellipse(x, y, w, h)
# for d in range(0, 360, 10):
# x, y = myEllipse.pointFromAngle(radians(d))
# self.ellipsePoints.append([d, x, y])
# aPoint = QGraphicsEllipseItem(QRectF(x-2.5,y-2.5,5, 5), parent=None)
# self.ellipseGraphicItems.append(aPoint)
## print(self.ellipsePoints)
def formatItem(self, ):
# configure the formatting aspects of the qgraphics item
pen = self.nodeFormat.pen()
brush = self.nodeFormat.brush()
self.INode.setZValue(NODELAYER)
self.INode.setBrush(brush)
self.INode.setPen(pen)
self.INode.setFlag(QGraphicsItem.ItemIsMovable, True)
self.INode.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
self.INode.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.INode.setSelected(True)
self.INode.setData(
1, self.itemInstance.NZID) # get with self.INode.data(1)
self.INode.setData(ITEMTYPE, NODEINSTANCE)
# draw the text
self.updateText()
self.INtext.setZValue(NODELAYER)
self.INtext.setTextWidth(self.INode.boundingRect().width())
self.INtext.setFlag(QGraphicsItem.ItemIsMovable, True)
self.INtext.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.INtext.setData(NODEID, self.itemInstance.NZID)
self.INtext.setData(ITEMTYPE, NODEINSTANCETEXT)
def updateText(self, ):
'''
Generate the HTML that formats the node data inside the ellipse
'''
# generate the html
prefix = "<!DOCTYPE html><html><body>"
suffix = "</body></html>"
try:
Lbl = str(self.itemInstance.labelList[0][0])
except:
Lbl = "No Labels"
firstLbl = "<center><b>{}</b></center>".format(Lbl)
try:
propName = str(self.itemInstance.propList[0][PROPERTY])
propVal = str(self.itemInstance.propList[0][VALUE])
prop = "{}: {}".format(propName, propVal)
except:
prop = "No Properties"
firstProp = "<center>{}</center>".format(prop)
genHTML = '{}{}<hr width="75%">{}{}'.format(prefix, firstLbl,
firstProp, suffix)
self.INtext.setHtml(genHTML)
def moveIt(self, dx, dy):
'''Move the node ellipse and the node textbox to the delta x,y coordinate.'''
# print("before moveIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
self.INode.moveBy(dx, dy)
self.x = self.INode.sceneBoundingRect().x()
self.y = self.INode.sceneBoundingRect().y()
self.INtext.moveBy(dx, dy)
# print("after moveIt: sceneboundingrect {} ".format( self.INode.sceneBoundingRect()))
# # recalc points
# self.genPoints()
# for point in self.ellipseGraphicItems:
# point.moveBy(dx, dy)
self.moveRels()
def moveRels(self, ):
'''Redraw all the relationship arcs connected to the Node ellipse.'''
# print("moveRels")
for key, diagramItem in self.scene.parent.itemDict.items():
if diagramItem.diagramType == "Instance Relationship":
if self.itemInstance.NZID in [
diagramItem.relationInstance.startNZID,
diagramItem.relationInstance.endNZID
]:
diagramItem.drawRelationship()
# if diagramItem.relationInstance.startNZID == self.itemInstance.NZID:
# diagramItem.moveRelationshipLine()
## print("move startnode {}-{}".format(self.x, self.y))
# if diagramItem.relationInstance.endNZID == self.itemInstance.NZID:
# diagramItem.moveRelationshipLine()
## print("move endnode {}-{}".format(self.x, self.y))
def getObjectDict(self, ):
'''
This function returns a dictionary with all the data that represents this node item.
The dictionary is added to the Instance Diagram dictionary.'''
objectDict = {}
objectDict["NZID"] = self.itemInstance.NZID
objectDict["x"] = self.INode.sceneBoundingRect().x()
objectDict["y"] = self.INode.sceneBoundingRect().y()
objectDict["diagramType"] = self.diagramType
return objectDict
def setLogMethod(self, logMethod=None):
if logMethod is None:
if self.logMsg is None:
self.logMsg = self.noLog
else:
self.logMsg = logMethod
def noLog(self, msg):
return
