eric: comparison eric6/Graphics/ApplicationDiagramBuilder.py

-:197414ba11cc
+:b3eefd7e58d1
 """
 import os
 import glob
-from PyQt5.QtWidgets import QApplication
+from PyQt5.QtWidgets import QApplication, QInputDialog
 from E5Gui import E5MessageBox
 from E5Gui.E5ProgressDialog import E5ProgressDialog
 from .UMLDiagramBuilder import UMLDiagramBuilder
 """
 def __init__(self, dialog, view, project, noModules=False):
 """
 Constructor
-@param dialog reference to the UML dialog (UMLDialog)
+@param dialog reference to the UML dialog
-@param view reference to the view object (UMLGraphicsView)
+@type UMLDialog
-@param project reference to the project object (Project)
+@param view reference to the view object
+@type UMLGraphicsView
+@param project reference to the project object
+@type Project
 @param noModules flag indicating, that no module names should be
-shown (boolean)
+shown
+@type bool
 """
 super().__init__(dialog, view, project)
 self.setObjectName("ApplicationDiagram")
 self.noModules = noModules
 def __buildModulesDict(self):
 """
 Private method to build a dictionary of modules contained in the
 application.
-@return dictionary of modules contained in the application.
+@return dictionary of modules contained in the application
+@rtype dict
 """
 import Utilities.ModuleParser
 extensions = (
 Preferences.getPython("Python3Extensions") +
 ['.rb']
 moduleDict[name] = mod
 finally:
 progress.setValue(tot)
 progress.deleteLater()
 return moduleDict
+def __findApplicationRoot(self):
+"""
+Private method to find the application root path.
+@return application root path
+@rtype str
+"""
+candidates = []
+path = self.project.getProjectPath()
+init = os.path.join(path, "__init__.py")
+if os.path.exists(init):
+# project is a package
+return path
+else:
+# check, if one of the top directories is a package
+for entry in os.listdir(path):
+if entry.startswith("."):
+# ignore hidden files and directories
+continue
+fullpath = os.path.join(path, entry)
+if os.path.isdir(fullpath):
+init = os.path.join(fullpath, "__init__.py")
+if os.path.exists(init):
+candidates.append(fullpath)
+if len(candidates) == 1:
+return candidates[0]
+elif len(candidates) > 1:
+root, ok = QInputDialog.getItem(
+None,
+self.tr("Application Diagram"),
+self.tr("Select the application directory:"),
+sorted(candidates),
+0, True)
+if ok:
+return root
+else:
+E5MessageBox.warning(
+None,
+self.tr("Application Diagram"),
+self.tr("""No application package could be detected."""
+""" Aborting..."""))
+return None
 def buildDiagram(self):
 """
 Public method to build the packages shapes of the diagram.
 """
-project = (
+rpath = self.__findApplicationRoot()
-os.path.splitdrive(self.project.getProjectPath())[1]
+if rpath is None:
-.replace(os.sep, '.')[1:]
+# no root path detected
-)
+return
+root = os.path.splitdrive(rpath)[1].replace(os.sep, '.')[1:]
 packages = {}
-shapes = {}
+self.__shapes = {}
-p = 10
-y = 10
-maxHeight = 0
-sceneRect = self.umlView.sceneRect()
 modules = self.__buildModulesDict()
 # step 1: build a dictionary of packages
 for module in sorted(modules.keys()):
-packageName, moduleName = module.rsplit(".", 1)
+if "." in module:
+packageName, moduleName = module.rsplit(".", 1)
+else:
+packageName, moduleName = "", module
 if packageName in packages:
 packages[packageName][0].append(moduleName)
 else:
 packages[packageName] = ([moduleName], [])
 n = "{0}.{1}".format(modules[module].package,
 moduleImport)
 if n in modules:
 impLst.append(n)
 else:
-n = "{0}.{1}".format(project, moduleImport)
+n = "{0}.{1}".format(root, moduleImport)
 if n in modules:
 impLst.append(n)
 elif n in packages:
 n = "{0}.<<Dummy>>".format(n)
 impLst.append(n)
 else:
-n = "{0}.{1}".format(project, moduleImport)
+n = "{0}.{1}".format(root, moduleImport)
 if n in modules:
 impLst.append(n)
 for moduleImport in list(modules[module].from_imports.keys()):
 if moduleImport.startswith('.'):
 dots = len(moduleImport) - len(moduleImport.lstrip('.'))
 n = "{0}.{1}".format(modules[module].package,
 moduleImport)
 if n in modules:
 impLst.append(n)
 else:
-n = "{0}.{1}".format(project, moduleImport)
+n = "{0}.{1}".format(root, moduleImport)
 if n in modules:
 impLst.append(n)
 elif n in packages:
 n = "{0}.<<Dummy>>".format(n)
 impLst.append(n)
 else:
-n = "{0}.{1}".format(project, moduleImport)
+n = "{0}.{1}".format(root, moduleImport)
 if n in modules:
 impLst.append(n)
 for moduleImport in impLst:
 impPackage = moduleImport.rsplit(".", 1)[0]
-if (
+try:
-impPackage not in packages[package][1] and
+if (
-impPackage != package
+impPackage not in packages[package][1] and
-):
+impPackage != package
-packages[package][1].append(impPackage)
+):
+packages[package][1].append(impPackage)
+except KeyError:
+continue
 for package in sorted(packages.keys()):
 if package:
-relPackage = package.replace(project, '')
+relPackage = package.replace(root, '')
 if relPackage and relPackage[0] == '.':
 relPackage = relPackage[1:]
 else:
 relPackage = self.tr("<<Application>>")
 else:
 relPackage = self.tr("<<Others>>")
 shape = self.__addPackage(
 relPackage, packages[package][0], 0.0, 0.0)
-shapeRect = shape.sceneBoundingRect()
+self.__shapes[package] = (shape, packages[package][1])
-shapes[package] = (shape, packages[package][1])
-pn = p + shapeRect.width() + 10
+# build a list of routes
-maxHeight = max(maxHeight, shapeRect.height())
+nodes = []
-if pn > sceneRect.width():
+routes = []
-p = 10
+for module in self.__shapes:
-y += maxHeight + 10
+nodes.append(module)
-maxHeight = shapeRect.height()
+for rel in self.__shapes[module][1]:
-shape.setPos(p, y)
+route = (module, rel)
-p += shapeRect.width() + 10
+if route not in routes:
-else:
+routes.append(route)
-shape.setPos(p, y)
-p = pn
+self.__arrangeNodes(nodes, routes[:])
+self.__createAssociations(routes)
-rect = self.umlView._getDiagramRect(10)
-sceneRect = self.umlView.sceneRect()
-if rect.width() > sceneRect.width():
-sceneRect.setWidth(rect.width())
-if rect.height() > sceneRect.height():
-sceneRect.setHeight(rect.height())
-self.umlView.setSceneSize(sceneRect.width(), sceneRect.height())
-self.__createAssociations(shapes)
 self.umlView.autoAdjustSceneSize(limit=True)
 def __addPackage(self, name, modules, x, y):
 """
 Private method to add a package to the diagram.
-@param name package name to be shown (string)
+@param name package name to be shown
+@type str
 @param modules list of module names contained in the package
-(list of strings)
+@type list of str
-@param x x-coordinate (float)
+@param x x-coordinate
-@param y y-coordinate (float)
+@type float
-@return reference to the package item (PackageItem)
+@param y y-coordinate
+@type float
+@return reference to the package item
+@rtype PackageItem
 """
 from .PackageItem import PackageItem, PackageModel
 modules.sort()
 pm = PackageModel(name, modules)
 pw = PackageItem(pm, x, y, noModules=self.noModules, scene=self.scene,
 colors=self.umlView.getDrawingColors())
 pw.setId(self.umlView.getItemId())
 return pw
-def __createAssociations(self, shapes):
+def __arrangeNodes(self, nodes, routes, whiteSpaceFactor=1.2):
 """
-Private method to generate the associations between the package shapes.
+Private method to arrange the shapes on the canvas.
-@param shapes list of shapes
+The algorithm is borrowed from Boa Constructor.
+@param nodes list of nodes to arrange
+@type list of str
+@param routes list of routes
+@type list of tuple of (str, str)
+@param whiteSpaceFactor factor to increase whitespace between
+items
+@type float
+"""
+from . import GraphicsUtilities
+generations = GraphicsUtilities.sort(nodes, routes)
+# calculate width and height of all elements
+sizes = []
+for generation in generations:
+sizes.append([])
+for child in generation:
+sizes[-1].append(
+self.__shapes[child][0].sceneBoundingRect())
+# calculate total width and total height
+width = 0
+height = 0
+widths = []
+heights = []
+for generation in sizes:
+currentWidth = 0
+currentHeight = 0
+for rect in generation:
+if rect.height() > currentHeight:
+currentHeight = rect.height()
+currentWidth += rect.width()
+# update totals
+if currentWidth > width:
+width = currentWidth
+height += currentHeight
+# store generation info
+widths.append(currentWidth)
+heights.append(currentHeight)
+# add in some whitespace
+width *= whiteSpaceFactor
+height = height * whiteSpaceFactor - 20
+verticalWhiteSpace = 40.0
+sceneRect = self.umlView.sceneRect()
+width += 50.0
+height += 50.0
+swidth = sceneRect.width() if width < sceneRect.width() else width
+sheight = sceneRect.height() if height < sceneRect.height() else height
+self.umlView.setSceneSize(swidth, sheight)
+# distribute each generation across the width and the
+# generations across height
+y = 10.0
+for currentWidth, currentHeight, generation in (
+zip(reversed(widths), reversed(heights), reversed(generations))
+):
+x = 10.0
+# whiteSpace is the space between any two elements
+whiteSpace = (
+(width - currentWidth - 20) /
+(len(generation) - 1.0 or 2.0)
+)
+for name in generation:
+shape = self.__shapes[name][0]
+shape.setPos(x, y)
+rect = shape.sceneBoundingRect()
+x = x + rect.width() + whiteSpace
+y = y + currentHeight + verticalWhiteSpace
+def __createAssociations(self, routes):
+"""
+Private method to generate the associations between the module shapes.
+@param routes list of associations
+@type list of tuple of (str, str)
 """
 from .AssociationItem import AssociationItem, AssociationType
-for package in shapes:
+for route in routes:
-for rel in shapes[package][1]:
+assoc = AssociationItem(
-assoc = AssociationItem(
+self.__shapes[route[0]][0],
-shapes[package][0], shapes[rel][0],
+self.__shapes[route[1]][0],
 AssociationType.IMPORTS,
 colors=self.umlView.getDrawingColors())
 self.scene.addItem(assoc)
 def getPersistenceData(self):
 """
 Public method to get a string for data to be persisted.
-@return persisted data string (string)
+@return persisted data string
+@rtype str
 """
 return "project={0}, no_modules={1}".format(
 self.project.getProjectFile(), self.noModules)
 def parsePersistenceData(self, version, data):
 """
 Public method to parse persisted data.
-@param version version of the data (string)
+@param version version of the data
-@param data persisted data to be parsed (string)
+@type str
-@return flag indicating success (boolean)
+@param data persisted data to be parsed
+@type str
+@return flag indicating success
+@rtype bool
 """
 parts = data.split(", ")
 if (
 len(parts) != 2 or
 not parts[0].startswith("project=") or
 self.noModules = Utilities.toBool(parts[1].split("=", 1)[1].strip())
 self.initialize()
 return True
+def toDict(self):
+"""
+Public method to collect data to be persisted.
+@return dictionary containing data to be persisted
+@rtype dict
+"""
+return {
+"project_name": self.project.getProjectName(),
+"no_modules": self.noModules,
+}
+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 tuple containing a flag indicating success and an info
+message in case the diagram belongs to a different project
+@rtype tuple of (bool, str)
+"""
+try:
+self.noModules = data["no_modules"]
+if data["project_name"] != self.project.getProjectName():
+msg = self.tr(
+"<p>The diagram belongs to project <b>{0}</b>."
+" Please open it and try again.</p>"
+).format(data["project_name"])
+return False, msg
+except KeyError:
+return False, ""
+self.initialize()
+return True, ""

Mercurial Repositories > eric / file comparison

comparison: eric6/Graphics/ApplicationDiagramBuilder.py

eric6/Graphics/ApplicationDiagramBuilder.py