def __init__(self, pyutClass: PyutClass = None, w: int = 0, h: int = 0):
"""
Args:
pyutClass: a PyutClass object
w: Width of the shape
h: Height of the shape
"""
if pyutClass is None:
pyutObject = PyutClass()
else:
pyutObject = pyutClass
width: int = w
height: int = h
# Use preferences to get initial size if not specified
# Note: auto_resize_shape_on_edit must be False for this size to actually stick
preferences: PyutPreferences = PyutPreferences()
if w == 0:
width = preferences.classDimensions.width
if h == 0:
height = preferences.classDimensions.height
super().__init__(pyutObject, width=width, height=height)
self._nameFont: Font = Font(DEFAULT_FONT_SIZE, FONTFAMILY_SWISS,
FONTSTYLE_NORMAL, FONTWEIGHT_BOLD)
self.logger: Logger = getLogger(__name__)
def _generatePyutClasses(self):
for className in self._classNames():
pyutClass: PyutClass = PyutClass(name=className)
pyutClass = self._addFields(pyutClass)
for methodName in self._methodNames(className):
pyutMethod: PyutMethod = PyutMethod(name=methodName)
if methodName[0:2] == "__":
pyutMethod.setVisibility(PyutVisibilityEnum.PRIVATE)
elif methodName[0] == "_":
pyutMethod.setVisibility(PyutVisibilityEnum.PROTECTED)
else:
pyutMethod.setVisibility(PyutVisibilityEnum.PUBLIC)
pyutMethod = self._addParameters(pyutMethod)
pyutMethod.sourceCode = self.visitor.methodCode[methodName]
pyutClass.addMethod(pyutMethod)
setterProperties: PyutPythonVisitor.Parameters = self.visitor.setterProperties
getterProperties: PyutPythonVisitor.Parameters = self.visitor.getterProperties
for propName in self.visitor.propertyNames:
setterParams: List[str] = setterProperties[propName]
getterParams: List[str] = getterProperties[propName]
self.logger.info(f'Processing - {propName=} {setterParams=} {getterParams=}')
setter, getter = self._createProperties(propName=propName, setterParams=setterParams)
pyutClass.addMethod(setter)
pyutClass.addMethod(getter)
self._pyutClasses[className] = pyutClass
self.logger.info(f'Generated {len(self._pyutClasses)} classes')
def _readFoundationCoreClass(self, coreClass):
"""
Read one Foundation.Core.Class
@param coreClass : Foundation.Core.Class element
@author C.Dutoit
"""
# Get class name
className = self._readFoundationCoreClassName(coreClass)
self.logger.info("Reading class ", className, end=' ')
# Get class ID
classID = str(coreClass.getAttribute("xmi.id"))
self.logger.info("id = ", classID, end=' ')
# Save class
pyutClass = PyutClass(className)
# Get class abstract status
isAbstract = self._readFoundationCoreClassIsAbstract(coreClass)
self.logger.info("isAbstract = ", isAbstract)
if isAbstract:
pyutClass.setStereotype("Abstract")
# Get class features
self._readFoundationCoreClassifierFeature(coreClass, pyutClass)
# Make the PyutClass visible
oglClass = OglClass(pyutClass)
x = (len(self._dicOglClasses) % 10) * 100
y = len(self._dicOglClasses) / 10 * 100
self._umlFrame.addShape(oglClass, x, y)
oglClass.autoResize()
self._dicOglClasses[classID] = oglClass
def _createNewClass(self, x, y):
"""
Add a new class at (x, y).
@return PyutClass : the newly created PyutClass
@since 1.4
@author L. Burgbacher <*****@*****.**>
"""
from org.pyut.general.Mediator import getMediator
from org.pyut.model.PyutClass import PyutClass
from org.pyut.ogl.OglClass import OglClass
med = getMediator()
umlFrame = med.getFileHandling().getCurrentFrame()
pyutClass = PyutClass(_("NoName"))
oglClass = OglClass(pyutClass)
med.classEditor(pyutClass)
# med.autoResize(pyutClass)
umlFrame.addShape(oglClass, x, y, withModelUpdate=True)
med.autoResize(pyutClass)
umlFrame.Refresh()
return oglClass
def _generatePyutClasses(self):
for className in self._classNames():
pyutClass: PyutClass = PyutClass(name=className)
pyutClass = self._addFields(pyutClass)
for methodName in self._methodNames(className):
pyutMethod: PyutMethod = PyutMethod(name=methodName)
if methodName[0:2] == "__":
pyutMethod.setVisibility(PyutVisibilityEnum.PRIVATE)
elif methodName[0] == "_":
pyutMethod.setVisibility(PyutVisibilityEnum.PROTECTED)
else:
pyutMethod.setVisibility(PyutVisibilityEnum.PUBLIC)
pyutMethod = self._addParameters(pyutMethod)
pyutMethod.sourceCode = self.visitor.methodCode[methodName]
pyutClass.addMethod(pyutMethod)
setterProperties: Parameters = self.visitor.setterProperties
getterProperties: Parameters = self.visitor.getterProperties
pyutClass = self._generatePropertiesAsMethods(
pyutClass, getterProperties, setterProperties)
if className in self.visitor.dataClassNames:
self._createDataClassPropertiesAsFields(
pyutClass, self.visitor.dataClassProperties)
self._pyutClasses[className] = pyutClass
self.logger.info(f'Generated {len(self._pyutClasses)} classes')
def _getOglClasses(self, xmlOglClasses, dicoOglObjects, umlFrame, oldData):
"""
Parse the XMI elements given and build data layer for PyUT classes.
If file is version 1.0, the dictionary given will contain, for key,
the name of the OGL object. Otherwise, it will be the ID
(multi-same-name support from version 1.1). Everything is fixed
later.
@param Element[] xmlOglClasses : XMI 'GraphicClass' elements
@param {id / srcName, OglObject} dicoOglObjects : OGL objects loaded
@param UmlFrame umlFrame : Where to draw
@param int oldData : If old data (v1.0), 1 else 0
@since 2.0
@author Philippe Waelti <*****@*****.**>
"""
pyutClass = PyutClass()
# adding name for this class
className = xmlOglClasses.getElementsByTagName("Foundation.Core.ModelElement.name")
self.logger.debug(f'Ogl class name: {className}')
if len(className) > 0:
name = className[0].firstChild
if name.nodeType == name.TEXT_NODE:
pyutClass.setName(name.data)
oglClass = OglClass(pyutClass, 50, 50)
# adding methods for this class
pyutClass.setMethods(self._getMethods(xmlOglClasses))
# adding fields for this class
pyutClass.fields = self._getFields(xmlOglClasses)
# for class id
classId = xmlOglClasses.getAttribute("xmi.id")
self.logger.debug(f"Class ID: {classId}")
# for all the classes who are an inheritance link
for fathers in xmlOglClasses.getElementsByTagName("Foundation.Core.Generalization"):
linkId = fathers.getAttribute("xmi.idref")
self.logger.debug(f"parent: {linkId}")
if linkId not in self.dicoFather:
self.dicoFather[linkId] = {}
self.dicoFather[linkId][classId] = oglClass
# for all class whos are link
for links in xmlOglClasses.getElementsByTagName("Foundation.Core.Classifier.associationEnd"):
for link in links.getElementsByTagName("Foundation.Core.AssociationEnd"):
linkId = link.getAttribute("xmi.idref")
self.logger.debug(f"linkId: {linkId}")
if linkId not in self.dicoLinks:
self.dicoLinks[linkId] = oglClass
pyutClassId = pyutClass.getId()
self.logger.debug(f'pyutClassId: {pyutClassId}')
dicoOglObjects[pyutClassId] = oglClass
umlFrame.addShape(oglClass, 100, 100)
def createNewClass(self, x, y):
"""
Add a new class at (x, y).
@return PyutClass : the newly created PyutClass
"""
pyutClass: PyutClass = PyutClass(_("NoName"))
oglClass: OglClass = OglClass(pyutClass)
self.addShape(oglClass, x, y)
self.Refresh()
return pyutClass
def setUp(self):
self.logger: Logger = TestIDFactory.clsLogger
self.app: App = TestIDFactory.clsApp
self._idFactory: IDFactory = IDFactory()
self._pyutInterface: PyutInterface = PyutInterface()
self._destinationAnchor: SelectAnchorPoint = SelectAnchorPoint(
250, 250, AttachmentPoint.NORTH)
self._pyutClass: PyutClass = PyutClass(name='UnitTestClass')
def addHierarchy(self, display):
"""
Hardcoded example of a class diagram, for test purposes.
Classes come from self introspection !!!
OK, it's too big, but it's not a feature, just a toy.
@author L. Burgbacher <*****@*****.**>
@since 1.4
"""
# BeginBusyCursor()
from org.pyut.experimental.PythonMetaClassDataHandler import PythonMetaClassDataHandler
cg: PythonMetaClassDataHandler = PythonMetaClassDataHandler()
classes: List[type] = cg.getClassListFromNames(display)
classNameToOglClass: Dict[str, OglClass] = {}
# create the Pyut Class objects & associate Ogl graphical classes
for cl in classes:
# create objects
pyutClassDef: PyutClass = PyutClass(cl.__name__)
klassMethods: List[classmethod] = cg.getMethodsFromClass(cl)
# add the methods
methods: List[PyutMethod] = cg.generatePyutMethods(klassMethods)
methods = sorted(methods, key=PyutMethod.getName)
pyutClassDef.setMethods(methods)
oglClassDef = self.addToDiagram(pyutClassDef)
classNameToOglClass[cl.__name__] = oglClassDef
# now, search for parent links
for oglClassDef in classNameToOglClass.values():
pyutClassDef = oglClassDef.getPyutObject()
# skip object, it has no parent
if pyutClassDef.getName() == "object":
continue
parentNames = cg.getParentClassNames(classes, pyutClassDef)
for parent in parentNames:
dest = classNameToOglClass.get(parent)
if dest is not None: # maybe we don't have the parent loaded
self.createInheritanceLink(oglClassDef, dest)
oglClassDefinitions: List[OglClass] = list(
classNameToOglClass.values())
self.positionClassHierarchy(oglClassDefinitions)
def testCreateDataClassPropertiesAsFields(self):
sampleDataClassProperties: DataClassProperties = [
DataClassProperty(('DataTestClass', 'w="A String"')),
DataClassProperty(('DataTestClass', 'x:float=0.0')),
DataClassProperty(('DataTestClass', 'y:float=42.0')),
DataClassProperty(('DataTestClass', 'z:int'))
]
pyutClass: PyutClass = PyutClass(name='DataTestClass')
self.reverseEngineer._createDataClassPropertiesAsFields(
pyutClass=pyutClass, dataClassProperties=sampleDataClassProperties)
def getOglClasses(self, xmlOglClasses: NodeList) -> OglClasses:
"""
Loads to OGL objects
Parse the XML elements given and build data model for the Pyut classes.
Args:
xmlOglClasses: XML 'GraphicClass' elements
Returns:
The built dictionary uses an ID for the key and an OglClass for the value
"""
oglObjects: OglClasses = cast(OglClasses, {})
for xmlOglClass in xmlOglClasses:
xmlOglClass: Element = cast(Element, xmlOglClass)
pyutClass: PyutClass = PyutClass()
height: float = float(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_HEIGHT))
width: float = float(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_WIDTH))
oglClass: OglClass = OglClass(pyutClass, width, height)
xmlClass: Element = xmlOglClass.getElementsByTagName(PyutXmlConstants.ELEMENT_MODEL_CLASS)[0]
pyutClass.setId(int(xmlClass.getAttribute(PyutXmlConstants.ATTR_ID)))
pyutClass.setName(xmlClass.getAttribute(PyutXmlConstants.ATTR_NAME))
pyutClass.description = xmlClass.getAttribute(PyutXmlConstants.ATTR_DESCRIPTION)
if xmlClass.hasAttribute(PyutXmlConstants.ATTR_STEREOTYPE):
pyutClass.setStereotype(getPyutStereotype(xmlClass.getAttribute(PyutXmlConstants.ATTR_STEREOTYPE)))
# adding display properties (cd)
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_STEREOTYPE))
pyutClass.setShowStereotype(value)
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_METHODS))
pyutClass.showMethods = value
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_FIELDS))
pyutClass.showFields = value
pyutClass.setFilename(xmlClass.getAttribute(PyutXmlConstants.ATTR_FILENAME))
pyutClass.methods = self._getMethods(xmlClass)
pyutClass.fields = self._getFields(xmlClass)
# Adding properties necessary to place shape on a diagram frame
x = float(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_X))
y = float(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_Y))
oglClass.SetPosition(x, y)
oglObjects[pyutClass.getId()] = oglClass
return oglObjects
def _createNewClass(self) -> OglClass:
"""
Create a new class
Returns: the newly created OglClass
"""
className: str = f'{self._prefs.className}{CreateOglClassCommand.clsCounter}'
pyutClass: PyutClass = PyutClass(className)
oglClass: OglClass = OglClass(pyutClass)
CreateOglClassCommand.clsCounter += 1
return oglClass
def _createNewClass(self) -> OglClass:
"""
Create a new class
Returns: the newly created OglClass
"""
className: str = f'{self._preferences.className}{TestOglToMiniDomV10.clsCounter}'
pyutClass: PyutClass = PyutClass(className)
pyutClass.addMethod(self._generateAMethod())
pyutClass.fileName = '/Users/humberto.a.sanchez.ii/PycharmProjects/PyUt/src/UnitTest.py'
oglClass: OglClass = OglClass(pyutClass)
TestOglToMiniDomV10.clsCounter += 1
return oglClass
def _generateReadOnlyMethods(self):
# Note the missing setter for fontSize
getterProperties: Dict[str, List] = {
'fontSize': [''],
'verticalGap': ['']
}
setterProperties: Dict[str, List] = {'verticalGap': ['newValue']}
pyutClass: PyutClass = PyutClass(name='NormalPropertiesClass')
self.__setMockVisitorPropertyNames()
pyutClass = self.reverseEngineer._generatePropertiesAsMethods(
pyutClass=pyutClass,
getterProperties=getterProperties,
setterProperties=setterProperties)
return pyutClass
def __init__(self, pyutClass: PyutClass = None, w: float = DEFAULT_CLASS_WIDTH, h: float = DEFAULT_CLASS_HEIGHT):
"""
Args:
pyutClass: a PyutClass object
w: Width of the shape
h: Height of the shape
"""
if pyutClass is None:
pyutObject = PyutClass()
else:
pyutObject = pyutClass
super().__init__(pyutObject, w, h)
self.logger: Logger = getLogger(__name__)
self._nameFont: Font = Font(DEFAULT_FONT_SIZE, FONTFAMILY_SWISS, FONTSTYLE_NORMAL, FONTWEIGHT_BOLD)
def testSerialize(self):
pyutClass: PyutClass = PyutClass(name='Implementor')
implementor: OglClass = OglClass(pyutClass=pyutClass)
attachmentAnchor: SelectAnchorPoint = SelectAnchorPoint(
x=100, y=100, attachmentPoint=AttachmentPoint.NORTH)
cOglXFaceCmd: CreateOglInterfaceCommand = CreateOglInterfaceCommand(
implementor=implementor, attachmentAnchor=attachmentAnchor)
#
# Override the created OglInterface2
#
oglInterface: OglInterface2 = cOglXFaceCmd._shape
pyutInterface: PyutInterface = cOglXFaceCmd._pyutInterface
floatMethod: PyutMethod = TestCommandCommon.createTestMethod(
'floatMethod', PyutVisibilityEnum.PRIVATE, PyutType('float'))
intMethod: PyutMethod = TestCommandCommon.createTestMethod(
'intMethod', PyutVisibilityEnum.PROTECTED, PyutType('int'))
pyutInterface.methods = [intMethod, floatMethod]
oglInterface.pyutInterface = pyutInterface
cOglXFaceCmd._shape = oglInterface
serializedShape: str = cOglXFaceCmd.serialize()
self.logger.debug(f'{serializedShape=}')
self.assertIsNotNone(serializedShape, 'Something must come back')
self.maxDiff = None
self.logger.debug(
f'{len(self._serializedCommand)=} {len(serializedShape)=}')
import re
fixedSerializedShape = re.sub('shapeId=[0-9]*', 'shapeId=2',
serializedShape)
self.logger.debug(f'{fixedSerializedShape=}')
expectedValue: str = self._serializedCommand
actualValue: str = fixedSerializedShape
self.assertEqual(expectedValue, actualValue, 'Oops, something changed')
def __addClass(self, className: str) -> OglClass:
"""
Add a class to the dictionary of classes
Args:
className: Name of the class to be added
Returns: OglClass instance for the class
"""
# If the class name exists already, return the instance
if className in self._classes:
return self._classes[className]
# Create the class
pc: PyutClass = PyutClass(className) # A new PyutClass
po: OglClass = OglClass(pc) # A new OglClass
self._classes[className] = po
return po
def createClasses(self, name: str, x: int, y: int) -> CreatedClassesType:
"""
Create a pair of classes (pyutClass and oglClass)
Args:
name: Class Name
x: x-coordinate on the uml frame oglClass
y: y coordinate on the uml frame oglClass
Returns: A named tuple with attributes: pyutClass and oglClass
"""
pyutClass: PyutClass = PyutClass()
pyutClass.setName(name)
oglClass: OglClass = OglClass(pyutClass, 50, 50)
# To make this code capable of being debugged
oglClass.SetPosition(x=x, y=y)
self.addShape(oglClass, x, y)
createdClasses: CreatedClassesType = CreatedClassesType(
pyutClass=pyutClass, oglClass=oglClass)
return createdClasses
def createClasses(self, name: str, x: float,
y: float) -> CreatedClassesType:
"""
Create a pair of classes (pyutClass and oglClass)
Args:
name: Class Name
x: x-coordinate on the uml frame oglClass
y: y coordinate on the uml frame oglClass
Returns: A tuple with one of each: pyutClass and oglClass
"""
pyutClass: PyutClass = PyutClass()
pyutClass.setName(name)
oglClass: OglClass = OglClass(pyutClass, 50, 50)
# To make this code capable of being debugged
oglClass.SetPosition(x=x, y=y)
self.addShape(oglClass, x, y)
retData: CreatedClassesType = cast(CreatedClassesType,
(pyutClass, oglClass))
return retData
def _getOglClasses(self, xmlOglClasses, dicoOglObjects, dicoLink,
dicoFather, umlFrame):
"""
Parse the XML elements given and build data layer for PyUT classes.
If file is version 1.0, the dictionary given will contain, for key,
the name of the OGL object. Otherwise, it will be the ID
(multi-same-name support from version 1.1). Everything is fixed
later.
@param Element[] xmlOglClasses : XML 'GraphicClass' elements
@param {id / srcName, OglObject} dicoOglObjects : OGL objects loaded
@param {id / srcName, OglLink} dicoLink : OGL links loaded
@param {id / srcName, id / srcName} dicoFather: Inheritance
@param UmlFrame umlFrame : Where to draw
@since 2.0
@author Philippe Waelti <*****@*****.**>
"""
oldData = 0
for xmlOglClass in xmlOglClasses:
pyutClass = PyutClass()
# Building OGL class
height = int(xmlOglClass.getAttribute('height'))
width = int(xmlOglClass.getAttribute('width'))
oglClass = OglClass(pyutClass, width, height)
# Data layer class
xmlClass = xmlOglClass.getElementsByTagName('Class')[0]
# Backward compatibility (pyut v1.0). If id not present,
# auto set by the instantiation of object
if xmlClass.hasAttribute('id'):
pyutClass.setId(int(xmlClass.getAttribute('id')))
else:
oldData = 1
# adding name for this class
pyutClass.setName(xmlClass.getAttribute('name').encode("charmap"))
# adding description
pyutClass.setDescription(xmlClass.getAttribute('description'))
# adding stereotype
if xmlClass.hasAttribute('stereotype'):
pyutClass.setStereotype(
getPyutStereotype(xmlClass.getAttribute('stereotype')))
# adding methods for this class
pyutClass.setMethods(self._getMethods(xmlClass))
# adding fields for this class
pyutClass.fields = self._getFields(xmlClass)
# adding fathers
self._getFathers(xmlClass.getElementsByTagName("Father"),
dicoFather, pyutClass.getId())
# adding link for this class
dicoLink[pyutClass.getId()] = self._getLinks(xmlClass)[:]
dicoOglObjects[pyutClass.getId()] = oglClass
# Adding OGL class to UML Frame
x = int(xmlOglClass.getAttribute('x'))
y = int(xmlOglClass.getAttribute('y'))
umlFrame.addShape(oglClass, x, y)
return oldData
def _getOglClasses(self, xmlOglClasses, dicoOglObjects, dicoLink,
dicoFather, umlFrame):
"""
Parse the XML elements given and build data layer for PyUT classes.
If file is version 1.0, the dictionary given will contain, for key,
the name of the OGL object. Otherwise, it will be the ID
(multi-same-name support from version 1.1). Everything is fixed
later.
@param Element[] xmlOglClasses : XML 'GraphicClass' elements
@param {id / srcName, OglObject} dicoOglObjects : OGL objects loaded
@param {id / srcName, OglLink} dicoLink : OGL links loaded
@param {id / srcName, id / srcName} dicoFather: Inheritance
@param UmlFrame umlFrame : Where to draw
"""
for xmlOglClass in xmlOglClasses:
pyutClass: PyutClass = PyutClass()
# Building OGL class
height = float(xmlOglClass.getAttribute('height'))
width = float(xmlOglClass.getAttribute('width'))
oglClass = OglClass(pyutClass, width, height)
# Data layer class
xmlClass = xmlOglClass.getElementsByTagName('Class')[0]
pyutClass.setId(int(xmlClass.getAttribute('id')))
# adding name for this class
# pyutClass.setName(xmlClass.getAttribute('name').encode("charmap"))
# Python 3 is already utf-8; don't need to encode anything
pyutClass.setName(xmlClass.getAttribute('name'))
# print "PyutXml/open-4d00d"
# adding description
pyutClass.description = xmlClass.getAttribute('description')
# adding stereotype
if xmlClass.hasAttribute('stereotype'):
pyutClass.setStereotype(
getPyutStereotype(xmlClass.getAttribute('stereotype')))
# adding display properties (cd)
value = secure_bool(xmlClass.getAttribute('showStereotype'))
pyutClass.setShowStereotype(value)
value = secure_bool(xmlClass.getAttribute('showMethods'))
pyutClass.showMethods = value
value = secure_bool(xmlClass.getAttribute('showFields'))
pyutClass.showFields = value
# adding associated filename ([email protected])
pyutClass.setFilename(xmlClass.getAttribute('filename'))
# adding methods for this class
pyutClass.methods = self._getMethods(xmlClass)
# adding fields for this class
pyutClass.fields = self._getFields(xmlClass)
dicoOglObjects[pyutClass.getId()] = oglClass
# Adding OGL class to UML Frame
x = float(xmlOglClass.getAttribute('x'))
y = float(xmlOglClass.getAttribute('y'))
umlFrame.addShape(oglClass, x, y)
def getOglClasses(self, xmlOglClasses: NodeList) -> OglClasses:
"""
Loads to OGL objects
Parse the XML elements given and build data model for the Pyut classes.
Args:
xmlOglClasses: XML 'GraphicClass' elements
Returns:
The built dictionary uses an ID for the key and an OglClass for the value
"""
oglObjects: OglClasses = cast(OglClasses, {})
for element in xmlOglClasses:
xmlOglClass: Element = cast(Element, element)
pyutClass: PyutClass = PyutClass()
# Some old files used float sizes and positions
height: int = PyutUtils.strFloatToInt(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_HEIGHT))
width: int = PyutUtils.strFloatToInt(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_WIDTH))
oglClass: OglClass = OglClass(pyutClass, width, height)
xmlClass: Element = xmlOglClass.getElementsByTagName(PyutXmlConstants.ELEMENT_MODEL_CLASS)[0]
pyutClass.setId(int(xmlClass.getAttribute(PyutXmlConstants.ATTR_ID)))
pyutClass.setName(xmlClass.getAttribute(PyutXmlConstants.ATTR_NAME))
pyutClass.description = xmlClass.getAttribute(PyutXmlConstants.ATTR_DESCRIPTION)
if xmlClass.hasAttribute(PyutXmlConstants.ATTR_STEREOTYPE):
pyutClass.setStereotype(getPyutStereotype(xmlClass.getAttribute(PyutXmlConstants.ATTR_STEREOTYPE)))
# adding display properties (cd)
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_STEREOTYPE))
pyutClass.setShowStereotype(value)
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_METHODS))
pyutClass.showMethods = value
value = PyutUtils.secureBoolean(xmlClass.getAttribute(PyutXmlConstants.ATTR_SHOW_FIELDS))
pyutClass.showFields = value
displayParametersStr: str = xmlClass.getAttribute(PyutXmlConstants.ATTR_DISPLAY_PARAMETERS)
self.logger.info(f'{pyutClass.name=} -- {displayParametersStr=}')
if displayParametersStr is None or displayParametersStr == '':
pyutClass.displayParameters = PyutDisplayParameters.UNSPECIFIED
else:
displayParameters: PyutDisplayParameters = PyutDisplayParameters(displayParametersStr)
pyutClass.displayParameters = displayParameters
pyutClass.setFilename(xmlClass.getAttribute(PyutXmlConstants.ATTR_FILENAME))
pyutClass.methods = self._getMethods(xmlClass)
pyutClass.fields = self._getFields(xmlClass)
# Adding properties necessary to place shape on a diagram frame
x = PyutUtils.strFloatToInt(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_X))
y = PyutUtils.strFloatToInt(xmlOglClass.getAttribute(PyutXmlConstants.ATTR_Y))
oglClass.SetPosition(x, y)
oglObjects[pyutClass.getId()] = oglClass
return oglObjects