"""
__ballCSULR_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: kyle
Modified: Wed Apr 30 00:40:52 2008
_______________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Composite import *
from Basic import *
from Orthogonal import *
from contains import *
from Hyperedge import *
from orthogonality import *
from graph_Basic import *
from graph_Orthogonal import *
from graph_Hyperedge import *
from graph_orthogonality import *
from graph_contains import *
from graph_Composite import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def ballCSULR_MDL(self, rootNode, DChartsRootNode=None):

    # --- Generating attributes code for ASG DCharts ---
    if( DChartsRootNode ): 
        # variables
        DChartsRootNode.variables.setValue('\n')
        DChartsRootNode.variables.setHeight(15)

        # misc
        DChartsRootNode.misc.setValue('\n')
        DChartsRootNode.misc.setHeight(15)

        # event_clauses
        DChartsRootNode.event_clauses.setValue('\n')
        DChartsRootNode.event_clauses.setHeight(15)
    # --- ASG attributes over ---


    self.obj3140=Composite(self)
    self.obj3140.isGraphObjectVisual = True

    if(hasattr(self.obj3140, '_setHierarchicalLink')):
      self.obj3140._setHierarchicalLink(False)

    # auto_adjust
    self.obj3140.auto_adjust.setValue((None, 1))
    self.obj3140.auto_adjust.config = 0

    # name
    self.obj3140.name.setValue('compo_0')

    # is_default
    self.obj3140.is_default.setValue((None, 0))
    self.obj3140.is_default.config = 0

    # visible
    self.obj3140.visible.setValue((None, 1))
    self.obj3140.visible.config = 0

    # exit_action
    self.obj3140.exit_action.setValue('\n')
    self.obj3140.exit_action.setHeight(15)

    # enter_action
    self.obj3140.enter_action.setValue('\n')
    self.obj3140.enter_action.setHeight(15)

    self.obj3140.graphClass_= graph_Composite
    if self.genGraphics:
       new_obj = graph_Composite(280.0,160.0,self.obj3140)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Composite", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf2.handler,205.0,178.0,811.0,463.0)
       self.UMLmodel.itemconfig(new_obj.gf2.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, outline='DARKBLUE')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,205.0,171.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='compo_0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3140.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3140)
    self.globalAndLocalPostcondition(self.obj3140, rootNode)
    self.obj3140.postAction( rootNode.CREATE )

    self.obj3141=Basic(self)
    self.obj3141.isGraphObjectVisual = True

    if(hasattr(self.obj3141, '_setHierarchicalLink')):
      self.obj3141._setHierarchicalLink(False)

    # is_default
    self.obj3141.is_default.setValue((None, 1))
    self.obj3141.is_default.config = 0

    # name
    self.obj3141.name.setValue('init')

    # exit_action
    self.obj3141.exit_action.setValue('\n')
    self.obj3141.exit_action.setHeight(15)

    # enter_action
    self.obj3141.enter_action.setValue('counter = 0\nballs = {}\n')
    self.obj3141.enter_action.setHeight(15)

    self.obj3141.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(480.0,80.0,self.obj3141)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,492.0,83.0,510.0,101.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,503.125,110.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='init')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font87440840')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3141.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3141)
    self.globalAndLocalPostcondition(self.obj3141, rootNode)
    self.obj3141.postAction( rootNode.CREATE )

    self.obj3142=Basic(self)
    self.obj3142.isGraphObjectVisual = True

    if(hasattr(self.obj3142, '_setHierarchicalLink')):
      self.obj3142._setHierarchicalLink(False)

    # is_default
    self.obj3142.is_default.setValue((None, 1))
    self.obj3142.is_default.config = 0

    # name
    self.obj3142.name.setValue('moving')

    # exit_action
    self.obj3142.exit_action.setValue('\n')
    self.obj3142.exit_action.setHeight(15)

    # enter_action
    self.obj3142.enter_action.setValue('\n')
    self.obj3142.enter_action.setHeight(15)

    self.obj3142.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(460.0,300.0,self.obj3142)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,472.0,303.0,490.0,321.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,483.125,330.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='moving')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font90189656')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3142.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3142)
    self.globalAndLocalPostcondition(self.obj3142, rootNode)
    self.obj3142.postAction( rootNode.CREATE )

    self.obj3143=Basic(self)
    self.obj3143.isGraphObjectVisual = True

    if(hasattr(self.obj3143, '_setHierarchicalLink')):
      self.obj3143._setHierarchicalLink(False)

    # is_default
    self.obj3143.is_default.setValue((None, 1))
    self.obj3143.is_default.config = 0

    # name
    self.obj3143.name.setValue('color')

    # exit_action
    self.obj3143.exit_action.setValue('\n')
    self.obj3143.exit_action.setHeight(15)

    # enter_action
    self.obj3143.enter_action.setValue('\n')
    self.obj3143.enter_action.setHeight(15)

    self.obj3143.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(660.0,320.0,self.obj3143)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,672.0,323.0,690.0,341.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,683.125,350.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='color')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font40359496')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3143.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3143)
    self.globalAndLocalPostcondition(self.obj3143, rootNode)
    self.obj3143.postAction( rootNode.CREATE )

    self.obj3144=Basic(self)
    self.obj3144.isGraphObjectVisual = True

    if(hasattr(self.obj3144, '_setHierarchicalLink')):
      self.obj3144._setHierarchicalLink(False)

    # is_default
    self.obj3144.is_default.setValue((None, 1))
    self.obj3144.is_default.config = 0

    # name
    self.obj3144.name.setValue('shape')

    # exit_action
    self.obj3144.exit_action.setValue('\n')
    self.obj3144.exit_action.setHeight(15)

    # enter_action
    self.obj3144.enter_action.setValue('\n')
    self.obj3144.enter_action.setHeight(15)

    self.obj3144.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(300.0,380.0,self.obj3144)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,312.0,383.0,330.0,401.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,323.125,410.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='shape')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font96967736')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3144.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3144)
    self.globalAndLocalPostcondition(self.obj3144, rootNode)
    self.obj3144.postAction( rootNode.CREATE )

    self.obj3145=Basic(self)
    self.obj3145.isGraphObjectVisual = True

    if(hasattr(self.obj3145, '_setHierarchicalLink')):
      self.obj3145._setHierarchicalLink(False)

    # is_default
    self.obj3145.is_default.setValue((None, 1))
    self.obj3145.is_default.config = 0

    # name
    self.obj3145.name.setValue('blowUp')

    # exit_action
    self.obj3145.exit_action.setValue('\n')
    self.obj3145.exit_action.setHeight(15)

    # enter_action
    self.obj3145.enter_action.setValue('\n')
    self.obj3145.enter_action.setHeight(15)

    self.obj3145.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(500.0,380.0,self.obj3145)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,512.0,383.0,530.0,401.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,523.125,410.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowUp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font64954496')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3145.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3145)
    self.globalAndLocalPostcondition(self.obj3145, rootNode)
    self.obj3145.postAction( rootNode.CREATE )

    self.obj3146=Basic(self)
    self.obj3146.isGraphObjectVisual = True

    if(hasattr(self.obj3146, '_setHierarchicalLink')):
      self.obj3146._setHierarchicalLink(False)

    # is_default
    self.obj3146.is_default.setValue((None, 1))
    self.obj3146.is_default.config = 0

    # name
    self.obj3146.name.setValue('blowRight')

    # exit_action
    self.obj3146.exit_action.setValue('\n')
    self.obj3146.exit_action.setHeight(15)

    # enter_action
    self.obj3146.enter_action.setValue('\n')
    self.obj3146.enter_action.setHeight(15)

    self.obj3146.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(740.0,200.0,self.obj3146)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,752.0,203.0,770.0,221.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,763.125,230.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowRight')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font98052496')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['Text Scale'] = 1.11
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3146.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3146)
    self.globalAndLocalPostcondition(self.obj3146, rootNode)
    self.obj3146.postAction( rootNode.CREATE )

    self.obj3147=Basic(self)
    self.obj3147.isGraphObjectVisual = True

    if(hasattr(self.obj3147, '_setHierarchicalLink')):
      self.obj3147._setHierarchicalLink(False)

    # is_default
    self.obj3147.is_default.setValue((None, 1))
    self.obj3147.is_default.config = 0

    # name
    self.obj3147.name.setValue('blowLeft')

    # exit_action
    self.obj3147.exit_action.setValue('\n')
    self.obj3147.exit_action.setHeight(15)

    # enter_action
    self.obj3147.enter_action.setValue('\n')
    self.obj3147.enter_action.setHeight(15)

    self.obj3147.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(273.0,261.0,self.obj3147)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,285.0,264.0,303.0,282.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,296.125,291.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowLeft')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font98711872')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3147.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3147)
    self.globalAndLocalPostcondition(self.obj3147, rootNode)
    self.obj3147.postAction( rootNode.CREATE )

    self.obj3148=Orthogonal(self)
    self.obj3148.isGraphObjectVisual = True

    if(hasattr(self.obj3148, '_setHierarchicalLink')):
      self.obj3148._setHierarchicalLink(False)

    # visible
    self.obj3148.visible.setValue((None, 1))
    self.obj3148.visible.config = 0

    # name
    self.obj3148.name.setValue('move_comp')

    # auto_adjust
    self.obj3148.auto_adjust.setValue((None, 1))
    self.obj3148.auto_adjust.config = 0

    self.obj3148.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(380.0,200.0,self.obj3148)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,453.0,262.0,605.0,343.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='darkgray')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,453.0,255.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='move_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3148.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3148)
    self.globalAndLocalPostcondition(self.obj3148, rootNode)
    self.obj3148.postAction( rootNode.CREATE )

    self.obj3149=Orthogonal(self)
    self.obj3149.isGraphObjectVisual = True

    if(hasattr(self.obj3149, '_setHierarchicalLink')):
      self.obj3149._setHierarchicalLink(False)

    # visible
    self.obj3149.visible.setValue((None, 1))
    self.obj3149.visible.config = 0

    # name
    self.obj3149.name.setValue('color_comp')

    # auto_adjust
    self.obj3149.auto_adjust.setValue((None, 1))
    self.obj3149.auto_adjust.config = 0

    self.obj3149.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(580.0,300.0,self.obj3149)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,660.0,317.0,799.0,396.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,660.0,310.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='color_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3149.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3149)
    self.globalAndLocalPostcondition(self.obj3149, rootNode)
    self.obj3149.postAction( rootNode.CREATE )

    self.obj3150=Orthogonal(self)
    self.obj3150.isGraphObjectVisual = True

    if(hasattr(self.obj3150, '_setHierarchicalLink')):
      self.obj3150._setHierarchicalLink(False)

    # visible
    self.obj3150.visible.setValue((None, 1))
    self.obj3150.visible.config = 0

    # name
    self.obj3150.name.setValue('shape_comp')

    # auto_adjust
    self.obj3150.auto_adjust.setValue((None, 1))
    self.obj3150.auto_adjust.config = 0

    self.obj3150.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(360.0,340.0,self.obj3150)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,247.0,360.0,351.0,440.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,247.0,353.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='shape_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3150.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3150)
    self.globalAndLocalPostcondition(self.obj3150, rootNode)
    self.obj3150.postAction( rootNode.CREATE )

    self.obj3151=Orthogonal(self)
    self.obj3151.isGraphObjectVisual = True

    if(hasattr(self.obj3151, '_setHierarchicalLink')):
      self.obj3151._setHierarchicalLink(False)

    # visible
    self.obj3151.visible.setValue((None, 1))
    self.obj3151.visible.config = 0

    # name
    self.obj3151.name.setValue('up_comp')

    # auto_adjust
    self.obj3151.auto_adjust.setValue((None, 1))
    self.obj3151.auto_adjust.config = 0

    self.obj3151.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(580.0,340.0,self.obj3151)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,456.0,377.0,555.0,456.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,456.0,370.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='up_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3151.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3151)
    self.globalAndLocalPostcondition(self.obj3151, rootNode)
    self.obj3151.postAction( rootNode.CREATE )

    self.obj3152=Orthogonal(self)
    self.obj3152.isGraphObjectVisual = True

    if(hasattr(self.obj3152, '_setHierarchicalLink')):
      self.obj3152._setHierarchicalLink(False)

    # visible
    self.obj3152.visible.setValue((None, 1))
    self.obj3152.visible.config = 0

    # name
    self.obj3152.name.setValue('right_comp')

    # auto_adjust
    self.obj3152.auto_adjust.setValue((None, 1))
    self.obj3152.auto_adjust.config = 0

    self.obj3152.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(600.0,220.0,self.obj3152)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,686.0,197.0,804.0,282.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,686.0,190.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='right_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3152.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3152)
    self.globalAndLocalPostcondition(self.obj3152, rootNode)
    self.obj3152.postAction( rootNode.CREATE )

    self.obj3153=Orthogonal(self)
    self.obj3153.isGraphObjectVisual = True

    if(hasattr(self.obj3153, '_setHierarchicalLink')):
      self.obj3153._setHierarchicalLink(False)

    # visible
    self.obj3153.visible.setValue((None, 1))
    self.obj3153.visible.config = 0

    # name
    self.obj3153.name.setValue('left_comp')

    # auto_adjust
    self.obj3153.auto_adjust.setValue((None, 1))
    self.obj3153.auto_adjust.config = 0

    self.obj3153.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(380.0,160.0,self.obj3153)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,261.0,205.0,331.0,305.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,261.0,198.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='left_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3153.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3153)
    self.globalAndLocalPostcondition(self.obj3153, rootNode)
    self.obj3153.postAction( rootNode.CREATE )

    self.obj3154=contains(self)
    self.obj3154.isGraphObjectVisual = True

    if(hasattr(self.obj3154, '_setHierarchicalLink')):
      self.obj3154._setHierarchicalLink(False)

    self.obj3154.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(484.931194496,270.723429936,self.obj3154)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3154.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3154)
    self.globalAndLocalPostcondition(self.obj3154, rootNode)
    self.obj3154.postAction( rootNode.CREATE )

    self.obj3155=contains(self)
    self.obj3155.isGraphObjectVisual = True

    if(hasattr(self.obj3155, '_setHierarchicalLink')):
      self.obj3155._setHierarchicalLink(False)

    self.obj3155.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(633.305006531,368.684491166,self.obj3155)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3155.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3155)
    self.globalAndLocalPostcondition(self.obj3155, rootNode)
    self.obj3155.postAction( rootNode.CREATE )

    self.obj3156=contains(self)
    self.obj3156.isGraphObjectVisual = True

    if(hasattr(self.obj3156, '_setHierarchicalLink')):
      self.obj3156._setHierarchicalLink(False)

    self.obj3156.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(445.788238619,435.244557513,self.obj3156)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3156.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3156)
    self.globalAndLocalPostcondition(self.obj3156, rootNode)
    self.obj3156.postAction( rootNode.CREATE )

    self.obj3157=contains(self)
    self.obj3157.isGraphObjectVisual = True

    if(hasattr(self.obj3157, '_setHierarchicalLink')):
      self.obj3157._setHierarchicalLink(False)

    self.obj3157.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(657.758818692,335.142676605,self.obj3157)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3157.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3157)
    self.globalAndLocalPostcondition(self.obj3157, rootNode)
    self.obj3157.postAction( rootNode.CREATE )

    self.obj3158=contains(self)
    self.obj3158.isGraphObjectVisual = True

    if(hasattr(self.obj3158, '_setHierarchicalLink')):
      self.obj3158._setHierarchicalLink(False)

    self.obj3158.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(732.036566907,326.621496023,self.obj3158)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3158.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3158)
    self.globalAndLocalPostcondition(self.obj3158, rootNode)
    self.obj3158.postAction( rootNode.CREATE )

    self.obj3159=contains(self)
    self.obj3159.isGraphObjectVisual = True

    if(hasattr(self.obj3159, '_setHierarchicalLink')):
      self.obj3159._setHierarchicalLink(False)

    self.obj3159.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(469.67015785,213.530814645,self.obj3159)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3159.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3159)
    self.globalAndLocalPostcondition(self.obj3159, rootNode)
    self.obj3159.postAction( rootNode.CREATE )

    self.obj3160=Hyperedge(self)
    self.obj3160.isGraphObjectVisual = True

    if(hasattr(self.obj3160, '_setHierarchicalLink')):
      self.obj3160._setHierarchicalLink(False)

    # name
    self.obj3160.name.setValue('')
    self.obj3160.name.setNone()

    # broadcast
    self.obj3160.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3160.broadcast.setHeight(15)

    # guard
    self.obj3160.guard.setValue('1')

    # trigger
    self.obj3160.trigger.setValue('start')

    # action
    self.obj3160.action.setValue('ctl = [PARAMS]\nbid = counter\ncounter += 1\ngid, pos, speed = ctl.init(bid)\nballs[bid] = {\'pos\': pos, \'speed\': speed, \'gid\':gid}\nwidth = ctl.getWidth()\nheight = ctl.getHeight()\n')
    self.obj3160.action.setHeight(15)

    # broadcast_to
    self.obj3160.broadcast_to.setValue('')
    self.obj3160.broadcast_to.setNone()

    # display
    self.obj3160.display.setValue('start')

    self.obj3160.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(514.374993426,138.55508343,self.obj3160)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [0.93999999999999961, 1.0399999999999998]
    else: new_obj = None
    self.obj3160.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3160)
    self.globalAndLocalPostcondition(self.obj3160, rootNode)
    self.obj3160.postAction( rootNode.CREATE )

    self.obj3161=Hyperedge(self)
    self.obj3161.isGraphObjectVisual = True

    if(hasattr(self.obj3161, '_setHierarchicalLink')):
      self.obj3161._setHierarchicalLink(False)

    # name
    self.obj3161.name.setValue('')
    self.obj3161.name.setNone()

    # broadcast
    self.obj3161.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3161.broadcast.setHeight(15)

    # guard
    self.obj3161.guard.setValue('1')

    # trigger
    self.obj3161.trigger.setValue('AFTER(0.01)')

    # action
    self.obj3161.action.setValue('for b in balls: ctl.bounce(b, 0.01)\n')
    self.obj3161.action.setHeight(15)

    # broadcast_to
    self.obj3161.broadcast_to.setValue('')
    self.obj3161.broadcast_to.setNone()

    # display
    self.obj3161.display.setValue('AFTER(0.01)')

    self.obj3161.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(535.8,296.0,self.obj3161)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3161.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3161)
    self.globalAndLocalPostcondition(self.obj3161, rootNode)
    self.obj3161.postAction( rootNode.CREATE )

    self.obj3162=Hyperedge(self)
    self.obj3162.isGraphObjectVisual = True

    if(hasattr(self.obj3162, '_setHierarchicalLink')):
      self.obj3162._setHierarchicalLink(False)

    # name
    self.obj3162.name.setValue('')
    self.obj3162.name.setNone()

    # broadcast
    self.obj3162.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3162.broadcast.setHeight(15)

    # guard
    self.obj3162.guard.setValue('1')

    # trigger
    self.obj3162.trigger.setValue('AFTER(0.03)')

    # action
    self.obj3162.action.setValue('for b in balls: ctl.changeColor(b)\n')
    self.obj3162.action.setHeight(15)

    # broadcast_to
    self.obj3162.broadcast_to.setValue('')
    self.obj3162.broadcast_to.setNone()

    # display
    self.obj3162.display.setValue('AFTER(0.03)')

    self.obj3162.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(730.2,364.0,self.obj3162)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3162.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3162)
    self.globalAndLocalPostcondition(self.obj3162, rootNode)
    self.obj3162.postAction( rootNode.CREATE )

    self.obj3163=Hyperedge(self)
    self.obj3163.isGraphObjectVisual = True

    if(hasattr(self.obj3163, '_setHierarchicalLink')):
      self.obj3163._setHierarchicalLink(False)

    # name
    self.obj3163.name.setValue('')
    self.obj3163.name.setNone()

    # broadcast
    self.obj3163.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3163.broadcast.setHeight(15)

    # guard
    self.obj3163.guard.setValue('1')

    # trigger
    self.obj3163.trigger.setValue('AFTER(0.01)')

    # action
    self.obj3163.action.setValue('for b in balls: ctl.changeShape(b)\n')
    self.obj3163.action.setHeight(15)

    # broadcast_to
    self.obj3163.broadcast_to.setValue('')
    self.obj3163.broadcast_to.setNone()

    # display
    self.obj3163.display.setValue('AFTER(0.01)')

    self.obj3163.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(260.0,400.0,self.obj3163)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3163.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3163)
    self.globalAndLocalPostcondition(self.obj3163, rootNode)
    self.obj3163.postAction( rootNode.CREATE )

    self.obj3164=Hyperedge(self)
    self.obj3164.isGraphObjectVisual = True

    if(hasattr(self.obj3164, '_setHierarchicalLink')):
      self.obj3164._setHierarchicalLink(False)

    # name
    self.obj3164.name.setValue('')
    self.obj3164.name.setNone()

    # broadcast
    self.obj3164.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3164.broadcast.setHeight(15)

    # guard
    self.obj3164.guard.setValue('1')

    # trigger
    self.obj3164.trigger.setValue('AFTER(10)')

    # action
    self.obj3164.action.setValue('for b in balls: ctl.blowUp(b)\n')
    self.obj3164.action.setHeight(15)

    # broadcast_to
    self.obj3164.broadcast_to.setValue('')
    self.obj3164.broadcast_to.setNone()

    # display
    self.obj3164.display.setValue('AFTER(10)')

    self.obj3164.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(475.8,424.0,self.obj3164)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3164.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3164)
    self.globalAndLocalPostcondition(self.obj3164, rootNode)
    self.obj3164.postAction( rootNode.CREATE )

    self.obj3165=Hyperedge(self)
    self.obj3165.isGraphObjectVisual = True

    if(hasattr(self.obj3165, '_setHierarchicalLink')):
      self.obj3165._setHierarchicalLink(False)

    # name
    self.obj3165.name.setValue('')
    self.obj3165.name.setNone()

    # broadcast
    self.obj3165.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3165.broadcast.setHeight(15)

    # guard
    self.obj3165.guard.setValue('1')

    # trigger
    self.obj3165.trigger.setValue('AFTER(15)')

    # action
    self.obj3165.action.setValue('for b in balls: ctl.blowRight(b)\n')
    self.obj3165.action.setHeight(15)

    # broadcast_to
    self.obj3165.broadcast_to.setValue('')
    self.obj3165.broadcast_to.setNone()

    # display
    self.obj3165.display.setValue('AFTER(15)')

    self.obj3165.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(706.2,245.8,self.obj3165)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3165.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3165)
    self.globalAndLocalPostcondition(self.obj3165, rootNode)
    self.obj3165.postAction( rootNode.CREATE )

    self.obj3166=Hyperedge(self)
    self.obj3166.isGraphObjectVisual = True

    if(hasattr(self.obj3166, '_setHierarchicalLink')):
      self.obj3166._setHierarchicalLink(False)

    # name
    self.obj3166.name.setValue('')
    self.obj3166.name.setNone()

    # broadcast
    self.obj3166.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3166.broadcast.setHeight(15)

    # guard
    self.obj3166.guard.setValue('1')

    # trigger
    self.obj3166.trigger.setValue('AFTER(23)')

    # action
    self.obj3166.action.setValue('for b in balls: ctl.blowLeft(b)\n')
    self.obj3166.action.setHeight(15)

    # broadcast_to
    self.obj3166.broadcast_to.setValue('')
    self.obj3166.broadcast_to.setNone()

    # display
    self.obj3166.display.setValue('')
    self.obj3166.display.setNone()

    self.obj3166.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(293.0,213.0,self.obj3166)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3166.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3166)
    self.globalAndLocalPostcondition(self.obj3166, rootNode)
    self.obj3166.postAction( rootNode.CREATE )

    self.obj3167=orthogonality(self)
    self.obj3167.isGraphObjectVisual = True

    if(hasattr(self.obj3167, '_setHierarchicalLink')):
      self.obj3167._setHierarchicalLink(False)

    self.obj3167.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(433.0,252.5,self.obj3167)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3167.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3167)
    self.globalAndLocalPostcondition(self.obj3167, rootNode)
    self.obj3167.postAction( rootNode.CREATE )

    self.obj3168=orthogonality(self)
    self.obj3168.isGraphObjectVisual = True

    if(hasattr(self.obj3168, '_setHierarchicalLink')):
      self.obj3168._setHierarchicalLink(False)

    self.obj3168.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(536.5,280.0,self.obj3168)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3168.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3168)
    self.globalAndLocalPostcondition(self.obj3168, rootNode)
    self.obj3168.postAction( rootNode.CREATE )

    self.obj3169=orthogonality(self)
    self.obj3169.isGraphObjectVisual = True

    if(hasattr(self.obj3169, '_setHierarchicalLink')):
      self.obj3169._setHierarchicalLink(False)

    self.obj3169.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(226.0,301.5,self.obj3169)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3169.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3169)
    self.globalAndLocalPostcondition(self.obj3169, rootNode)
    self.obj3169.postAction( rootNode.CREATE )

    self.obj3170=orthogonality(self)
    self.obj3170.isGraphObjectVisual = True

    if(hasattr(self.obj3170, '_setHierarchicalLink')):
      self.obj3170._setHierarchicalLink(False)

    self.obj3170.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(330.5,310.0,self.obj3170)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3170.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3170)
    self.globalAndLocalPostcondition(self.obj3170, rootNode)
    self.obj3170.postAction( rootNode.CREATE )

    self.obj3171=orthogonality(self)
    self.obj3171.isGraphObjectVisual = True

    if(hasattr(self.obj3171, '_setHierarchicalLink')):
      self.obj3171._setHierarchicalLink(False)

    self.obj3171.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(445.5,187.5,self.obj3171)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3171.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3171)
    self.globalAndLocalPostcondition(self.obj3171, rootNode)
    self.obj3171.postAction( rootNode.CREATE )

    self.obj3172=orthogonality(self)
    self.obj3172.isGraphObjectVisual = True

    if(hasattr(self.obj3172, '_setHierarchicalLink')):
      self.obj3172._setHierarchicalLink(False)

    self.obj3172.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(233.0,191.5,self.obj3172)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3172.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3172)
    self.globalAndLocalPostcondition(self.obj3172, rootNode)
    self.obj3172.postAction( rootNode.CREATE )

    # Connections for obj3140 (graphObject_: Obj1376) named compo_0
    self.drawConnections(
(self.obj3140,self.obj3167,[508.0, 178.0, 432.99999999999994, 252.49999999999997],"bezier", 2),
(self.obj3140,self.obj3168,[508.0, 178.0, 536.49999999999989, 280.0],"bezier", 2),
(self.obj3140,self.obj3169,[204.99999999999997, 314.0, 225.99999999996311, 301.4999999999593],"bezier", 2),
(self.obj3140,self.obj3170,[204.99999999999997, 314.0, 330.49999999999773, 310.0000000001329],"bezier", 2),
(self.obj3140,self.obj3171,[508.0, 178.0, 445.49999999999989, 187.5],"bezier", 2),
(self.obj3140,self.obj3172,[204.99999999999997, 314.0, 233.00000000023272, 191.50000000010388],"bezier", 2) )
    # Connections for obj3141 (graphObject_: Obj1377) named init
    self.drawConnections(
(self.obj3141,self.obj3160,[505.27658095602624, 99.886944663512139, 512.58397077527081, 119.29559917015337, 514.37499342581282, 138.55508343014282],"bezier", 3) )
    # Connections for obj3142 (graphObject_: Obj1378) named moving
    self.drawConnections(
(self.obj3142,self.obj3161,[488.92020890121108, 307.49479166666663, 523.79999999999995, 269.60000000000002, 535.79999999999995, 296.00000000000011],"bezier", 3) )
    # Connections for obj3143 (graphObject_: Obj1379) named color
    self.drawConnections(
(self.obj3143,self.obj3162,[690.00191094743798, 331.96502037329128, 742.20000000000005, 340.39999999999998, 730.20000000000005, 364.0],"bezier", 3) )
    # Connections for obj3144 (graphObject_: Obj1380) named shape
    self.drawConnections(
(self.obj3144,self.obj3163,[313.34320001431365, 387.61979166666663, 260.0, 367.99999999999994, 260.0, 400.0],"bezier", 3) )
    # Connections for obj3145 (graphObject_: Obj1381) named blowUp
    self.drawConnections(
(self.obj3145,self.obj3164,[516.56603289956797, 399.88694466351211, 487.80000000000001, 447.60000000000002, 475.79999999999995, 423.99999999999994],"bezier", 3) )
    # Connections for obj3146 (graphObject_: Obj1382) named blowRight
    self.drawConnections(
(self.obj3146,self.obj3165,[756.56603289956831, 219.88694466351214, 718.60000000000002, 274.19999999999999, 706.19999999999993, 245.79999999999998],"bezier", 3) )
    # Connections for obj3147 (graphObject_: Obj1383) named blowLeft
    self.drawConnections(
(self.obj3147,self.obj3166,[289.74796458621137, 265.1680960830704, 278.00000000000011, 212.99999999999989, 292.99999999999994, 212.99999999999997],"bezier", 3) )
    # Connections for obj3148 (graphObject_: Obj1384) named move_comp
    self.drawConnections(
(self.obj3148,self.obj3154,[514.0, 238.0, 484.93119449599999, 270.723429936],"bezier", 2) )
    # Connections for obj3149 (graphObject_: Obj1385) named color_comp
    self.drawConnections(
(self.obj3149,self.obj3155,[660.0, 356.0, 633.30500653099989, 368.68449116600004],"bezier", 2) )
    # Connections for obj3150 (graphObject_: Obj1386) named shape_comp
    self.drawConnections(
(self.obj3150,self.obj3156,[350.99999999999994, 408.0, 445.78823861900003, 435.24455751300007],"bezier", 2) )
    # Connections for obj3151 (graphObject_: Obj1387) named up_comp
    self.drawConnections(
(self.obj3151,self.obj3157,[554.99999999999989, 409.99999999999994, 657.75881869200009, 335.14267660500002],"bezier", 2) )
    # Connections for obj3152 (graphObject_: Obj1388) named right_comp
    self.drawConnections(
(self.obj3152,self.obj3158,[745.00000000000011, 266.0, 732.03656690699995, 326.62149602299996],"bezier", 2) )
    # Connections for obj3153 (graphObject_: Obj1389) named left_comp
    self.drawConnections(
(self.obj3153,self.obj3159,[331.0, 255.0, 469.67015784999995, 213.53081464500002],"bezier", 2) )
    # Connections for obj3154 (graphObject_: Obj1390) of type contains
    self.drawConnections(
(self.obj3154,self.obj3142,[484.93119449599999, 270.723429936, 496.72556937513104, 283.47957067605591, 485.33351264266946, 304.04309608307028],"bezier", 3) )
    # Connections for obj3155 (graphObject_: Obj1391) of type contains
    self.drawConnections(
(self.obj3155,self.obj3143,[633.305006531, 368.68449116599999, 640.82063153051433, 365.66664810603578, 672.97933664102663, 336.43524907991582],"bezier", 3) )
    # Connections for obj3156 (graphObject_: Obj1392) of type contains
    self.drawConnections(
(self.obj3156,self.obj3144,[445.78823861900003, 435.24455751300007, 436.7810413523145, 436.33086468925484, 328.80634552792412, 396.43524907991576],"bezier", 3) )
    # Connections for obj3157 (graphObject_: Obj1393) of type contains
    self.drawConnections(
(self.obj3157,self.obj3145,[657.75881869199986, 335.14267660500002, 643.75162142514409, 336.22898378194157, 528.92020890121103, 387.49479166666657],"bezier", 3) )
    # Connections for obj3158 (graphObject_: Obj1394) of type contains
    self.drawConnections(
(self.obj3158,self.obj3146,[732.03656690699995, 326.62149602299996, 754.55219190690877, 313.60365296343952, 760.83590939783187, 220.962062960042],"bezier", 3) )
    # Connections for obj3159 (graphObject_: Obj1395) of type contains
    self.drawConnections(
(self.obj3159,self.obj3147,[469.67015785000007, 213.53081464500002, 448.91296058278255, 229.86712182155404, 301.92020890121097, 268.49479166666669],"bezier", 3) )
    # Connections for obj3160 (graphObject_: Obj1396) named 
    self.drawConnections(
(self.obj3160,self.obj3140,[514.37499342581282, 138.55508343014282, 516.16601607635494, 157.81456769013229, 508.0, 178.0],"bezier", 3) )
    # Connections for obj3161 (graphObject_: Obj1398) named 
    self.drawConnections(
(self.obj3161,self.obj3142,[535.79999999999995, 296.00000000000011, 547.79999999999995, 322.39999999999998, 490.00191094743781, 311.96502037329128],"bezier", 3) )
    # Connections for obj3162 (graphObject_: Obj1400) named 
    self.drawConnections(
(self.obj3162,self.obj3143,[730.20000000000005, 364.0, 718.20000000000005, 387.60000000000002, 685.27658095602612, 339.88694466351211],"bezier", 3) )
    # Connections for obj3163 (graphObject_: Obj1402) named 
    self.drawConnections(
(self.obj3163,self.obj3144,[260.0, 400.0, 260.0, 431.99999999999994, 312.97933664102646, 396.43524907991576],"bezier", 3) )
    # Connections for obj3164 (graphObject_: Obj1404) named 
    self.drawConnections(
(self.obj3164,self.obj3145,[475.79999999999995, 423.99999999999994, 463.80000000000001, 400.39999999999992, 512.01149796808659, 392.0781907202944],"bezier", 3) )
    # Connections for obj3165 (graphObject_: Obj1406) named 
    self.drawConnections(
(self.obj3165,self.obj3146,[706.19999999999993, 245.79999999999998, 693.79999999999995, 217.40000000000001, 752.01149796808704, 212.07819072029443],"bezier", 3) )
    # Connections for obj3166 (graphObject_: Obj1408) named 
    self.drawConnections(
(self.obj3166,self.obj3147,[292.99999999999994, 212.99999999999997, 308.00000000000006, 212.99999999999989, 294.17749951769287, 264.02456296004203],"bezier", 3) )
    # Connections for obj3167 (graphObject_: Obj1410) of type orthogonality
    self.drawConnections(
(self.obj3167,self.obj3148,[432.99999999999994, 252.49999999999997, 439.49999999999869, 261.49999999955634, 423.99999999999994, 290.0],"bezier", 3) )
    # Connections for obj3168 (graphObject_: Obj1411) of type orthogonality
    self.drawConnections(
(self.obj3168,self.obj3149,[536.49999999999989, 280.0, 544.75000000040757, 279.75000000045384, 660.0, 356.0],"bezier", 3) )
    # Connections for obj3169 (graphObject_: Obj1412) of type orthogonality
    self.drawConnections(
(self.obj3169,self.obj3150,[225.99999999999997, 301.5, 220.49999999996314, 306.49999999995941, 247.00000000000003, 408.0],"bezier", 3) )
    # Connections for obj3170 (graphObject_: Obj1413) of type orthogonality
    self.drawConnections(
(self.obj3170,self.obj3151,[330.49999999999994, 310.00000000000006, 343.99999999999784, 321.5000000001329, 455.99999999999994, 409.99999999999994],"bezier", 3) )
    # Connections for obj3171 (graphObject_: Obj1414) of type orthogonality
    self.drawConnections(
(self.obj3171,self.obj3152,[445.49999999999989, 187.5, 455.9999999996304, 164.49999999989643, 685.99999999999989, 231.00000000000003],"bezier", 3) )
    # Connections for obj3172 (graphObject_: Obj1415) of type orthogonality
    self.drawConnections(
(self.obj3172,self.obj3153,[233.0, 191.49999999999997, 220.50000000023275, 181.00000000010391, 261.0, 255.0],"bezier", 3) )

newfunction = ballCSULR_MDL

loadedMMName = 'DCharts'

atom3version = '0.3'