eric: comparison eric6/Graphics/ImportsDiagramBuilder.py

-:197414ba11cc
+:b3eefd7e58d1
 def __init__(self, dialog, view, project, package,
 showExternalImports=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 package name of a python package to show the import
-relationships (string)
+relationships
+@type str
 @param showExternalImports flag indicating to show exports from
-outside the package (boolean)
+outside the package
+@type bool
 """
 super().__init__(dialog, view, project)
 self.setObjectName("ImportsDiagram")
 self.showExternalImports = showExternalImports
 self.packagePath = os.path.abspath(package)
+self.__relPackagePath = (
+self.project.getRelativePath(self.packagePath)
+if self.project.isProjectSource(self.packagePath) else
+""
+)
 def initialize(self):
 """
 Public method to initialize the object.
 """
 def __buildModulesDict(self):
 """
 Private method to build a dictionary of modules contained in the
 package.
-@return dictionary of modules contained in the package.
+@return dictionary of modules contained in the package
+@rtype dict
 """
 import Utilities.ModuleParser
 extensions = (
 Preferences.getPython("Python3Extensions")
 )
 Public method to build the modules shapes of the diagram.
 """
 initlist = glob.glob(os.path.join(self.packagePath, '__init__.*'))
 if len(initlist) == 0:
 ct = QGraphicsTextItem(None)
-ct.setHtml(
+ct.setHtml(self.buildErrorMessage(
-self.tr(
+self.tr("The directory <b>'{0}'</b> is not a Python"
-"The directory <b>'{0}'</b> is not a Python package.")
+" package.").format(self.package)
-.format(self.package))
+))
 self.scene.addItem(ct)
 return
-shapes = {}
+self.__shapes = {}
-p = 10
-y = 10
-maxHeight = 0
-sceneRect = self.umlView.sceneRect()
 modules = self.__buildModulesDict()
-sortedkeys = sorted(modules.keys())
 externalMods = []
 packageList = self.shortPackage.split('.')
 packageListLen = len(packageList)
-for module in sortedkeys:
+for module in sorted(modules.keys()):
 impLst = []
-for i in modules[module].imports:
+for importName in modules[module].imports:
-n = (i[len(self.package) + 1:]
+n = (
-if i.startswith(self.package) else i)
+importName[len(self.package) + 1:]
-if i in modules:
+if importName.startswith(self.package) else
+importName
+)
+if importName in modules:
 impLst.append(n)
 elif self.showExternalImports:
 impLst.append(n)
 if n not in externalMods:
 externalMods.append(n)
-for i in list(modules[module].from_imports.keys()):
+for importName in list(modules[module].from_imports.keys()):
-if i.startswith('.'):
+if importName.startswith('.'):
-dots = len(i) - len(i.lstrip('.'))
+dots = len(importName) - len(importName.lstrip('.'))
 if dots == 1:
-n = i[1:]
+n = importName[1:]
-i = n
+importName = n
 else:
 if self.showExternalImports:
 n = '.'.join(
 packageList[:packageListLen - dots + 1] +
-[i[dots:]])
+[importName[dots:]])
 else:
-n = i
+n = importName
-elif i.startswith(self.package):
+elif importName.startswith(self.package):
-n = i[len(self.package) + 1:]
+n = importName[len(self.package) + 1:]
 else:
-n = i
+n = importName
-if i in modules:
+if importName in modules:
 impLst.append(n)
 elif self.showExternalImports:
 impLst.append(n)
 if n not in externalMods:
 externalMods.append(n)
 classNames = []
-for cls in list(modules[module].classes.keys()):
+for class_ in list(modules[module].classes.keys()):
-className = modules[module].classes[cls].name
+className = modules[module].classes[class_].name
 if className not in classNames:
 classNames.append(className)
 shape = self.__addModule(module, classNames, 0.0, 0.0)
-shapeRect = shape.sceneBoundingRect()
+self.__shapes[module] = (shape, impLst)
-shapes[module] = (shape, impLst)
-pn = p + shapeRect.width() + 10
-maxHeight = max(maxHeight, shapeRect.height())
-if pn > sceneRect.width():
-p = 10
-y += maxHeight + 10
-maxHeight = shapeRect.height()
-shape.setPos(p, y)
-p += shapeRect.width() + 10
-else:
-shape.setPos(p, y)
-p = pn
 for module in externalMods:
 shape = self.__addModule(module, [], 0.0, 0.0)
-shapeRect = shape.sceneBoundingRect()
+self.__shapes[module] = (shape, [])
-shapes[module] = (shape, [])
-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 __addModule(self, name, classes, x, y):
 """
 Private method to add a module to the diagram.
-@param name module name to be shown (string)
+@param name module name to be shown
+@type str
 @param classes list of class names contained in the module
-(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 imports item (ModuleItem)
+@param y y-coordinate
+@type float
+@return reference to the imports item
+@rtype ModuleItem
 """
 from .ModuleItem import ModuleItem, ModuleModel
 classes.sort()
 impM = ModuleModel(name, classes)
 impW = ModuleItem(impM, x, y, scene=self.scene,
 colors=self.umlView.getDrawingColors())
 impW.setId(self.umlView.getItemId())
 return impW
-def __createAssociations(self, shapes):
+def __arrangeNodes(self, nodes, routes, whiteSpaceFactor=1.2):
+"""
+Private method to arrange the shapes on the canvas.
+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 shapes list of shapes
+@param routes list of associations
+@type list of tuple of (str, str)
 """
 from .AssociationItem import AssociationItem, AssociationType
-for module in list(shapes.keys()):
+for route in routes:
-for rel in shapes[module][1]:
+assoc = AssociationItem(
-assoc = AssociationItem(
+self.__shapes[route[0]][0],
-shapes[module][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 "package={0}, show_external={1}".format(
 self.packagePath, self.showExternalImports)
 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("package=") or
 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
+"""
+data = {
+"project_name": self.project.getProjectName(),
+"show_external": self.showExternalImports,
+}
+data["package"] = (
+Utilities.fromNativeSeparators(self.__relPackagePath)
+if self.__relPackagePath else
+Utilities.fromNativeSeparators(self.packagePath)
+)
+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 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.showExternalImports = data["show_external"]
+packagePath = Utilities.toNativeSeparators(data["package"])
+if os.path.isabs(packagePath):
+self.packagePath = packagePath
+self.__relPackagePath = ""
+else:
+# relative package paths indicate a project package
+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
+self.__relPackagePath = packagePath
+self.package = self.project.getAbsolutePath(packagePath)
+except KeyError:
+return False, ""
+self.initialize()
+return True, ""

Mercurial Repositories > eric / file comparison

comparison: eric6/Graphics/ImportsDiagramBuilder.py

eric6/Graphics/ImportsDiagramBuilder.py