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

-:e9e7eca7efee
+:bf71ee032bb4
 Module implementing a subclass of EricGraphicsView for our diagrams.
 """
 import pathlib
-from PyQt6.QtCore import (
+from PyQt6.QtCore import pyqtSignal, Qt, QSignalMapper, QEvent, QRectF, QMarginsF
-pyqtSignal, Qt, QSignalMapper, QEvent, QRectF, QMarginsF
-)
 from PyQt6.QtGui import QAction, QPageLayout
 from PyQt6.QtWidgets import QGraphicsView, QToolBar, QDialog
 from PyQt6.QtPrintSupport import QPrinter, QPrintDialog
 from EricGraphics.EricGraphicsView import EricGraphicsView
 class UMLGraphicsView(EricGraphicsView):
 """
 Class implementing a specialized EricGraphicsView for our diagrams.
 @signal relayout() emitted to indicate a relayout of the diagram
 is requested
 """
 relayout = pyqtSignal()
 def __init__(self, scene, parent=None):
 """
 Constructor
 @param scene reference to the scene object
 @type QGraphicsScene
 @param parent parent widget of the view
 @type QWidget
 """
 EricGraphicsView.__init__(self, scene, parent)
 self.setObjectName("UMLGraphicsView")
-self.setViewportUpdateMode(
+self.setViewportUpdateMode(QGraphicsView.ViewportUpdateMode.FullViewportUpdate)
-QGraphicsView.ViewportUpdateMode.FullViewportUpdate)
 self.diagramName = "Unnamed"
 self.__itemId = -1
 self.border = 10
 self.deltaSize = 100.0
 self.__zoomWidget = EricZoomWidget(
 UI.PixmapCache.getPixmap("zoomOut"),
 UI.PixmapCache.getPixmap("zoomIn"),
-UI.PixmapCache.getPixmap("zoomReset"), self)
+UI.PixmapCache.getPixmap("zoomReset"),
+self,
+)
 parent.statusBar().addPermanentWidget(self.__zoomWidget)
 self.__zoomWidget.setMapping(
-EricGraphicsView.ZoomLevels, EricGraphicsView.ZoomLevelDefault)
+EricGraphicsView.ZoomLevels, EricGraphicsView.ZoomLevelDefault
+)
 self.__zoomWidget.valueChanged.connect(self.setZoom)
 self.zoomValueChanged.connect(self.__zoomWidget.setValue)
 self.__initActions()
 scene.changed.connect(self.__sceneChanged)
 self.grabGesture(Qt.GestureType.PinchGesture)
 def __initActions(self):
 """
 Private method to initialize the view actions.
 """
 self.alignMapper = QSignalMapper(self)
 try:
 self.alignMapper.mappedInt.connect(self.__alignShapes)
 except AttributeError:
 # pre Qt 5.15
 self.alignMapper.mapped[int].connect(self.__alignShapes)
 self.deleteShapeAct = QAction(
-UI.PixmapCache.getIcon("deleteShape"),
+UI.PixmapCache.getIcon("deleteShape"), self.tr("Delete shapes"), self
-self.tr("Delete shapes"), self)
+)
 self.deleteShapeAct.triggered.connect(self.__deleteShape)
 self.incWidthAct = QAction(
 UI.PixmapCache.getIcon("sceneWidthInc"),
-self.tr("Increase width by {0} points").format(
+self.tr("Increase width by {0} points").format(self.deltaSize),
-self.deltaSize),
+self,
-self)
+)
 self.incWidthAct.triggered.connect(self.__incWidth)
 self.incHeightAct = QAction(
 UI.PixmapCache.getIcon("sceneHeightInc"),
-self.tr("Increase height by {0} points").format(
+self.tr("Increase height by {0} points").format(self.deltaSize),
-self.deltaSize),
+self,
-self)
+)
 self.incHeightAct.triggered.connect(self.__incHeight)
 self.decWidthAct = QAction(
 UI.PixmapCache.getIcon("sceneWidthDec"),
-self.tr("Decrease width by {0} points").format(
+self.tr("Decrease width by {0} points").format(self.deltaSize),
-self.deltaSize),
+self,
-self)
+)
 self.decWidthAct.triggered.connect(self.__decWidth)
 self.decHeightAct = QAction(
 UI.PixmapCache.getIcon("sceneHeightDec"),
-self.tr("Decrease height by {0} points").format(
+self.tr("Decrease height by {0} points").format(self.deltaSize),
-self.deltaSize),
+self,
-self)
+)
 self.decHeightAct.triggered.connect(self.__decHeight)
 self.setSizeAct = QAction(
-UI.PixmapCache.getIcon("sceneSize"),
+UI.PixmapCache.getIcon("sceneSize"), self.tr("Set size"), self
-self.tr("Set size"), self)
+)
 self.setSizeAct.triggered.connect(self.__setSize)
 self.rescanAct = QAction(
-UI.PixmapCache.getIcon("rescan"),
+UI.PixmapCache.getIcon("rescan"), self.tr("Re-Scan"), self
-self.tr("Re-Scan"), self)
+)
 self.rescanAct.triggered.connect(self.__rescan)
 self.relayoutAct = QAction(
-UI.PixmapCache.getIcon("relayout"),
+UI.PixmapCache.getIcon("relayout"), self.tr("Re-Layout"), self
-self.tr("Re-Layout"), self)
+)
 self.relayoutAct.triggered.connect(self.__relayout)
 self.alignLeftAct = QAction(
-UI.PixmapCache.getIcon("shapesAlignLeft"),
+UI.PixmapCache.getIcon("shapesAlignLeft"), self.tr("Align Left"), self
-self.tr("Align Left"), self)
+)
-self.alignMapper.setMapping(
+self.alignMapper.setMapping(self.alignLeftAct, Qt.AlignmentFlag.AlignLeft)
-self.alignLeftAct, Qt.AlignmentFlag.AlignLeft)
 self.alignLeftAct.triggered.connect(self.alignMapper.map)
 self.alignHCenterAct = QAction(
 UI.PixmapCache.getIcon("shapesAlignHCenter"),
-self.tr("Align Center Horizontal"), self)
+self.tr("Align Center Horizontal"),
-self.alignMapper.setMapping(
+self,
-self.alignHCenterAct, Qt.AlignmentFlag.AlignHCenter)
+)
+self.alignMapper.setMapping(self.alignHCenterAct, Qt.AlignmentFlag.AlignHCenter)
 self.alignHCenterAct.triggered.connect(self.alignMapper.map)
 self.alignRightAct = QAction(
-UI.PixmapCache.getIcon("shapesAlignRight"),
+UI.PixmapCache.getIcon("shapesAlignRight"), self.tr("Align Right"), self
-self.tr("Align Right"), self)
+)
-self.alignMapper.setMapping(
+self.alignMapper.setMapping(self.alignRightAct, Qt.AlignmentFlag.AlignRight)
-self.alignRightAct, Qt.AlignmentFlag.AlignRight)
 self.alignRightAct.triggered.connect(self.alignMapper.map)
 self.alignTopAct = QAction(
-UI.PixmapCache.getIcon("shapesAlignTop"),
+UI.PixmapCache.getIcon("shapesAlignTop"), self.tr("Align Top"), self
-self.tr("Align Top"), self)
+)
-self.alignMapper.setMapping(
+self.alignMapper.setMapping(self.alignTopAct, Qt.AlignmentFlag.AlignTop)
-self.alignTopAct, Qt.AlignmentFlag.AlignTop)
 self.alignTopAct.triggered.connect(self.alignMapper.map)
 self.alignVCenterAct = QAction(
 UI.PixmapCache.getIcon("shapesAlignVCenter"),
-self.tr("Align Center Vertical"), self)
+self.tr("Align Center Vertical"),
-self.alignMapper.setMapping(
+self,
-self.alignVCenterAct, Qt.AlignmentFlag.AlignVCenter)
+)
+self.alignMapper.setMapping(self.alignVCenterAct, Qt.AlignmentFlag.AlignVCenter)
 self.alignVCenterAct.triggered.connect(self.alignMapper.map)
 self.alignBottomAct = QAction(
-UI.PixmapCache.getIcon("shapesAlignBottom"),
+UI.PixmapCache.getIcon("shapesAlignBottom"), self.tr("Align Bottom"), self
-self.tr("Align Bottom"), self)
+)
-self.alignMapper.setMapping(
+self.alignMapper.setMapping(self.alignBottomAct, Qt.AlignmentFlag.AlignBottom)
-self.alignBottomAct, Qt.AlignmentFlag.AlignBottom)
 self.alignBottomAct.triggered.connect(self.alignMapper.map)
 def setLayoutActionsEnabled(self, enable):
 """
 Public method to enable or disable the layout related actions.
 @param enable flag indicating the desired enable state
 @type bool
 """
 self.rescanAct.setEnabled(enable)
 self.relayoutAct.setEnabled(enable)
 def __checkSizeActions(self):
 """
 Private slot to set the enabled state of the size actions.
 """
 diagramSize = self._getDiagramSize(10)
 self.decWidthAct.setEnabled(True)
 if (sceneRect.height() - self.deltaSize) < diagramSize.height():
 self.decHeightAct.setEnabled(False)
 else:
 self.decHeightAct.setEnabled(True)
 def __sceneChanged(self, areas):
 """
 Private slot called when the scene changes.
 @param areas list of rectangles that contain changes
 @type list of QRectF
 """
 if len(self.scene().selectedItems()) > 0:
 self.deleteShapeAct.setEnabled(True)
 else:
 self.deleteShapeAct.setEnabled(False)
 sceneRect = self.scene().sceneRect()
 newWidth = width = sceneRect.width()
 newHeight = height = sceneRect.height()
 rect = self.scene().itemsBoundingRect()
 # calculate with 10 pixel border on each side
 if sceneRect.right() - 10 < rect.right():
 newWidth = rect.right() + 10
 if sceneRect.bottom() - 10 < rect.bottom():
 newHeight = rect.bottom() + 10
 if newHeight != height or newWidth != width:
 self.setSceneSize(newWidth, newHeight)
 self.__checkSizeActions()
 def initToolBar(self):
 """
 Public method to populate a toolbar with our actions.
 @return the populated toolBar
 @rtype QToolBar
 """
 toolBar = QToolBar(self.tr("Graphics"), self)
 toolBar.setIconSize(UI.Config.ToolBarIconSize)
 toolBar.addAction(self.decHeightAct)
 toolBar.addAction(self.setSizeAct)
 toolBar.addSeparator()
 toolBar.addAction(self.rescanAct)
 toolBar.addAction(self.relayoutAct)
 return toolBar
 def filteredItems(self, items, itemType=UMLItem):
 """
 Public method to filter a list of items.
 @param items list of items as returned by the scene object
 @type QGraphicsItem
 @param itemType type to be filtered
 @type class
 @return list of interesting collision items
 @rtype QGraphicsItem
 """
 return [itm for itm in items if isinstance(itm, itemType)]
 def selectItems(self, items):
 """
 Public method to select the given items.
 @param items list of items to be selected
 @type list of QGraphicsItemItem
 """
 # step 1: deselect all items
 self.unselectItems()
 # step 2: select all given items
 for itm in items:
 if isinstance(itm, UMLItem):
 itm.setSelected(True)
 def selectItem(self, item):
 """
 Public method to select an item.
 @param item item to be selected
 @type QGraphicsItemItem
 """
 if isinstance(item, UMLItem):
 item.setSelected(not item.isSelected())
 def __deleteShape(self):
 """
 Private method to delete the selected shapes from the display.
 """
 for item in self.scene().selectedItems():
 item.removeAssociations()
 item.setSelected(False)
 self.scene().removeItem(item)
 del item
 def __incWidth(self):
 """
 Private method to handle the increase width context menu entry.
 """
 self.resizeScene(self.deltaSize, True)
 self.__checkSizeActions()
 def __incHeight(self):
 """
 Private method to handle the increase height context menu entry.
 """
 self.resizeScene(self.deltaSize, False)
 self.__checkSizeActions()
 def __decWidth(self):
 """
 Private method to handle the decrease width context menu entry.
 """
 self.resizeScene(-self.deltaSize, True)
 self.__checkSizeActions()
 def __decHeight(self):
 """
 Private method to handle the decrease height context menu entry.
 """
 self.resizeScene(-self.deltaSize, False)
 self.__checkSizeActions()
 def __setSize(self):
 """
 Private method to handle the set size context menu entry.
 """
 from .UMLSceneSizeDialog import UMLSceneSizeDialog
 rect = self._getDiagramRect(10)
 sceneRect = self.scene().sceneRect()
-dlg = UMLSceneSizeDialog(sceneRect.width(), sceneRect.height(),
+dlg = UMLSceneSizeDialog(
-rect.width(), rect.height(), self)
+sceneRect.width(), sceneRect.height(), rect.width(), rect.height(), self
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 width, height = dlg.getData()
 self.setSceneSize(width, height)
 self.__checkSizeActions()
 def autoAdjustSceneSize(self, limit=False):
 """
 Public method to adjust the scene size to the diagram size.
 @param limit flag indicating to limit the scene to the
 initial size
 @type bool
 """
 super().autoAdjustSceneSize(limit=limit)
 self.__checkSizeActions()
 def saveImage(self):
 """
 Public method to handle the save context menu entry.
 """
 fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save Diagram"),
 "",
-self.tr("Portable Network Graphics (*.png);;"
+self.tr(
-"Scalable Vector Graphics (*.svg)"),
+"Portable Network Graphics (*.png);;" "Scalable Vector Graphics (*.svg)"
+),
 "",
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if fname:
 fpath = pathlib.Path(fname)
 if not fpath.suffix:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fpath = fpath.with_suffix(ex)
 if fpath.exists():
 res = EricMessageBox.yesNo(
 self,
 self.tr("Save Diagram"),
-self.tr("<p>The file <b>{0}</b> already exists."
+self.tr(
-" Overwrite it?</p>").format(fpath),
+"<p>The file <b>{0}</b> already exists." " Overwrite it?</p>"
-icon=EricMessageBox.Warning)
+).format(fpath),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
-success = super().saveImage(
+success = super().saveImage(str(fpath), fpath.suffix.upper())
-str(fpath), fpath.suffix.upper())
 if not success:
 EricMessageBox.critical(
 self,
 self.tr("Save Diagram"),
 self.tr(
-"""<p>The file <b>{0}</b> could not be saved.</p>""")
+"""<p>The file <b>{0}</b> could not be saved.</p>"""
-.format(fpath))
+).format(fpath),
+)
 def __relayout(self):
 """
 Private slot to handle the re-layout context menu entry.
 """
 self.__itemId = -1
 self.scene().clear()
 self.relayout.emit()
 def __rescan(self):
 """
 Private slot to handle the re-scan context menu entry.
 """
 # 1. save positions of all items and names of selected items
 name = item.getName()
 if name:
 itemPositions[name] = (item.x(), item.y())
 if item.isSelected():
 selectedItems.append(name)
 # 2. save
 # 2. re-layout the diagram
 self.__relayout()
 # 3. move known items to the saved positions
 for item in self.filteredItems(self.scene().items(), UMLItem):
 name = item.getName()
 if name in itemPositions:
 item.setPos(*itemPositions[name])
 if name in selectedItems:
 item.setSelected(True)
 def printDiagram(self):
 """
 Public slot called to print the diagram.
 """
 printer = QPrinter(mode=QPrinter.PrinterMode.PrinterResolution)
 printer.setColorMode(QPrinter.ColorMode.GrayScale)
 if Preferences.getPrinter("FirstPageFirst"):
 printer.setPageOrder(QPrinter.PageOrder.FirstPageFirst)
 else:
 printer.setPageOrder(QPrinter.PageOrder.LastPageFirst)
-printer.setPageMargins(QMarginsF(
+printer.setPageMargins(
-Preferences.getPrinter("LeftMargin") * 10,
+QMarginsF(
-Preferences.getPrinter("TopMargin") * 10,
+Preferences.getPrinter("LeftMargin") * 10,
-Preferences.getPrinter("RightMargin") * 10,
+Preferences.getPrinter("TopMargin") * 10,
-Preferences.getPrinter("BottomMargin") * 10),
+Preferences.getPrinter("RightMargin") * 10,
-QPageLayout.Unit.Millimeter
+Preferences.getPrinter("BottomMargin") * 10,
+),
+QPageLayout.Unit.Millimeter,
 )
 printerName = Preferences.getPrinter("PrinterName")
 if printerName:
 printer.setPrinterName(printerName)
 printDialog = QPrintDialog(printer, self)
 if printDialog.exec():
-super().printDiagram(
+super().printDiagram(printer, self.diagramName)
-printer, self.diagramName)
 def printPreviewDiagram(self):
 """
 Public slot called to show a print preview of the diagram.
 """
 from PyQt6.QtPrintSupport import QPrintPreviewDialog
 printer = QPrinter(mode=QPrinter.PrinterMode.PrinterResolution)
 printer.setFullPage(True)
 if Preferences.getPrinter("ColorMode"):
 printer.setColorMode(QPrinter.ColorMode.Color)
 else:
 printer.setColorMode(QPrinter.ColorMode.GrayScale)
 if Preferences.getPrinter("FirstPageFirst"):
 printer.setPageOrder(QPrinter.PageOrder.FirstPageFirst)
 else:
 printer.setPageOrder(QPrinter.PageOrder.LastPageFirst)
-printer.setPageMargins(QMarginsF(
+printer.setPageMargins(
-Preferences.getPrinter("LeftMargin") * 10,
+QMarginsF(
-Preferences.getPrinter("TopMargin") * 10,
+Preferences.getPrinter("LeftMargin") * 10,
-Preferences.getPrinter("RightMargin") * 10,
+Preferences.getPrinter("TopMargin") * 10,
-Preferences.getPrinter("BottomMargin") * 10),
+Preferences.getPrinter("RightMargin") * 10,
-QPageLayout.Unit.Millimeter
+Preferences.getPrinter("BottomMargin") * 10,
+),
+QPageLayout.Unit.Millimeter,
 )
 printerName = Preferences.getPrinter("PrinterName")
 if printerName:
 printer.setPrinterName(printerName)
 preview = QPrintPreviewDialog(printer, self)
 preview.paintRequested[QPrinter].connect(self.__printPreviewPrint)
 preview.exec()
 def __printPreviewPrint(self, printer):
 """
 Private slot to generate a print preview.
 @param printer reference to the printer object
 @type QPrinter
 """
 super().printDiagram(printer, self.diagramName)
 def setDiagramName(self, name):
 """
 Public slot to set the diagram name.
 @param name diagram name
 @type str
 """
 self.diagramName = name
 def __alignShapes(self, alignment):
 """
 Private slot to align the selected shapes.
 @param alignment alignment type
 @type Qt.AlignmentFlag
 """
 # step 1: get all selected items
 items = self.scene().selectedItems()
 if len(items) <= 1:
 return
 # step 2: find the index of the item to align in relation to
 amount = None
 for i, item in enumerate(items):
 rect = item.sceneBoundingRect()
 if alignment == Qt.AlignmentFlag.AlignLeft:
 # __IGNORE_WARNING_Y102__
 if amount is None or rect.height() > amount:
 amount = rect.height()
 index = i
 rect = items[index].sceneBoundingRect()
 # step 3: move the other items
 for i, item in enumerate(items):
 if i == index:
 continue
 itemrect = item.sceneBoundingRect()
 xOffset = yOffset = 0
 if alignment == Qt.AlignmentFlag.AlignLeft:
 xOffset = rect.x() - itemrect.x()
 elif alignment == Qt.AlignmentFlag.AlignRight:
-xOffset = (
+xOffset = (rect.x() + rect.width()) - (itemrect.x() + itemrect.width())
-(rect.x() + rect.width()) -
-(itemrect.x() + itemrect.width())
-)
 elif alignment == Qt.AlignmentFlag.AlignHCenter:
-xOffset = (
+xOffset = (rect.x() + rect.width() // 2) - (
-(rect.x() + rect.width() // 2) -
+itemrect.x() + itemrect.width() // 2
-(itemrect.x() + itemrect.width() // 2)
 )
 elif alignment == Qt.AlignmentFlag.AlignTop:
 yOffset = rect.y() - itemrect.y()
 elif alignment == Qt.AlignmentFlag.AlignBottom:
-yOffset = (
+yOffset = (rect.y() + rect.height()) - (
-(rect.y() + rect.height()) -
+itemrect.y() + itemrect.height()
-(itemrect.y() + itemrect.height())
 )
 elif alignment == Qt.AlignmentFlag.AlignVCenter:
-yOffset = (
+yOffset = (rect.y() + rect.height() // 2) - (
-(rect.y() + rect.height() // 2) -
+itemrect.y() + itemrect.height() // 2
-(itemrect.y() + itemrect.height() // 2)
 )
 item.moveBy(xOffset, yOffset)
 self.scene().update()
 def __itemsBoundingRect(self, items):
 """
 Private method to calculate the bounding rectangle of the given items.
 @param items list of items to operate on
 @type list of UMLItem
 @return bounding rectangle
 @rtype QRectF
 """
 left = min(rect.left(), left)
 right = max(rect.right(), right)
 top = min(rect.top(), top)
 bottom = max(rect.bottom(), bottom)
 return QRectF(left, top, right - left, bottom - top)
 def keyPressEvent(self, evt):
 """
 Protected method handling key press events.
 @param evt reference to the key event
 @type QKeyEvent
 """
 key = evt.key()
-if key in [Qt.Key.Key_Up, Qt.Key.Key_Down, Qt.Key.Key_Left,
+if key in [Qt.Key.Key_Up, Qt.Key.Key_Down, Qt.Key.Key_Left, Qt.Key.Key_Right]:
-Qt.Key.Key_Right]:
 items = self.filteredItems(self.scene().selectedItems())
 if items:
 if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
 stepSize = 50
 else:
 dy = 0
 for item in items:
 item.moveBy(dx, dy)
 evt.accept()
 return
 super().keyPressEvent(evt)
 def wheelEvent(self, evt):
 """
 Protected method to handle wheel events.
 @param evt reference to the wheel event
 @type QWheelEvent
 """
 if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
 delta = evt.angleDelta().y()
 self.zoomOut()
 elif delta > 0:
 self.zoomIn()
 evt.accept()
 return
 super().wheelEvent(evt)
 def event(self, evt):
 """
 Public method handling events.
 @param evt reference to the event
 @type QEvent
 @return flag indicating, if the event was handled
 @rtype bool
 """
 if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
 return super().event(evt)
 def gestureEvent(self, evt):
 """
 Protected method handling gesture events.
 @param evt reference to the gesture event
 @type QGestureEvent
 """
 pinch = evt.gesture(Qt.GestureType.PinchGesture)
 if pinch:
 if pinch.state() == Qt.GestureState.GestureStarted:
 pinch.setTotalScaleFactor(self.zoom() / 100.0)
 elif pinch.state() == Qt.GestureState.GestureUpdated:
 self.setZoom(int(pinch.totalScaleFactor() * 100))
 evt.accept()
 def getItemId(self):
 """
 Public method to get the ID to be assigned to an item.
 @return item ID
 @rtype int
 """
 self.__itemId += 1
 return self.__itemId
 def findItem(self, itemId):
 """
 Public method to find an UML item based on the ID.
 @param itemId of the item to search for
 @type int
 @return item found or None
 @rtype UMLItem
 """
 try:
 if item.getId() == itemId:
 return item
 except AttributeError:
 continue
 return None
 def findItemByName(self, name):
 """
 Public method to find an UML item based on its name.
 @param name name to look for
 @type str
 @return item found or None
 @rtype UMLItem
 """
 try:
 if item.getName() == name:
 return item
 except AttributeError:
 continue
 return None
 def parsePersistenceData(self, version, data):
 """
 Public method to parse persisted data.
 @param version version of the data
 @type str
 @param data persisted data to be parsed
 @type list of str
 @return tuple of flag indicating success (boolean) and faulty line
 number
 @rtype int
 """
 umlItems = {}
 if not data[0].startswith("diagram_name:"):
 return False, 0
 self.diagramName = data[0].split(": ", 1)[1].strip()
 from .ClassItem import ClassItem
 from .ModuleItem import ModuleItem
 from .PackageItem import PackageItem
 from .AssociationItem import AssociationItem
 for linenum, line in enumerate(data[1:], start=1):
 if not line.startswith(("item:", "association:")):
 return False, linenum
 key, value = line.split(": ", 1)
 if key == "item":
 itemId, x, y, itemType, itemData = value.split(", ", 4)
 try:
 itemId = int(itemId.split("=", 1)[1].strip())
 x = float(x.split("=", 1)[1].strip())
 y = float(y.split("=", 1)[1].strip())
 itemType = itemType.split("=", 1)[1].strip()
 if itemType == ClassItem.ItemType:
-itm = ClassItem(x=0, y=0, scene=self.scene(),
+itm = ClassItem(
-colors=self.getDrawingColors())
+x=0, y=0, scene=self.scene(), colors=self.getDrawingColors()
+)
 elif itemType == ModuleItem.ItemType:
-itm = ModuleItem(x=0, y=0, scene=self.scene(),
+itm = ModuleItem(
-colors=self.getDrawingColors())
+x=0, y=0, scene=self.scene(), colors=self.getDrawingColors()
+)
 elif itemType == PackageItem.ItemType:
-itm = PackageItem(x=0, y=0, scene=self.scene(),
+itm = PackageItem(
-colors=self.getDrawingColors())
+x=0, y=0, scene=self.scene(), colors=self.getDrawingColors()
+)
 itm.setPos(x, y)
 itm.setId(itemId)
 umlItems[itemId] = itm
 if not itm.parseItemDataString(version, itemData):
 return False, linenum
 except ValueError:
 return False, linenum
 elif key == "association":
-srcId, dstId, assocType, topToBottom = (
+(
-AssociationItem.parseAssociationItemDataString(
+srcId,
-value.strip())
+dstId,
+assocType,
+topToBottom,
+) = AssociationItem.parseAssociationItemDataString(value.strip())
+assoc = AssociationItem(
+umlItems[srcId], umlItems[dstId], assocType, topToBottom
 )
-assoc = AssociationItem(umlItems[srcId], umlItems[dstId],
-assocType, topToBottom)
 self.scene().addItem(assoc)
 return True, -1
 def toDict(self):
 """
 Public method to collect data to be persisted.
 @return dictionary containing data to be persisted
 @rtype dict
 """
 items = [
-item.toDict()
+item.toDict() for item in self.filteredItems(self.scene().items(), UMLItem)
-for item in self.filteredItems(self.scene().items(), UMLItem)
 ]
 from .AssociationItem import AssociationItem
 associations = [
 assoc.toDict()
-for assoc in self.filteredItems(self.scene().items(),
+for assoc in self.filteredItems(self.scene().items(), AssociationItem)
-AssociationItem)
 ]
 data = {
 "diagram_name": self.diagramName,
 "items": items,
 "associations": associations,
 }
 return data
 def fromDict(self, version, data):
 """
 Public method to populate the class with data persisted by 'toDict()'.
 @param version version of the data
 @type str
 @param data dictionary containing the persisted data
 @type dict
 @return flag indicating success
 from .UMLItem import UMLItem
 from .ClassItem import ClassItem
 from .ModuleItem import ModuleItem
 from .PackageItem import PackageItem
 from .AssociationItem import AssociationItem
 umlItems = {}
 try:
 self.diagramName = data["diagram_name"]
 for itemData in data["items"]:
 if itemData["type"] == UMLItem.ItemType:
-itm = UMLItem.fromDict(
+itm = UMLItem.fromDict(itemData, colors=self.getDrawingColors())
-itemData, colors=self.getDrawingColors())
 elif itemData["type"] == ClassItem.ItemType:
-itm = ClassItem.fromDict(
+itm = ClassItem.fromDict(itemData, colors=self.getDrawingColors())
-itemData, colors=self.getDrawingColors())
 elif itemData["type"] == ModuleItem.ItemType:
-itm = ModuleItem.fromDict(
+itm = ModuleItem.fromDict(itemData, colors=self.getDrawingColors())
-itemData, colors=self.getDrawingColors())
 elif itemData["type"] == PackageItem.ItemType:
-itm = PackageItem.fromDict(
+itm = PackageItem.fromDict(itemData, colors=self.getDrawingColors())
-itemData, colors=self.getDrawingColors())
 if itm is not None:
 umlItems[itm.getId()] = itm
 self.scene().addItem(itm)
 for assocData in data["associations"]:
 assoc = AssociationItem.fromDict(
-assocData, umlItems, colors=self.getDrawingColors())
+assocData, umlItems, colors=self.getDrawingColors()
+)
 self.scene().addItem(assoc)
 return True
 except KeyError:
 return False

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Graphics/UMLGraphicsView.py

src/eric7/Graphics/UMLGraphicsView.py