eric: comparison src/eric7/Graphics/UMLItem.py

-:e9e7eca7efee
+:bf71ee032bb4
 class UMLModel:
 """
 Class implementing the UMLModel base class.
 """
 def __init__(self, name):
 """
 Constructor
 @param name package name
 @type str
 """
 self.name = name
 def getName(self):
 """
 Public method to retrieve the model name.
 @return model name
 @rtype str
 """
 return self.name
 class UMLItem(QGraphicsRectItem):
 """
 Class implementing the UMLItem base class.
 """
 ItemType = "UMLItem"
-def __init__(self, model=None, x=0, y=0, rounded=False, colors=None,
+def __init__(self, model=None, x=0, y=0, rounded=False, colors=None, parent=None):
-parent=None):
 """
 Constructor
 @param model UML model containing the item data
 @type UMLModel
 @param x x-coordinate
 @type int
 @param y y-coordinate
 @param parent reference to the parent object
 @type QGraphicsItem
 """
 super().__init__(parent)
 self.model = model
 if colors is None:
-self._colors = (QColor(Qt.GlobalColor.black),
+self._colors = (QColor(Qt.GlobalColor.black), QColor(Qt.GlobalColor.white))
-QColor(Qt.GlobalColor.white))
 else:
 self._colors = colors
 self.setPen(QPen(self._colors[0]))
 self.font = Preferences.getGraphics("Font")
 self.margin = 5
 self.associations = []
 self.shouldAdjustAssociations = False
 self.__id = -1
 self.setRect(x, y, 60, 30)
 if rounded:
 p = self.pen()
 p.setCapStyle(Qt.PenCapStyle.RoundCap)
 p.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
 self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
 self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, True)
-self.setFlag(
+self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges, True)
-QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges, True)
 def getName(self):
 """
 Public method to retrieve the item name.
 @return item name
 @rtype str
 """
 if self.model:
 return self.model.name
 else:
 return ""
 def setSize(self, width, height):
 """
 Public method to set the rectangles size.
 @param width width of the rectangle
 @type float
 @param height height of the rectangle
 @type float
 """
 rect = self.rect()
 rect.setSize(QSizeF(width, height))
 self.setRect(rect)
 def addAssociation(self, assoc):
 """
 Public method to add an association to this widget.
 @param assoc association to be added
 @type AssociationWidget
 """
 if assoc and assoc not in self.associations:
 self.associations.append(assoc)
 def removeAssociation(self, assoc):
 """
 Public method to remove an association to this widget.
 @param assoc association to be removed
 @type AssociationWidget
 """
 if assoc and assoc in self.associations:
 self.associations.remove(assoc)
 def removeAssociations(self):
 """
 Public method to remove all associations of this widget.
 """
 for assoc in self.associations[:]:
 assoc.unassociate()
 assoc.hide()
 del assoc
 def adjustAssociations(self):
 """
 Public method to adjust the associations to widget movements.
 """
 if self.shouldAdjustAssociations:
 for assoc in self.associations:
 assoc.widgetMoved()
 self.shouldAdjustAssociations = False
 def moveBy(self, dx, dy):
 """
 Public overriden method to move the widget relative.
 @param dx relative movement in x-direction
 @type float
 @param dy relative movement in y-direction
 @type float
 """
 super().moveBy(dx, dy)
 self.adjustAssociations()
 def setPos(self, x, y):
 """
 Public overriden method to set the items position.
 @param x absolute x-position
 @type float
 @param y absolute y-position
 @type float
 """
 super().setPos(x, y)
 self.adjustAssociations()
 def itemChange(self, change, value):
 """
 Public method called when an items state changes.
 @param change the item's change
 @type QGraphicsItem.GraphicsItemChange
 @param value the value of the change
 @return adjusted values
 """
 if change == QGraphicsItem.GraphicsItemChange.ItemPositionChange:
 # 1. remember to adjust associations
 self.shouldAdjustAssociations = True
 # 2. ensure the new position is inside the scene
 scene = self.scene()
 if scene:
 rect = scene.sceneRect()
 if not rect.contains(value):
 # keep the item inside the scene
 value.setX(min(rect.right(), max(value.x(), rect.left())))
 value.setY(min(rect.bottom(), max(value.y(), rect.top())))
 return value
 return QGraphicsItem.itemChange(self, change, value)
 def paint(self, painter, option, widget=None):
 """
 Public method to paint the item in local coordinates.
 @param painter reference to the painter object
 @type QPainter
 @param option style options
 @type QStyleOptionGraphicsItem
 @param widget optional reference to the widget painted on
 @type QWidget
 """
 pen = self.pen()
 if (
-(option.state & QStyle.StateFlag.State_Selected) ==
+option.state & QStyle.StateFlag.State_Selected
-QStyle.StateFlag.State_Selected
+) == QStyle.StateFlag.State_Selected:
-):
 pen.setWidth(2)
 else:
 pen.setWidth(1)
 painter.setPen(pen)
 painter.setBrush(self.brush())
 painter.drawRect(self.rect())
 self.adjustAssociations()
 def setId(self, itemId):
 """
 Public method to assign an ID to the item.
 @param itemId assigned ID
 @type int
 """
 self.__id = itemId
 def getId(self):
 """
 Public method to get the item ID.
 @return ID of the item
 @rtype int
 """
 return self.__id
 def getItemType(self):
 """
 Public method to get the item's type.
 @return item type
 @rtype str
 """
 return self.ItemType
 def parseItemDataString(self, version, data):
 """
 Public method to parse the given persistence data.
 @param version version of the data
 @type str
 @param data persisted data to be parsed
 @type str
 @return flag indicating success
 @rtype bool
 """
 return True
 def toDict(self):
 """
 Public method to collect data to be persisted.
 @return dictionary containing data to be persisted
 @rtype dict
 """
 return {
 "id": self.getId(),
 "x": self.x(),
 "y": self.y(),
 "type": self.getItemType(),
 "model_name": self.model.getName(),
 }
 @classmethod
 def fromDict(cls, data, colors=None):
 """
 Class method to create a generic UML item from persisted data.
 @param data dictionary containing the persisted data as generated
 by toDict()
 @type dict
 @param colors tuple containing the foreground and background colors
 @type tuple of (QColor, QColor)
 @return created UML item
 @rtype UMLItem
 """
 try:
 model = UMLModel(data["model_name"])
-itm = cls(model=model,
+itm = cls(model=model, x=0, y=0, colors=colors)
-x=0,
-y=0,
-colors=colors)
 itm.setPos(data["x"], data["y"])
 itm.setId(data["id"])
 return itm
 except KeyError:
 return None

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Graphics/UMLItem.py

src/eric7/Graphics/UMLItem.py