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

-:e9e7eca7efee
+:bf71ee032bb4
 class UMLDialogType(enum.Enum):
 """
 Class defining the UML dialog types.
 """
 CLASS_DIAGRAM = 0
 PACKAGE_DIAGRAM = 1
 IMPORTS_DIAGRAM = 2
 APPLICATION_DIAGRAM = 3
 NO_DIAGRAM = 255
 class UMLDialog(EricMainWindow):
 """
 Class implementing a dialog showing UML like diagrams.
 """
-FileVersions = ("1.0", )
-JsonFileVersions = ("1.0", )
+FileVersions = ("1.0",)
+JsonFileVersions = ("1.0",)
 UMLDialogType2String = {
-UMLDialogType.CLASS_DIAGRAM:
+UMLDialogType.CLASS_DIAGRAM: QCoreApplication.translate(
-QCoreApplication.translate("UMLDialog", "Class Diagram"),
+"UMLDialog", "Class Diagram"
-UMLDialogType.PACKAGE_DIAGRAM:
+),
-QCoreApplication.translate("UMLDialog", "Package Diagram"),
+UMLDialogType.PACKAGE_DIAGRAM: QCoreApplication.translate(
-UMLDialogType.IMPORTS_DIAGRAM:
+"UMLDialog", "Package Diagram"
-QCoreApplication.translate("UMLDialog", "Imports Diagram"),
+),
-UMLDialogType.APPLICATION_DIAGRAM:
+UMLDialogType.IMPORTS_DIAGRAM: QCoreApplication.translate(
-QCoreApplication.translate("UMLDialog", "Application Diagram"),
+"UMLDialog", "Imports Diagram"
+),
+UMLDialogType.APPLICATION_DIAGRAM: QCoreApplication.translate(
+"UMLDialog", "Application Diagram"
+),
 }
-def __init__(self, diagramType, project, path="", parent=None,
+def __init__(
-initBuilder=True, **kwargs):
+self, diagramType, project, path="", parent=None, initBuilder=True, **kwargs
+):
 """
 Constructor
 @param diagramType type of the diagram
 @type UMLDialogType
 @param project reference to the project object
 @type Project
 @param path file or directory path to build the diagram from
 @keyparam kwargs diagram specific data
 @type dict
 """
 super().__init__(parent)
 self.setObjectName("UMLDialog")
 self.__project = project
 self.__diagramType = diagramType
 from .UMLGraphicsView import UMLGraphicsView
 self.scene = QGraphicsScene(0.0, 0.0, 800.0, 600.0)
 self.umlView = UMLGraphicsView(self.scene, parent=self)
-self.builder = self.__diagramBuilder(
+self.builder = self.__diagramBuilder(self.__diagramType, path, **kwargs)
-self.__diagramType, path, **kwargs)
 if self.builder and initBuilder:
 self.builder.initialize()
 self.__fileName = ""
 self.__initActions()
 self.__initToolBars()
 self.setCentralWidget(self.umlView)
 self.umlView.relayout.connect(self.__relayout)
 self.setWindowTitle(self.__getDiagramTitel(self.__diagramType))
 def __getDiagramTitel(self, diagramType):
 """
 Private method to get a textual description for the diagram type.
 @param diagramType diagram type string
 @type str
 @return titel of the diagram
 @rtype str
 """
 return UMLDialog.UMLDialogType2String.get(
 diagramType, self.tr("Illegal Diagram Type")
 )
 def __initActions(self):
 """
 Private slot to initialize the actions.
 """
-self.closeAct = QAction(
+self.closeAct = QAction(UI.PixmapCache.getIcon("close"), self.tr("Close"), self)
-UI.PixmapCache.getIcon("close"),
-self.tr("Close"), self)
 self.closeAct.triggered.connect(self.close)
-self.openAct = QAction(
+self.openAct = QAction(UI.PixmapCache.getIcon("open"), self.tr("Load"), self)
-UI.PixmapCache.getIcon("open"),
-self.tr("Load"), self)
 self.openAct.triggered.connect(self.load)
 self.saveAct = QAction(
-UI.PixmapCache.getIcon("fileSave"),
+UI.PixmapCache.getIcon("fileSave"), self.tr("Save"), self
-self.tr("Save"), self)
+)
 self.saveAct.triggered.connect(self.__save)
 self.saveAsAct = QAction(
-UI.PixmapCache.getIcon("fileSaveAs"),
+UI.PixmapCache.getIcon("fileSaveAs"), self.tr("Save As..."), self
-self.tr("Save As..."), self)
+)
 self.saveAsAct.triggered.connect(self.__saveAs)
 self.saveImageAct = QAction(
-UI.PixmapCache.getIcon("fileSavePixmap"),
+UI.PixmapCache.getIcon("fileSavePixmap"), self.tr("Save as Image"), self
-self.tr("Save as Image"), self)
+)
 self.saveImageAct.triggered.connect(self.umlView.saveImage)
-self.printAct = QAction(
+self.printAct = QAction(UI.PixmapCache.getIcon("print"), self.tr("Print"), self)
-UI.PixmapCache.getIcon("print"),
-self.tr("Print"), self)
 self.printAct.triggered.connect(self.umlView.printDiagram)
 self.printPreviewAct = QAction(
-UI.PixmapCache.getIcon("printPreview"),
+UI.PixmapCache.getIcon("printPreview"), self.tr("Print Preview"), self
-self.tr("Print Preview"), self)
+)
-self.printPreviewAct.triggered.connect(
+self.printPreviewAct.triggered.connect(self.umlView.printPreviewDiagram)
-self.umlView.printPreviewDiagram)
 def __initToolBars(self):
 """
 Private slot to initialize the toolbars.
 """
 self.windowToolBar = QToolBar(self.tr("Window"), self)
 self.windowToolBar.setIconSize(UI.Config.ToolBarIconSize)
 self.windowToolBar.addAction(self.closeAct)
 self.fileToolBar = QToolBar(self.tr("File"), self)
 self.fileToolBar.setIconSize(UI.Config.ToolBarIconSize)
 self.fileToolBar.addAction(self.openAct)
 self.fileToolBar.addSeparator()
 self.fileToolBar.addAction(self.saveAct)
 self.fileToolBar.addAction(self.saveAsAct)
 self.fileToolBar.addAction(self.saveImageAct)
 self.fileToolBar.addSeparator()
 self.fileToolBar.addAction(self.printPreviewAct)
 self.fileToolBar.addAction(self.printAct)
 self.umlToolBar = self.umlView.initToolBar()
 self.addToolBar(Qt.ToolBarArea.TopToolBarArea, self.fileToolBar)
 self.addToolBar(Qt.ToolBarArea.TopToolBarArea, self.windowToolBar)
 self.addToolBar(Qt.ToolBarArea.TopToolBarArea, self.umlToolBar)
 def show(self, fromFile=False):
 """
 Public method to show the dialog.
 @param fromFile flag indicating, that the diagram was loaded
 from file
 @type bool
 """
 if not fromFile and self.builder:
 self.builder.buildDiagram()
 super().show()
 def __relayout(self):
 """
 Private method to re-layout the diagram.
 """
 if self.builder:
 self.builder.buildDiagram()
 def __diagramBuilder(self, diagramType, path, **kwargs):
 """
 Private method to instantiate a diagram builder object.
 @param diagramType type of the diagram
 @type UMLDialogType
 @param path file or directory path to build the diagram from
 @type str
 @keyparam kwargs diagram specific data
 @return reference to the instantiated diagram builder
 @rtype UMLDiagramBuilder
 """
 if diagramType == UMLDialogType.CLASS_DIAGRAM:
 from .UMLClassDiagramBuilder import UMLClassDiagramBuilder
 return UMLClassDiagramBuilder(
-self, self.umlView, self.__project, path, **kwargs)
+self, self.umlView, self.__project, path, **kwargs
+)
 elif diagramType == UMLDialogType.PACKAGE_DIAGRAM:
 from .PackageDiagramBuilder import PackageDiagramBuilder
 return PackageDiagramBuilder(
-self, self.umlView, self.__project, path, **kwargs)
+self, self.umlView, self.__project, path, **kwargs
+)
 elif diagramType == UMLDialogType.IMPORTS_DIAGRAM:
 from .ImportsDiagramBuilder import ImportsDiagramBuilder
 return ImportsDiagramBuilder(
-self, self.umlView, self.__project, path, **kwargs)
+self, self.umlView, self.__project, path, **kwargs
+)
 elif diagramType == UMLDialogType.APPLICATION_DIAGRAM:
 from .ApplicationDiagramBuilder import ApplicationDiagramBuilder
 return ApplicationDiagramBuilder(
-self, self.umlView, self.__project, **kwargs)
+self, self.umlView, self.__project, **kwargs
+)
 else:
 return None
 def __save(self):
 """
 Private slot to save the diagram with the current name.
 """
 self.__saveAs(self.__fileName)
 @pyqtSlot()
 def __saveAs(self, filename=""):
 """
 Private slot to save the diagram.
 @param filename name of the file to write to
 @type str
 """
 if not filename:
 fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save Diagram"),
 "",
-self.tr("Eric Graphics File (*.egj);;"
+self.tr(
-"Eric Text Graphics File (*.e5g);;"
+"Eric Graphics File (*.egj);;"
-"All Files (*)"),
+"Eric Text Graphics File (*.e5g);;"
+"All Files (*)"
+),
 "",
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if not fname:
 return
 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
 filename = str(fpath)
 res = self.__writeJsonGraphicsFile(filename)
 if res:
 # save the file name only in case of success
 self.__fileName = filename
 # Note: remove loading of eric6 line based diagram format after 22.6
 def load(self, filename=""):
 """
 Public method to load a diagram from a file.
 @param filename name of the file to be loaded
 @type str
 @return flag indicating success
 @rtype bool
 """
 if not filename:
 filename = EricFileDialog.getOpenFileName(
 self,
 self.tr("Load Diagram"),
 "",
-self.tr("Eric Graphics File (*.egj);;"
+self.tr(
-"Eric Text Graphics File (*.e5g);;"
+"Eric Graphics File (*.egj);;"
-"All Files (*)"))
+"Eric Text Graphics File (*.e5g);;"
+"All Files (*)"
+),
+)
 if not filename:
 # Canceled by user
 return False
 return (
 self.__readLineBasedGraphicsFile(filename)
-if filename.endswith(".e5g") else
+if filename.endswith(".e5g")
+else
 # JSON format is the default
 self.__readJsonGraphicsFile(filename)
 )
 #######################################################################
 ## Methods to read and write eric graphics files of the old line
 ## based file format.
 #######################################################################
 def __readLineBasedGraphicsFile(self, filename):
 """
 Private method to read an eric graphics file using the old line
 based file format.
 @param filename name of the file to be read
 @type str
 @return flag indicating success
 @rtype bool
 """
 EricMessageBox.critical(
 self,
 self.tr("Load Diagram"),
 self.tr(
 """<p>The file <b>{0}</b> could not be read.</p>"""
-"""<p>Reason: {1}</p>""").format(filename, str(err)))
+"""<p>Reason: {1}</p>"""
+).format(filename, str(err)),
+)
 return False
 lines = data.splitlines()
 if len(lines) < 3:
 self.__showInvalidDataMessage(filename)
 return False
 try:
 # step 1: check version
 linenum = 0
 key, value = lines[linenum].split(": ", 1)
-if (
+if key.strip() != "version" or value.strip() not in UMLDialog.FileVersions:
-key.strip() != "version" or
-value.strip() not in UMLDialog.FileVersions
-):
 self.__showInvalidDataMessage(filename, linenum)
 return False
 else:
 version = value
 # step 2: extract diagram type
 linenum += 1
 key, value = lines[linenum].split(": ", 1)
 if key.strip() != "diagram_type":
 self.__showInvalidDataMessage(filename, linenum)
 except ValueError:
 self.__showInvalidDataMessage(filename, linenum)
 return False
 self.scene.clear()
 self.builder = self.__diagramBuilder(self.__diagramType, "")
 # step 3: extract scene size
 linenum += 1
 key, value = lines[linenum].split(": ", 1)
 if key.strip() != "scene_size":
 self.__showInvalidDataMessage(filename, linenum)
 width, height = [float(v.strip()) for v in value.split(";")]
 except ValueError:
 self.__showInvalidDataMessage(filename, linenum)
 return False
 self.umlView.setSceneSize(width, height)
 # step 4: extract builder data if available
 linenum += 1
 key, value = lines[linenum].split(": ", 1)
 if key.strip() == "builder_data":
 ok = self.builder.parsePersistenceData(version, value)
 if not ok:
 self.__showInvalidDataMessage(filename, linenum)
 return False
 linenum += 1
 # step 5: extract the graphics items
-ok, vlinenum = self.umlView.parsePersistenceData(
+ok, vlinenum = self.umlView.parsePersistenceData(version, lines[linenum:])
-version, lines[linenum:])
 if not ok:
 self.__showInvalidDataMessage(filename, linenum + vlinenum)
 return False
 except IndexError:
 self.__showInvalidDataMessage(filename)
 return False
 # everything worked fine, so remember the file name and set the
 # window title
 self.setWindowTitle(self.__getDiagramTitel(self.__diagramType))
 self.__fileName = filename
 return True
 def __showInvalidDataMessage(self, filename, linenum=-1):
 """
 Private slot to show a message dialog indicating an invalid data file.
 @param filename name of the file containing the invalid data
 @type str
 @param linenum number of the invalid line
 @type int
 """
 msg = (
-self.tr("""<p>The file <b>{0}</b> does not contain"""
+self.tr(
-""" valid data.</p>""").format(filename)
+"""<p>The file <b>{0}</b> does not contain""" """ valid data.</p>"""
-if linenum < 0 else
+).format(filename)
-self.tr("""<p>The file <b>{0}</b> does not contain"""
+if linenum < 0
-""" valid data.</p><p>Invalid line: {1}</p>"""
+else self.tr(
-).format(filename, linenum + 1)
+"""<p>The file <b>{0}</b> does not contain"""
+""" valid data.</p><p>Invalid line: {1}</p>"""
+).format(filename, linenum + 1)
 )
 EricMessageBox.critical(self, self.tr("Load Diagram"), msg)
 #######################################################################
 ## Methods to read and write eric graphics files of the JSON based
 ## file format.
 #######################################################################
 def __writeJsonGraphicsFile(self, filename):
 """
 Private method to write an eric graphics file using the JSON based
 file format.
 @param filename name of the file to write to
 @type str
 @return flag indicating a successful write
 @rtype bool
 """
 "width": self.scene.width(),
 "height": self.scene.height(),
 "builder": self.builder.toDict(),
 "view": self.umlView.toDict(),
 }
 try:
 jsonString = json.dumps(data, indent=2)
 with open(filename, "w") as f:
 f.write(jsonString)
 return True
 EricMessageBox.critical(
 self,
 self.tr("Save Diagram"),
 self.tr(
 """<p>The file <b>{0}</b> could not be saved.</p>"""
-"""<p>Reason: {1}</p>""").format(filename, str(err))
+"""<p>Reason: {1}</p>"""
+).format(filename, str(err)),
 )
 return False
 def __readJsonGraphicsFile(self, filename):
 """
 Private method to read an eric graphics file using the JSON based
 file format.
 @param filename name of the file to be read
 @type str
 @return flag indicating a successful read
 @rtype bool
 """
 EricMessageBox.critical(
 None,
 self.tr("Load Diagram"),
 self.tr(
 """<p>The file <b>{0}</b> could not be read.</p>"""
-"""<p>Reason: {1}</p>""").format(filename, str(err))
+"""<p>Reason: {1}</p>"""
+).format(filename, str(err)),
 )
 return False
 try:
 # step 1: check version
 if data["version"] in UMLDialog.JsonFileVersions:
 version = data["version"]
 else:
 self.__showInvalidDataMessage(filename)
 return False
 # step 2: set diagram type
 try:
 self.__diagramType = UMLDialogType(data["type"])
 except ValueError:
 self.__showInvalidDataMessage(filename)
 return False
 self.scene.clear()
 self.builder = self.__diagramBuilder(self.__diagramType, "")
 # step 3: set scene size
 self.umlView.setSceneSize(data["width"], data["height"])
 # step 4: extract builder data if available
 ok, msg = self.builder.fromDict(version, data["builder"])
 if not ok:
 if msg:
 res = EricMessageBox.warning(
 self,
 self.tr("Load Diagram"),
 msg,
 EricMessageBox.Abort | EricMessageBox.Ignore,
-EricMessageBox.Abort)
+EricMessageBox.Abort,
+)
 if res == EricMessageBox.Abort:
 return False
 else:
 self.umlView.setLayoutActionsEnabled(False)
 else:
 self.__showInvalidDataMessage(filename)
 return False
 # step 5: extract the graphics items
 ok = self.umlView.fromDict(version, data["view"])
 if not ok:
 self.__showInvalidDataMessage(filename)
 return False
 except KeyError:
 self.__showInvalidDataMessage(filename)
 return False
 # everything worked fine, so remember the file name and set the
 # window title
 self.setWindowTitle(self.__getDiagramTitel(self.__diagramType))
 self.__fileName = filename
 return True

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Graphics/UMLDialog.py

src/eric7/Graphics/UMLDialog.py