Back to index

salome-kernel  6.5.0
Public Member Functions | Public Attributes
KERNEL_PY.kernel.studyedit.StudyEditor Class Reference

List of all members.

Public Member Functions

def __init__
def findOrCreateComponent
def loadComponentEngine
def getOrLoadObject
def findOrCreateItem
def findItem
def createItem
def setItem
def removeItem
def setItemAtTag
def getAttributeValue
def setAttributeValue
def getTypeId
def setTypeId
def getFileType
def setFileType
def getFileName
def setFileName
def getIcon
def setIcon

Public Attributes

 studyId
 study
 builder

Detailed Description

This class provides utility methods to complement :class:`Study` and
:class:`StudyBuilder` classes. Those methods may be moved in those classes
in the future. The parameter `studyId` defines the ID of the study to
edit. If it is :const:`None`, the edited study will be the current study.
The preferred way to get a StudyEditor object is through the method
:meth:`getStudyEditor` which allows to reuse existing instances.

.. attribute:: studyId

   This instance attribute contains the ID of the edited study. This
   attribute should not be modified.

.. attribute:: study

   This instance attribute contains the underlying :class:`Study` object.
   It can be used to access the study but the attribute itself should not
   be modified.

.. attribute:: builder

   This instance attribute contains the underlying :class:`StudyBuilder`
   object. It can be used to edit the study but the attribute itself
   should not be modified.

Definition at line 75 of file studyedit.py.


Constructor & Destructor Documentation

def KERNEL_PY.kernel.studyedit.StudyEditor.__init__ (   self,
  studyId = None 
)

Definition at line 102 of file studyedit.py.

00102 
00103     def __init__(self, studyId = None):
00104         salome.salome_init()
00105         if studyId is None:
00106             studyId = getActiveStudyId()
00107         self.studyId = studyId
00108         self.study = salome.myStudyManager.GetStudyByID(studyId)
00109         if self.study is None:
00110             raise Exception("Can't create StudyEditor object: "
00111                             "Study %d doesn't exist" % studyId)
00112         self.builder = self.study.NewBuilder()

Here is the call graph for this function:


Member Function Documentation

def KERNEL_PY.kernel.studyedit.StudyEditor.createItem (   self,
  fatherItem,
  name,
  fileType = None,
  fileName = None,
  comment = None,
  icon = None,
  IOR = None,
  typeId = None 
)
Create a new object named `name` under `fatherItem` in the study, with
the given attributes. If an object named `name` already exists under
the father object, the new object is created with a new name `name_X`
where X is the first available index.

:type  fatherItem: SObject
:param fatherItem: item under which the new item will be added.

:return: new SObject created in the study

See :meth:`setItem` for the description of the other parameters.

Definition at line 261 of file studyedit.py.

00261 
00262                    comment = None, icon = None, IOR = None, typeId = None):
00263         """
00264         Create a new object named `name` under `fatherItem` in the study, with
00265         the given attributes. If an object named `name` already exists under
00266         the father object, the new object is created with a new name `name_X`
00267         where X is the first available index.
00268         
00269         :type  fatherItem: SObject
00270         :param fatherItem: item under which the new item will be added.
00271                 
00272         :return: new SObject created in the study
00273         
00274         See :meth:`setItem` for the description of the other parameters.
00275         """
00276         aSObject = self.builder.NewObject(fatherItem)
00277 
00278         aChildIterator = self.study.NewChildIterator(fatherItem)
00279         aMaxId = -1
00280         aLength = len(name)
00281         aDelim = "_"
00282         anIdRE = re.compile("^" + aDelim + "[0-9]+")
00283         aNameRE = re.compile("^" + name)
00284         while aChildIterator.More():
00285             aSObj = aChildIterator.Value()
00286             aChildIterator.Next()
00287             aName = aSObj.GetName()
00288             if re.match(aNameRE,aName):
00289                 aTmp = aName[aLength:]
00290                 if re.match(anIdRE,aTmp):
00291                     import string
00292                     anId = string.atol(aTmp[1:])
00293                     if aMaxId < anId:
00294                         aMaxId = anId
00295                         pass
00296                     pass
00297                 elif aMaxId < 0:
00298                     aMaxId = 0
00299                     pass
00300                 pass
00301             pass
00302         
00303         aMaxId = aMaxId + 1
00304         aName = name
00305         if aMaxId > 0:
00306             aName = aName + aDelim + str(aMaxId)
00307             pass
00308         
00309         self.setItem(aSObject, aName, fileType, fileName, comment, icon,
00310                      IOR, typeId)
00311     
00312         return aSObject

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.findItem (   self,
  fatherItem,
  name = None,
  fileType = None,
  fileName = None,
  comment = None,
  icon = None,
  IOR = None,
  typeId = None 
)
Find an item with given attributes under `fatherItem` in the study. If
none is found, return :const:`None`. If several items correspond to
the parameters, only the first one is returned. The search is made
only on given parameters (i.e. not :const:`None`). To look explicitly
for an empty attribute, use an empty string in the corresponding
parameter.

See :meth:`setItem` for the description of the parameters.

Definition at line 229 of file studyedit.py.

00229 
00230                  typeId = None):
00231         """
00232         Find an item with given attributes under `fatherItem` in the study. If
00233         none is found, return :const:`None`. If several items correspond to
00234         the parameters, only the first one is returned. The search is made
00235         only on given parameters (i.e. not :const:`None`). To look explicitly
00236         for an empty attribute, use an empty string in the corresponding
00237         parameter.
00238         
00239         See :meth:`setItem` for the description of the parameters.
00240         """
00241         foundItem = None;
00242         childIterator = self.study.NewChildIterator(fatherItem)
00243         while childIterator.More() and foundItem is None:
00244             childItem = childIterator.Value()
00245             if childItem and \
00246                (name is None or childItem.GetName() == name) and \
00247                (fileType is None or \
00248                 self.getFileType(childItem) == fileType) and \
00249                (fileName is None or \
00250                 self.getFileName(childItem) == fileName) and \
00251                (comment is None or childItem.GetComment() == comment) and \
00252                (icon is None or \
00253                 self.getIcon(childItem) == icon) and \
00254                (IOR is None or childItem.GetIOR() == IOR) and \
00255                (typeId is None or \
00256                 self.getTypeId(childItem) == typeId):
00257                 foundItem = childItem
00258             childIterator.Next()
00259         return foundItem

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.findOrCreateComponent (   self,
  moduleName,
  componentName = None,
  icon = None,
  containerName = _DEFAULT_CONTAINER 
)
Find a component corresponding to the Salome module `moduleName` in
the study. If none is found, create a new component and associate it
with the corresponding engine (i.e. the engine named `moduleName`).
Note that in Salome 5, the module name and engine name must be
identical (every module must provide an engine with the same name).
In Salome 6 it will be possible to define a different name for the
engine.

:type  moduleName: string
:param moduleName: name of the module corresponding to the component
           (the module name is the string value in the
           attribute "AttributeComment" of the component)

:type  componentName: string
:param componentName: name of the new component if created. If
              :const:`None`, use `moduleName` instead.

:type  icon: string
:param icon: icon for the new component (attribute "AttributePixMap").

:type  containerName: string
:param containerName: name of the container in which the engine should be
              loaded.

:return: the SComponent found or created.

Definition at line 114 of file studyedit.py.

00114 
00115                               icon = None, containerName = _DEFAULT_CONTAINER):
00116         """
00117         Find a component corresponding to the Salome module `moduleName` in
00118         the study. If none is found, create a new component and associate it
00119         with the corresponding engine (i.e. the engine named `moduleName`).
00120         Note that in Salome 5, the module name and engine name must be
00121         identical (every module must provide an engine with the same name).
00122         In Salome 6 it will be possible to define a different name for the
00123         engine.
00124 
00125         :type  moduleName: string
00126         :param moduleName: name of the module corresponding to the component
00127                            (the module name is the string value in the
00128                            attribute "AttributeComment" of the component)
00129 
00130         :type  componentName: string
00131         :param componentName: name of the new component if created. If
00132                               :const:`None`, use `moduleName` instead.
00133 
00134         :type  icon: string
00135         :param icon: icon for the new component (attribute "AttributePixMap").
00136 
00137         :type  containerName: string
00138         :param containerName: name of the container in which the engine should be
00139                               loaded.
00140 
00141         :return: the SComponent found or created.
00142 
00143         """
00144         sComponent = self.study.FindComponent(moduleName)
00145         if sComponent is None:
00146             sComponent = self.builder.NewComponent(moduleName)
00147             # Note that the NewComponent method set the "comment" attribute to the
00148             # value of its argument (moduleName here)
00149             if componentName is None:
00150                 componentName = moduleName
00151             self.builder.SetName(sComponent, componentName)
00152             if icon is not None:
00153                 # _MEM_ : This will be effective if and only if "moduleName"
00154                 # really corresponds to the module name (as specified in the
00155                 # SalomeApp.xml)
00156                 self.setIcon(sComponent, icon)
00157 
00158             # This part will stay inactive until Salome 6. In Salome 6, the
00159             # engine name will be stored separately from the module name.
00160             # An internal convention (in this class) is to store the name of the
00161             # associated engine in the parameter attribute of the scomponent (so that
00162             # it could be retrieved in a future usage of this scomponent, for example,
00163             # for the need of the function loadComponentEngine). The comment attribute
00164             # SHOULD NOT be used for this purpose  because it's used by the SALOME
00165             # resources manager to identify the SALOME module and then localized
00166             # the resource files
00167             #attr = self.builder.FindOrCreateAttribute( sComponent, "AttributeParameter" )
00168             #attr.SetString( "ENGINE_NAME", engineName )
00169 
00170             engine = salome.lcc.FindOrLoadComponent(containerName, moduleName)
00171             if engine is None:
00172                 raise Exception("Cannot load engine %s in container %s. See "
00173                                 "logs of container %s for more details." %
00174                                 (moduleName, containerName, containerName))
00175             self.builder.DefineComponentInstance(sComponent, engine)
00176 
00177         return sComponent

Here is the call graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.findOrCreateItem (   self,
  fatherItem,
  name,
  fileType = None,
  fileName = None,
  comment = None,
  icon = None,
  IOR = None,
  typeId = None 
)
Find an object under `fatherItem` in the study with the given
attributes. Return the first one found if at least one exists,
otherwise create a new one with the given attributes and return it.

See :meth:`setItem` for the description of the parameters.

Definition at line 212 of file studyedit.py.

00212 
00213                          IOR = None, typeId = None):
00214         """
00215         Find an object under `fatherItem` in the study with the given
00216         attributes. Return the first one found if at least one exists,
00217         otherwise create a new one with the given attributes and return it.
00218         
00219         See :meth:`setItem` for the description of the parameters.
00220         """
00221         sObject = self.findItem(fatherItem, name, fileType, fileName, comment,
00222                                 icon, IOR, typeId)
00223         if sObject is None:
00224             sObject = self.createItem(fatherItem, name, fileType, fileName,
00225                                       comment, icon, IOR, typeId)
00226         return sObject

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.getAttributeValue (   self,
  sObject,
  attributeName,
  default = None 
)
Return the value of the attribute named `attributeName` on the object
`sObject`, or `default` if the attribute doesn't exist.

Definition at line 419 of file studyedit.py.

00419 
00420     def getAttributeValue(self, sObject, attributeName, default = None):
00421         """
00422         Return the value of the attribute named `attributeName` on the object
00423         `sObject`, or `default` if the attribute doesn't exist.
00424         """
00425         value = default
00426         found, attr = self.builder.FindAttribute(sObject, attributeName)
00427         if found:
00428             value = attr.Value()
00429         return value

Here is the caller graph for this function:

Return the value of the attribute "AttributeExternalFileDef" of the
object `sObject`, or an empty string if it is not set.

Definition at line 467 of file studyedit.py.

00467 
00468     def getFileName(self, sObject):
00469         """
00470         Return the value of the attribute "AttributeExternalFileDef" of the
00471         object `sObject`, or an empty string if it is not set.
00472         """
00473         return self.getAttributeValue(sObject, "AttributeExternalFileDef", "")

Here is the call graph for this function:

Here is the caller graph for this function:

Return the value of the attribute "AttributeFileType" of the object
`sObject`, or an empty string if it is not set.

Definition at line 452 of file studyedit.py.

00452 
00453     def getFileType(self, sObject):
00454         """
00455         Return the value of the attribute "AttributeFileType" of the object
00456         `sObject`, or an empty string if it is not set.
00457         """
00458         return self.getAttributeValue(sObject, "AttributeFileType", "")

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.getIcon (   self,
  sObject 
)
Return the value of the attribute "AttributePixMap" of the object
`sObject`, or an empty string if it is not set.

Definition at line 483 of file studyedit.py.

00483 
00484     def getIcon(self, sObject):
00485         """
00486         Return the value of the attribute "AttributePixMap" of the object
00487         `sObject`, or an empty string if it is not set.
00488         """
00489         value = ""
00490         found, attr = self.builder.FindAttribute(sObject, "AttributePixMap")
00491         if found and attr.HasPixMap():
00492             value = attr.GetPixMap()
00493         return value

Here is the caller graph for this function:

Get the CORBA object associated with the SObject `item`, eventually by
first loading it with the corresponding engine.

Definition at line 198 of file studyedit.py.

00198 
00199     def getOrLoadObject(self, item):
00200         """
00201         Get the CORBA object associated with the SObject `item`, eventually by
00202         first loading it with the corresponding engine.
00203         """
00204         object = item.GetObject()
00205         if object is None: # the engine has not been loaded yet
00206             sComponent = item.GetFatherComponent()
00207             self.loadComponentEngine(sComponent)
00208             object = item.GetObject()
00209         return object

Here is the call graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.getTypeId (   self,
  sObject 
)
Return the value of the attribute "AttributeLocalID" of the object
`sObject`, or :const:`None` if it is not set.

Definition at line 438 of file studyedit.py.

00438 
00439     def getTypeId(self, sObject):
00440         """
00441         Return the value of the attribute "AttributeLocalID" of the object
00442         `sObject`, or :const:`None` if it is not set.
00443         """
00444         return self.getAttributeValue(sObject, "AttributeLocalID")

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.loadComponentEngine (   self,
  sComponent,
  containerName = _DEFAULT_CONTAINER 
)
Load the engine corresponding to `sComponent` in the container
`containerName`, associate the engine with the component and load the
CORBA objects of this component in the study.

Definition at line 179 of file studyedit.py.

00179 
00180                             containerName = _DEFAULT_CONTAINER):
00181         """
00182         Load the engine corresponding to `sComponent` in the container
00183         `containerName`, associate the engine with the component and load the
00184         CORBA objects of this component in the study.
00185         """
00186         # This part will stay inactive until Salome 6. In Salome 6, the
00187         # engine name will be stored separately from the module name.
00188         #attr = self.builder.FindOrCreateAttribute( sComponent, "AttributeParameter" )
00189         #engineName = attr.GetString( "ENGINE_NAME" )
00190         engine = salome.lcc.FindOrLoadComponent(containerName,
00191                                                 sComponent.GetComment())
00192         if engine is None:
00193             raise Exception("Cannot load component %s in container %s. See "
00194                             "logs of container %s for more details." %
00195                             (sComponent.GetComment(), containerName,
00196                              containerName))
00197         self.builder.LoadWith(sComponent, engine)

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.removeItem (   self,
  item,
  withChildren = False 
)
Remove the given item from the study. Note that the items are never
really deleted. They just don't appear in the study anymore.

:type  item: SObject
:param item: the item to be removed

:type  withChildren: boolean
:param withChildren: if :const:`True`, also remove the children of
             `item`

:return: :const:`True` if the item was removed successfully, or
 :const:`False` if an error happened.

Definition at line 367 of file studyedit.py.

00367 
00368     def removeItem(self, item, withChildren = False ):
00369         """
00370         Remove the given item from the study. Note that the items are never
00371         really deleted. They just don't appear in the study anymore.
00372 
00373         :type  item: SObject
00374         :param item: the item to be removed
00375 
00376         :type  withChildren: boolean
00377         :param withChildren: if :const:`True`, also remove the children of
00378                              `item`
00379 
00380         :return: :const:`True` if the item was removed successfully, or
00381                  :const:`False` if an error happened.
00382         """
00383         ok = False
00384         try:
00385             if withChildren:
00386                 self.builder.RemoveObjectWithChildren(item)
00387             else:
00388                 self.builder.RemoveObject(item)
00389             ok = True
00390         except:
00391             ok = False
00392         return ok

Here is the call graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setAttributeValue (   self,
  sObject,
  attributeName,
  attributeValue 
)
Set the value of the attribute named `attributeName` on the object
`sObject` to the value `attributeValue`.

Definition at line 430 of file studyedit.py.

00430 
00431     def setAttributeValue(self, sObject, attributeName, attributeValue):
00432         """
00433         Set the value of the attribute named `attributeName` on the object
00434         `sObject` to the value `attributeValue`.
00435         """        
00436         attr = self.builder.FindOrCreateAttribute(sObject, attributeName)
00437         attr.SetValue(attributeValue)

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setFileName (   self,
  sObject,
  value 
)
Set the attribute "AttributeExternalFileDef" of the object `sObject`
to the value `value`.

Definition at line 474 of file studyedit.py.

00474 
00475     def setFileName(self, sObject, value):
00476         """
00477         Set the attribute "AttributeExternalFileDef" of the object `sObject`
00478         to the value `value`.
00479         """
00480         # Explicit cast is necessary for unicode to string conversion
00481         self.setAttributeValue(sObject, "AttributeExternalFileDef",
00482                                str(value))

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setFileType (   self,
  sObject,
  value 
)
Set the attribute "AttributeFileType" of the object `sObject` to the
value `value`.

Definition at line 459 of file studyedit.py.

00459 
00460     def setFileType(self, sObject, value):
00461         """
00462         Set the attribute "AttributeFileType" of the object `sObject` to the
00463         value `value`.
00464         """
00465         # Explicit cast is necessary for unicode to string conversion
00466         self.setAttributeValue(sObject, "AttributeFileType", str(value))

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setIcon (   self,
  sObject,
  value 
)
Set the attribute "AttributePixMap" of the object `sObject` to the
value `value`.

Definition at line 494 of file studyedit.py.

00494 
00495     def setIcon(self, sObject, value):
00496         """
00497         Set the attribute "AttributePixMap" of the object `sObject` to the
00498         value `value`.
00499         """
00500         attr = self.builder.FindOrCreateAttribute(sObject, "AttributePixMap")
00501         # Explicit cast is necessary for unicode to string conversion
00502         attr.SetPixMap(str(value))

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setItem (   self,
  item,
  name = None,
  fileType = None,
  fileName = None,
  comment = None,
  icon = None,
  IOR = None,
  typeId = None 
)
Modify the attributes of an item in the study. Unspecified attributes
(i.e. those set to :const:`None`) are left unchanged.

:type  item: SObject
:param item: item to modify.

:type  name: string
:param name: item name (attribute 'AttributeName').

:type  fileType: string
:param fileType: item file type (attribute 'AttributeFileType').

:type  fileName: string
:param fileName: item file name (attribute
         'AttributeExternalFileDef').

:type  comment: string
:param comment: item comment (attribute 'AttributeComment'). Note that
        this attribute will appear in the 'Value' column in
        the object browser.

:type  icon: string
:param icon: item icon name (attribute 'AttributePixMap').

:type  IOR: string
:param IOR: IOR of a CORBA object associated with the item
    (attribute 'AttributeIOR').

:type  typeId: integer
:param typeId: item type (attribute 'AttributeLocalID').

Definition at line 314 of file studyedit.py.

00314 
00315                 comment = None, icon = None, IOR = None, typeId = None):
00316         """
00317         Modify the attributes of an item in the study. Unspecified attributes
00318         (i.e. those set to :const:`None`) are left unchanged.
00319 
00320         :type  item: SObject
00321         :param item: item to modify.
00322 
00323         :type  name: string
00324         :param name: item name (attribute 'AttributeName').
00325 
00326         :type  fileType: string
00327         :param fileType: item file type (attribute 'AttributeFileType').
00328 
00329         :type  fileName: string
00330         :param fileName: item file name (attribute
00331                          'AttributeExternalFileDef').
00332 
00333         :type  comment: string
00334         :param comment: item comment (attribute 'AttributeComment'). Note that
00335                         this attribute will appear in the 'Value' column in
00336                         the object browser.
00337 
00338         :type  icon: string
00339         :param icon: item icon name (attribute 'AttributePixMap').
00340 
00341         :type  IOR: string
00342         :param IOR: IOR of a CORBA object associated with the item
00343                     (attribute 'AttributeIOR').
00344 
00345         :type  typeId: integer
00346         :param typeId: item type (attribute 'AttributeLocalID').
00347         """
00348         logger.debug("setItem (ID=%s): name=%s, fileType=%s, fileName=%s, "
00349                      "comment=%s, icon=%s, IOR=%s" %
00350                      (item.GetID(), name, fileType, fileName, comment,
00351                       icon, IOR))
00352         # Explicit cast is necessary for unicode to string conversion
00353         if name is not None:
00354             self.builder.SetName(item, str(name))
00355         if fileType is not None:
00356             self.setFileType(item, fileType)
00357         if fileName is not None:
00358             self.setFileName(item, fileName)
00359         if comment is not None:
00360             self.builder.SetComment(item, str(comment))
00361         if icon is not None:
00362             self.setIcon(item, icon)
00363         if IOR is not None:
00364             self.builder.SetIOR(item, str(IOR))
00365         if typeId is not None:
00366             self.setTypeId(item, typeId)

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setItemAtTag (   self,
  fatherItem,
  tag,
  name = None,
  fileType = None,
  fileName = None,
  comment = None,
  icon = None,
  IOR = None,
  typeId = None 
)
Find an item tagged `tag` under `fatherItem` in the study tree or
create it if there is none, then set its attributes.

:type  fatherItem: SObject
:param fatherItem: item under which the tagged item will be looked for
           and eventually created.

:type  tag: integer
:param tag: tag of the item to look for.

:return: the SObject at `tag` if found or created successfully, or
 :const:`None` if an error happened.

See :meth:`setItem` for the description of the other parameters.

Definition at line 395 of file studyedit.py.

00395 
00396                      typeId = None):
00397         """
00398         Find an item tagged `tag` under `fatherItem` in the study tree or
00399         create it if there is none, then set its attributes.
00400         
00401         :type  fatherItem: SObject
00402         :param fatherItem: item under which the tagged item will be looked for
00403                            and eventually created.
00404 
00405         :type  tag: integer
00406         :param tag: tag of the item to look for.
00407 
00408         :return: the SObject at `tag` if found or created successfully, or
00409                  :const:`None` if an error happened.
00410         
00411         See :meth:`setItem` for the description of the other parameters.
00412         """
00413         found, sObj = fatherItem.FindSubObject(tag)
00414         if not found:
00415             sObj = self.builder.NewObjectToTag(fatherItem, tag)
00416         self.setItem(sObj, name, fileType, fileName, comment, icon,
00417                      IOR, typeId)
00418         return sObj

Here is the call graph for this function:

Here is the caller graph for this function:

def KERNEL_PY.kernel.studyedit.StudyEditor.setTypeId (   self,
  sObject,
  value 
)
Set the attribute "AttributeLocalID" of the object `sObject` to the
value `value`.

Definition at line 445 of file studyedit.py.

00445 
00446     def setTypeId(self, sObject, value):
00447         """
00448         Set the attribute "AttributeLocalID" of the object `sObject` to the
00449         value `value`.
00450         """
00451         self.setAttributeValue(sObject, "AttributeLocalID", value)

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 111 of file studyedit.py.

Definition at line 107 of file studyedit.py.

Definition at line 106 of file studyedit.py.


The documentation for this class was generated from the following file: