text:
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.structuralsearch.plugin.ui;

import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
import com.intellij.codeInsight.template.TemplateContextType;
import com.intellij.codeInsight.template.impl.TemplateEditorUtil;
import com.intellij.lang.Language;
import com.intellij.lang.injection.InjectedLanguageManager;
import com.intellij.openapi.command.WriteCommandAction;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.editor.EditorSettings;
import com.intellij.openapi.editor.colors.EditorColors;
import com.intellij.openapi.editor.colors.EditorColorsManager;
import com.intellij.openapi.editor.colors.EditorColorsScheme;
import com.intellij.openapi.editor.ex.EditorEx;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.fileTypes.FileTypes;
import com.intellij.openapi.fileTypes.LanguageFileType;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiFileFactory;
import com.intellij.structuralsearch.*;
import com.intellij.structuralsearch.plugin.StructuralSearchAction;
import com.intellij.structuralsearch.plugin.replace.ReplaceOptions;
import com.intellij.ui.EditorTextField;
import com.intellij.util.LocalTimeCounter;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.awt.*;

/**
 * @author Maxim.Mossienko
 */
public final class UIUtil {
  @NonNls private static final String SS_GROUP = "structuralsearchgroup";

  @NonNls public static final String SSR_NOTIFICATION_GROUP_ID = "Structural Search";

  @NonNls public static final String TEXT = "TEXT";
  @NonNls public static final String TEXT_HIERARCHY = "TEXT HIERARCHY";
  @NonNls public static final String REFERENCE = "REFERENCE";
  @NonNls public static final String TYPE = "TYPE";
  @NonNls public static final String TYPE_REGEX = "TYPE REGEX";
  @NonNls public static final String EXPECTED_TYPE = "EXPECTED TYPE";
  @NonNls public static final String MINIMUM_ZERO = "MINIMUM ZERO";
  @NonNls public static final String MAXIMUM_UNLIMITED = "MAXIMUM UNLIMITED";
  @NonNls public static final String CONTEXT = "CONTEXT";

  private UIUtil() {
  }

  @NotNull
  public static Editor createEditor(@NotNull Document doc, Project project, boolean editable, @Nullable TemplateContextType contextType) {
    final Editor editor =
        editable ? EditorFactory.getInstance().createEditor(doc, project) : EditorFactory.getInstance().createViewer(doc, project);

    final EditorSettings editorSettings = editor.getSettings();
    editorSettings.setVirtualSpace(false);
    editorSettings.setLineMarkerAreaShown(false);
    editorSettings.setIndentGuidesShown(false);
    editorSettings.setLineNumbersShown(false);
    editorSettings.setFoldingOutlineShown(false);
    editorSettings.setCaretRowShown(false);

    if (!editable) {
      final EditorColorsScheme globalScheme = EditorColorsManager.getInstance().getGlobalScheme();
      Color c = globalScheme.getColor(EditorColors.READONLY_BACKGROUND_COLOR);

      if (c == null) {
        c = globalScheme.getDefaultBackground();
      }

      ((EditorEx)editor).setBackgroundColor(c);
    }
    else {
      ((EditorEx)editor).setEmbeddedIntoDialogWrapper(true);
    }

    TemplateEditorUtil.setHighlighter(editor, contextType);
    return editor;
  }

  public static void setContent(@NotNull final Editor editor, String text) {
    final String value = text != null ? text : "";
    final Document document = editor.getDocument();
    WriteCommandAction.runWriteCommandAction(editor.getProject(), SSRBundle.message("modify.editor.content.command.name"), SS_GROUP,
                                             () -> document.replaceString(0, document.getTextLength(), value));
  }

  public static void setContent(@NotNull EditorTextField editor, @NotNull String text) {
    final Document document = editor.getDocument();
    WriteCommandAction.runWriteCommandAction(editor.getProject(), SSRBundle.message("modify.editor.content.command.name"), SS_GROUP,
                                             () -> document.replaceString(0, document.getTextLength(), text));
  }

  public static void invokeAction(@NotNull Configuration config, @NotNull SearchContext context) {
    StructuralSearchAction.triggerAction(config, context, !(config instanceof SearchConfiguration));
  }

  @NotNull
  public static MatchVariableConstraint getOrAddVariableConstraint(@NotNull String varName, @NotNull Configuration configuration) {
    final MatchOptions options = configuration.getMatchOptions();
    final MatchVariableConstraint varInfo = options.getVariableConstraint(varName);

    if (varInfo != null) {
      return varInfo;
    }
    return configuration.getMatchOptions().addNewVariableConstraint(varName);
  }

  @NotNull
  public static ReplacementVariableDefinition getOrAddReplacementVariable(@NotNull String varName, @NotNull Configuration configuration) {
    final ReplaceOptions replaceOptions = configuration.getReplaceOptions();
    ReplacementVariableDefinition definition = replaceOptions.getVariableDefinition(varName);

    if (definition != null) {
      return definition;
    }
    return replaceOptions.addNewVariableDefinition(varName);
  }

  public static boolean isTarget(@NotNull String varName, @NotNull MatchOptions matchOptions) {
    if (Configuration.CONTEXT_VAR_NAME.equals(varName)) {
      // Complete Match is default target
      for (String name : matchOptions.getVariableConstraintNames()) {
        if (!name.equals(Configuration.CONTEXT_VAR_NAME)) {
          if (matchOptions.getVariableConstraint(name).isPartOfSearchResults()) {
            return false;
          }
        }
      }
      return true;
    }
    final MatchVariableConstraint constraint = matchOptions.getVariableConstraint(varName);
    if (constraint == null) {
      return false;
    }
    return constraint.isPartOfSearchResults();
  }

  @NotNull
  public static EditorTextField createTextComponent(@NotNull String text, @NotNull Project project) {
    return createEditorComponent(text, "1.txt", project);
  }

  @NotNull
  public static EditorTextField createRegexComponent(@NotNull String text, @NotNull Project project) {
    return createEditorComponent(text, "1.regexp", project);
  }

  @NotNull
  public static EditorTextField createScriptComponent(@NotNull String text, @NotNull Project project) {
    return createEditorComponent(text, "1.groovy", project);
  }

  @NotNull
  public static EditorTextField createEditorComponent(@NotNull String text, @NotNull String fileName, @NotNull Project project) {
    final FileType fileType = getFileType(fileName);
    final Document document = createDocument(fileType, text, project);
    return new EditorTextField(document, project, fileType);
  }

  @NotNull
  public static Document createDocument(@NotNull FileType fileType, @NotNull String text, @NotNull Project project) {
    final PsiFile file =
      PsiFileFactory.getInstance(project).createFileFromText("Dummy." + fileType.getDefaultExtension(), fileType, text, -1, true);
    final Document document = PsiDocumentManager.getInstance(project).getDocument(file);
    assert document != null;
    return document;
  }

  @NotNull
  private static FileType getFileType(@NotNull String fileName) {
    FileType fileType = FileTypeManager.getInstance().getFileTypeByFileName(fileName);
    if (fileType == FileTypes.UNKNOWN) fileType = FileTypes.PLAIN_TEXT;
    return fileType;
  }

  @NotNull
  public static LanguageFileType detectFileType(@NotNull SearchContext searchContext) {
    final PsiFile file = searchContext.getFile();
    PsiElement context = null;

    final Editor editor = searchContext.getEditor();
    if (editor != null && file != null) {
      final int offset = editor.getCaretModel().getOffset();
      context = InjectedLanguageManager.getInstance(searchContext.getProject()).findInjectedElementAt(file, offset);
      if (context == null) {
        context = file.findElementAt(offset);
      }
      if (context != null) {
        context = context.getParent();
      }
      if (context == null) {
        context = file;
      }
    }
    if (context != null) {
      final Language language = context.getLanguage();
      final StructuralSearchProfile profile = StructuralSearchUtil.getProfileByLanguage(language);
      if (profile != null) {
        LanguageFileType fileType = profile.detectFileType(context);
        if (fileType == null) {
          fileType = language.getAssociatedFileType();
        }
        if (fileType != null) return fileType;
      }
    }
    return StructuralSearchUtil.getDefaultFileType();
  }

  @NotNull
  public static Document createDocument(@NotNull Project project, @Nullable LanguageFileType fileType, Language dialect,
                                        PatternContext patternContext, @NotNull String text, @Nullable StructuralSearchProfile profile) {
    if (fileType != null && profile != null) {
      final String contextId = (patternContext == null) ? null : patternContext.getId();
      PsiFile codeFragment = profile.createCodeFragment(project, text, contextId);
      if (codeFragment == null) {
        codeFragment = createFileFragment(project, fileType, dialect, text);
      }

      if (codeFragment != null) {
        final Document doc = PsiDocumentManager.getInstance(project).getDocument(codeFragment);
        assert doc != null : "code fragment element should be physical";
        return doc;
      }
    }
    return EditorFactory.getInstance().createDocument(text);
  }

  @NotNull
  public static Editor createEditor(@NotNull Project project, @NotNull LanguageFileType fileType, Language dialect, @NotNull String text,
                                    boolean editable, @NotNull StructuralSearchProfile profile) {
    PsiFile codeFragment = profile.createCodeFragment(project, text, null);
    if (codeFragment == null) {
      codeFragment = createFileFragment(project, fileType, dialect, text);
    }

    final Document doc;
    if (codeFragment != null) {
      doc = PsiDocumentManager.getInstance(project).getDocument(codeFragment);
      assert doc != null : "code fragment element should be physical";
      DaemonCodeAnalyzer.getInstance(project).setHighlightingEnabled(codeFragment, false);
    }
    else {
      doc = EditorFactory.getInstance().createDocument("");
    }
    return createEditor(doc, project, editable, getTemplateContextType(profile));
  }

  private static PsiFile createFileFragment(@NotNull Project project, @NotNull LanguageFileType fileType, Language dialect, @NotNull String text) {
    final String name = "__dummy." + fileType.getDefaultExtension();
    final PsiFileFactory factory = PsiFileFactory.getInstance(project);

    return dialect == null
           ? factory.createFileFromText(name, fileType, text, LocalTimeCounter.currentTime(), true, true)
           : factory.createFileFromText(name, dialect, text, true, true);
  }

  public static TemplateContextType getTemplateContextType(@NotNull StructuralSearchProfile profile) {
    final Class<? extends TemplateContextType> clazz = profile.getTemplateContextTypeClass();
    return ContainerUtil.findInstance(TemplateContextType.EP_NAME.getExtensions(), clazz);
  }
}


text:
Hi Everyone,

This is really meant to be a way to consolidate useful links for learning programming.  So, if you've got something you'd really like to share, feel free to open a pull request or an issue.  (I'll come up with a clever way to show who suggested what... maybe  "thing -- (contributed: person)?"

Thanks, and happy programming! :)

~Jon

redpajama_set_name: RedPajamaGithub


text:
/**/
/* normal state */
/**/
.sky-form .toggle i:before {
	background-color: #F78181;
}
.sky-form .button {
	background-color: #EF3B3A;
    }

/**/
/* hover state */
/**/
.sky-form .input:hover input,
.sky-form .select:hover select,
.sky-form .textarea:hover textarea,
.sky-form .radio:hover i,
.sky-form .checkbox:hover i,
.sky-form .toggle:hover i {
	border-color: #F78181;
}
.sky-form .rating input + label:hover,
.sky-form .rating input + label:hover ~ label {
	color: #F78181;
}

/**/
/* focus state */
/**/
.sky-form .input input:focus,
.sky-form .select select:focus,
.sky-form .textarea textarea:focus,
.sky-form .radio input:focus + i,
.sky-form .checkbox input:focus + i,
.sky-form .toggle input:focus + i {
	border-color: #F78181;
}

/**/
/* checked state */
/**/
.sky-form .radio input + i:after {
	background-color: #F78181;
}
.sky-form .checkbox input + i:after {
	color: #F78181;
}
.sky-form .radio input:checked + i,
.sky-form .checkbox input:checked + i,
.sky-form .toggle input:checked + i {
	border-color: #F78181;
}
.sky-form .rating input:checked ~ label {
	color: #F78181;
}


text:
"""
__ExitPtConOPsOfExitPtOUT_Complete_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: gehan
Modified: Mon Mar  9 18:19:28 2015
______________________________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from MT_pre__ExitPoint import *
from MT_pre__Transition import *
from MT_pre__State import *
from MT_pre__OUT2 import *
from MT_pre__Name import *
from MT_pre__Trigger_T import *
from MT_pre__Par import *
from MT_pre__Inst import *
from MT_pre__Attribute import *
from MT_pre__Equation import *
from MT_pre__Constant import *
from MT_pre__directLink_T import *
from MT_pre__directLink_S import *
from MT_pre__trace_link import *
from MT_pre__hasAttribute_S import *
from MT_pre__hasAttribute_T import *
from MT_pre__leftExpr import *
from MT_pre__rightExpr import *
from LHS import *
from graph_MT_pre__Equation import *
from graph_MT_pre__Trigger_T import *
from graph_MT_pre__directLink_T import *
from graph_LHS import *
from graph_MT_pre__hasAttribute_T import *
from graph_MT_pre__trace_link import *
from graph_MT_pre__Name import *
from graph_MT_pre__Transition import *
from graph_MT_pre__hasAttribute_S import *
from graph_MT_pre__State import *
from graph_MT_pre__directLink_S import *
from graph_MT_pre__rightExpr import *
from graph_MT_pre__Constant import *
from graph_MT_pre__ExitPoint import *
from graph_MT_pre__OUT2 import *
from graph_MT_pre__Par import *
from graph_MT_pre__Attribute import *
from graph_MT_pre__leftExpr import *
from graph_MT_pre__Inst 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 ExitPtConOPsOfExitPtOUT_Complete_MDL(self, rootNode, MoTifRuleRootNode=None, MT_pre__UMLRT2Kiltera_MMRootNode=None):

    # --- Generating attributes code for ASG MoTifRule ---
    if( MoTifRuleRootNode ):
        # author
        MoTifRuleRootNode.author.setValue('Annonymous')

        # description
        MoTifRuleRootNode.description.setValue('\n')
        MoTifRuleRootNode.description.setHeight(15)

        # name
        MoTifRuleRootNode.name.setValue('ExitPtConOPsOfExitPtOUT_Complete')
    # --- ASG attributes over ---

    # --- Generating attributes code for ASG MT_pre__UMLRT2Kiltera_MM ---
    if( MT_pre__UMLRT2Kiltera_MMRootNode ):
        # author
        MT_pre__UMLRT2Kiltera_MMRootNode.author.setValue('Annonymous')

        # description
        MT_pre__UMLRT2Kiltera_MMRootNode.description.setValue('\n')
        MT_pre__UMLRT2Kiltera_MMRootNode.description.setHeight(15)

        # name
        MT_pre__UMLRT2Kiltera_MMRootNode.name.setValue('')
        MT_pre__UMLRT2Kiltera_MMRootNode.name.setNone()
    # --- ASG attributes over ---

    self.obj73895=MT_pre__ExitPoint(self)
    self.obj73895.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73895.MT_pivotOut__.setValue('element2')

    # MT_subtypeMatching__
    self.obj73895.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73895.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73895.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73895.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj73895.MT_pivotIn__.setValue('element2')

    # MT_label__
    self.obj73895.MT_label__.setValue('2')

    # MT_pre__cardinality
    self.obj73895.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73895.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73895.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73895.MT_pre__name.setHeight(15)

    self.obj73895.graphClass_= graph_MT_pre__ExitPoint
    if self.genGraphics:
       new_obj = graph_MT_pre__ExitPoint(233.0,40.0,self.obj73895)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__ExitPoint", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73895.graphObject_ = new_obj

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

    self.obj73896=MT_pre__Transition(self)
    self.obj73896.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73896.MT_pivotOut__.setValue('element3')

    # MT_subtypeMatching__
    self.obj73896.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73896.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73896.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73896.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj73896.MT_pivotIn__.setValue('element3')

    # MT_label__
    self.obj73896.MT_label__.setValue('3')

    # MT_pre__cardinality
    self.obj73896.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73896.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73896.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73896.MT_pre__name.setHeight(15)

    self.obj73896.graphClass_= graph_MT_pre__Transition
    if self.genGraphics:
       new_obj = graph_MT_pre__Transition(260.0,140.0,self.obj73896)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Transition", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73896.graphObject_ = new_obj

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

    self.obj73897=MT_pre__State(self)
    self.obj73897.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73897.MT_pivotOut__.setValue('element1')

    # MT_subtypeMatching__
    self.obj73897.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73897.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73897.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73897.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj73897.MT_pivotIn__.setValue('element1')

    # MT_label__
    self.obj73897.MT_label__.setValue('1')

    # MT_pre__cardinality
    self.obj73897.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73897.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73897.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73897.MT_pre__name.setHeight(15)

    self.obj73897.graphClass_= graph_MT_pre__State
    if self.genGraphics:
       new_obj = graph_MT_pre__State(60.0,40.0,self.obj73897)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__State", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73897.graphObject_ = new_obj

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

    self.obj73898=MT_pre__OUT2(self)
    self.obj73898.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73898.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj73898.MT_pivotOut__.setValue('element4')

    # MT_subtypeMatching__
    self.obj73898.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73898.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73898.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73898.MT_pre__classtype.setHeight(15)

    # MT_pre__cardinality
    self.obj73898.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73898.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73898.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73898.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj73898.MT_pivotIn__.setValue('element4')

    self.obj73898.graphClass_= graph_MT_pre__OUT2
    if self.genGraphics:
       new_obj = graph_MT_pre__OUT2(60.0,129.0,self.obj73898)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__OUT2", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73898.graphObject_ = new_obj

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

    self.obj73899=MT_pre__Name(self)
    self.obj73899.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73899.MT_pivotOut__.setValue('')
    self.obj73899.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73899.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73899.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73899.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73899.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj73899.MT_pivotIn__.setValue('')
    self.obj73899.MT_pivotIn__.setNone()

    # MT_label__
    self.obj73899.MT_label__.setValue('15')

    # MT_pre__cardinality
    self.obj73899.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73899.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73899.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73899.MT_pre__name.setHeight(15)

    self.obj73899.graphClass_= graph_MT_pre__Name
    if self.genGraphics:
       new_obj = graph_MT_pre__Name(200.0,260.0,self.obj73899)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Name", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73899.graphObject_ = new_obj

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

    self.obj73900=MT_pre__Trigger_T(self)
    self.obj73900.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73900.MT_label__.setValue('9')

    # MT_pivotOut__
    self.obj73900.MT_pivotOut__.setValue('')
    self.obj73900.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73900.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73900.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73900.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73900.MT_pre__classtype.setHeight(15)

    # MT_pre__cardinality
    self.obj73900.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73900.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73900.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73900.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj73900.MT_pivotIn__.setValue('')
    self.obj73900.MT_pivotIn__.setNone()

    self.obj73900.graphClass_= graph_MT_pre__Trigger_T
    if self.genGraphics:
       new_obj = graph_MT_pre__Trigger_T(238.0,220.0,self.obj73900)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Trigger_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73900.graphObject_ = new_obj

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

    self.obj73901=MT_pre__Par(self)
    self.obj73901.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73901.MT_label__.setValue('8')

    # MT_pivotOut__
    self.obj73901.MT_pivotOut__.setValue('')
    self.obj73901.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73901.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73901.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73901.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73901.MT_pre__classtype.setHeight(15)

    # MT_pre__cardinality
    self.obj73901.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73901.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73901.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73901.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj73901.MT_pivotIn__.setValue('')
    self.obj73901.MT_pivotIn__.setNone()

    self.obj73901.graphClass_= graph_MT_pre__Par
    if self.genGraphics:
       new_obj = graph_MT_pre__Par(60.0,200.0,self.obj73901)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Par", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73901.graphObject_ = new_obj

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

    self.obj73902=MT_pre__Inst(self)
    self.obj73902.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73902.MT_label__.setValue('10')

    # MT_pivotOut__
    self.obj73902.MT_pivotOut__.setValue('')
    self.obj73902.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73902.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73902.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj73902.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73902.MT_pre__classtype.setHeight(15)

    # MT_pre__cardinality
    self.obj73902.MT_pre__cardinality.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73902.MT_pre__cardinality.setHeight(15)

    # MT_pre__name
    self.obj73902.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73902.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj73902.MT_pivotIn__.setValue('')
    self.obj73902.MT_pivotIn__.setNone()

    self.obj73902.graphClass_= graph_MT_pre__Inst
    if self.genGraphics:
       new_obj = graph_MT_pre__Inst(60.0,260.0,self.obj73902)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Inst", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73902.graphObject_ = new_obj

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

    self.obj73903=MT_pre__Attribute(self)
    self.obj73903.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73903.MT_pivotOut__.setValue('')
    self.obj73903.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73903.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73903.MT_subtypeMatching__.config = 0

    # MT_pre__Type
    self.obj73903.MT_pre__Type.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73903.MT_pre__Type.setHeight(15)

    # MT_pivotIn__
    self.obj73903.MT_pivotIn__.setValue('')
    self.obj73903.MT_pivotIn__.setNone()

    # MT_label__
    self.obj73903.MT_label__.setValue('19')

    # MT_pre__name
    self.obj73903.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73903.MT_pre__name.setHeight(15)

    self.obj73903.graphClass_= graph_MT_pre__Attribute
    if self.genGraphics:
       new_obj = graph_MT_pre__Attribute(80.0,140.0,self.obj73903)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Attribute", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73903.graphObject_ = new_obj

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

    self.obj73924=MT_pre__Attribute(self)
    self.obj73924.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73924.MT_pivotOut__.setValue('')
    self.obj73924.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73924.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73924.MT_subtypeMatching__.config = 0

    # MT_pre__Type
    self.obj73924.MT_pre__Type.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73924.MT_pre__Type.setHeight(15)

    # MT_pivotIn__
    self.obj73924.MT_pivotIn__.setValue('')
    self.obj73924.MT_pivotIn__.setNone()

    # MT_label__
    self.obj73924.MT_label__.setValue('25')

    # MT_pre__name
    self.obj73924.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73924.MT_pre__name.setHeight(15)

    self.obj73924.graphClass_= graph_MT_pre__Attribute
    if self.genGraphics:
       new_obj = graph_MT_pre__Attribute(100.0,60.0,self.obj73924)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Attribute", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73924.graphObject_ = new_obj

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

    self.obj73904=MT_pre__Equation(self)
    self.obj73904.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73904.MT_label__.setValue('20')

    # MT_pivotOut__
    self.obj73904.MT_pivotOut__.setValue('')
    self.obj73904.MT_pivotOut__.setNone()

    # MT_pre__name
    self.obj73904.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73904.MT_pre__name.setHeight(15)

    # MT_subtypeMatching__
    self.obj73904.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73904.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73904.MT_pivotIn__.setValue('')
    self.obj73904.MT_pivotIn__.setNone()

    self.obj73904.graphClass_= graph_MT_pre__Equation
    if self.genGraphics:
       new_obj = graph_MT_pre__Equation(100.0,220.0,self.obj73904)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Equation", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73904.graphObject_ = new_obj

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

    self.obj73925=MT_pre__Equation(self)
    self.obj73925.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73925.MT_label__.setValue('26')

    # MT_pivotOut__
    self.obj73925.MT_pivotOut__.setValue('')
    self.obj73925.MT_pivotOut__.setNone()

    # MT_pre__name
    self.obj73925.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73925.MT_pre__name.setHeight(15)

    # MT_subtypeMatching__
    self.obj73925.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73925.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73925.MT_pivotIn__.setValue('')
    self.obj73925.MT_pivotIn__.setNone()

    self.obj73925.graphClass_= graph_MT_pre__Equation
    if self.genGraphics:
       new_obj = graph_MT_pre__Equation(260.0,40.0,self.obj73925)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Equation", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73925.graphObject_ = new_obj

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

    self.obj73905=MT_pre__Constant(self)
    self.obj73905.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73905.MT_pivotOut__.setValue('')
    self.obj73905.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73905.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73905.MT_subtypeMatching__.config = 0

    # MT_pre__Type
    self.obj73905.MT_pre__Type.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73905.MT_pre__Type.setHeight(15)

    # MT_pivotIn__
    self.obj73905.MT_pivotIn__.setValue('')
    self.obj73905.MT_pivotIn__.setNone()

    # MT_label__
    self.obj73905.MT_label__.setValue('22')

    # MT_pre__name
    self.obj73905.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73905.MT_pre__name.setHeight(15)

    self.obj73905.graphClass_= graph_MT_pre__Constant
    if self.genGraphics:
       new_obj = graph_MT_pre__Constant(100.0,280.0,self.obj73905)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Constant", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73905.graphObject_ = new_obj

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

    self.obj73926=MT_pre__Constant(self)
    self.obj73926.isGraphObjectVisual = True

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

    # MT_pivotOut__
    self.obj73926.MT_pivotOut__.setValue('')
    self.obj73926.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73926.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73926.MT_subtypeMatching__.config = 0

    # MT_pre__Type
    self.obj73926.MT_pre__Type.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73926.MT_pre__Type.setHeight(15)

    # MT_pivotIn__
    self.obj73926.MT_pivotIn__.setValue('')
    self.obj73926.MT_pivotIn__.setNone()

    # MT_label__
    self.obj73926.MT_label__.setValue('27')

    # MT_pre__name
    self.obj73926.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73926.MT_pre__name.setHeight(15)

    self.obj73926.graphClass_= graph_MT_pre__Constant
    if self.genGraphics:
       new_obj = graph_MT_pre__Constant(240.0,140.0,self.obj73926)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Constant", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73926.graphObject_ = new_obj

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

    self.obj73906=MT_pre__directLink_T(self)
    self.obj73906.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73906.MT_label__.setValue('11')

    # MT_pivotOut__
    self.obj73906.MT_pivotOut__.setValue('')
    self.obj73906.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73906.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73906.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73906.MT_pivotIn__.setValue('')
    self.obj73906.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73906.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73906.MT_pre__associationType.setHeight(15)

    self.obj73906.graphClass_= graph_MT_pre__directLink_T
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_T(366.0,311.0,self.obj73906)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73906.graphObject_ = new_obj

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

    self.obj73907=MT_pre__directLink_T(self)
    self.obj73907.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73907.MT_label__.setValue('12')

    # MT_pivotOut__
    self.obj73907.MT_pivotOut__.setValue('')
    self.obj73907.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73907.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73907.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73907.MT_pivotIn__.setValue('')
    self.obj73907.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73907.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73907.MT_pre__associationType.setHeight(15)

    self.obj73907.graphClass_= graph_MT_pre__directLink_T
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_T(279.5,331.0,self.obj73907)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73907.graphObject_ = new_obj

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

    self.obj73908=MT_pre__directLink_T(self)
    self.obj73908.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73908.MT_label__.setValue('16')

    # MT_pivotOut__
    self.obj73908.MT_pivotOut__.setValue('')
    self.obj73908.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73908.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73908.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73908.MT_pivotIn__.setValue('')
    self.obj73908.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73908.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73908.MT_pre__associationType.setHeight(15)

    self.obj73908.graphClass_= graph_MT_pre__directLink_T
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_T(352.0,361.0,self.obj73908)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73908.graphObject_ = new_obj

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

    self.obj73909=MT_pre__directLink_S(self)
    self.obj73909.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73909.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj73909.MT_pivotOut__.setValue('')
    self.obj73909.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73909.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73909.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73909.MT_pivotIn__.setValue('')
    self.obj73909.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73909.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73909.MT_pre__associationType.setHeight(15)

    self.obj73909.graphClass_= graph_MT_pre__directLink_S
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_S(344.5,115.0,self.obj73909)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73909.graphObject_ = new_obj

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

    self.obj73910=MT_pre__directLink_S(self)
    self.obj73910.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73910.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj73910.MT_pivotOut__.setValue('')
    self.obj73910.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73910.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73910.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73910.MT_pivotIn__.setValue('')
    self.obj73910.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73910.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73910.MT_pre__associationType.setHeight(15)

    self.obj73910.graphClass_= graph_MT_pre__directLink_S
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_S(453.0,159.0,self.obj73910)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73910.graphObject_ = new_obj

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

    self.obj73911=MT_pre__directLink_S(self)
    self.obj73911.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73911.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj73911.MT_pivotOut__.setValue('')
    self.obj73911.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73911.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73911.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73911.MT_pivotIn__.setValue('')
    self.obj73911.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj73911.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj73911.MT_pre__associationType.setHeight(15)

    self.obj73911.graphClass_= graph_MT_pre__directLink_S
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_S(365.5,203.5,self.obj73911)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73911.graphObject_ = new_obj

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

    self.obj73912=MT_pre__trace_link(self)
    self.obj73912.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73912.MT_label__.setValue('13')

    # MT_pivotOut__
    self.obj73912.MT_pivotOut__.setValue('')
    self.obj73912.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73912.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73912.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73912.MT_pivotIn__.setValue('')
    self.obj73912.MT_pivotIn__.setNone()

    self.obj73912.graphClass_= graph_MT_pre__trace_link
    if self.genGraphics:
       new_obj = graph_MT_pre__trace_link(353.5,208.0,self.obj73912)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__trace_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73912.graphObject_ = new_obj

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

    self.obj73913=MT_pre__trace_link(self)
    self.obj73913.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73913.MT_label__.setValue('14')

    # MT_pivotOut__
    self.obj73913.MT_pivotOut__.setValue('')
    self.obj73913.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73913.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73913.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73913.MT_pivotIn__.setValue('')
    self.obj73913.MT_pivotIn__.setNone()

    self.obj73913.graphClass_= graph_MT_pre__trace_link
    if self.genGraphics:
       new_obj = graph_MT_pre__trace_link(488.5,189.0,self.obj73913)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__trace_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73913.graphObject_ = new_obj

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

    self.obj73914=MT_pre__trace_link(self)
    self.obj73914.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73914.MT_label__.setValue('17')

    # MT_pivotOut__
    self.obj73914.MT_pivotOut__.setValue('')
    self.obj73914.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73914.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73914.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73914.MT_pivotIn__.setValue('')
    self.obj73914.MT_pivotIn__.setNone()

    self.obj73914.graphClass_= graph_MT_pre__trace_link
    if self.genGraphics:
       new_obj = graph_MT_pre__trace_link(369.5,288.0,self.obj73914)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__trace_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73914.graphObject_ = new_obj

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

    self.obj73915=MT_pre__trace_link(self)
    self.obj73915.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73915.MT_label__.setValue('18')

    # MT_pivotOut__
    self.obj73915.MT_pivotOut__.setValue('')
    self.obj73915.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73915.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73915.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73915.MT_pivotIn__.setValue('')
    self.obj73915.MT_pivotIn__.setNone()

    self.obj73915.graphClass_= graph_MT_pre__trace_link
    if self.genGraphics:
       new_obj = graph_MT_pre__trace_link(439.5,288.0,self.obj73915)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__trace_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73915.graphObject_ = new_obj

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

    self.obj73916=MT_pre__hasAttribute_S(self)
    self.obj73916.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73916.MT_label__.setValue('24')

    # MT_pivotOut__
    self.obj73916.MT_pivotOut__.setValue('')
    self.obj73916.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73916.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73916.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73916.MT_pivotIn__.setValue('')
    self.obj73916.MT_pivotIn__.setNone()

    self.obj73916.graphClass_= graph_MT_pre__hasAttribute_S
    if self.genGraphics:
       new_obj = graph_MT_pre__hasAttribute_S(251.0,160.0,self.obj73916)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__hasAttribute_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73916.graphObject_ = new_obj

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

    self.obj73931=MT_pre__hasAttribute_T(self)
    self.obj73931.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73931.MT_label__.setValue('28')

    # MT_pivotOut__
    self.obj73931.MT_pivotOut__.setValue('')
    self.obj73931.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73931.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73931.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73931.MT_pivotIn__.setValue('')
    self.obj73931.MT_pivotIn__.setNone()

    self.obj73931.graphClass_= graph_MT_pre__hasAttribute_T
    if self.genGraphics:
       new_obj = graph_MT_pre__hasAttribute_T(360.0,223.0,self.obj73931)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__hasAttribute_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73931.graphObject_ = new_obj

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

    self.obj73917=MT_pre__leftExpr(self)
    self.obj73917.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73917.MT_label__.setValue('21')

    # MT_pivotOut__
    self.obj73917.MT_pivotOut__.setValue('')
    self.obj73917.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73917.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73917.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73917.MT_pivotIn__.setValue('')
    self.obj73917.MT_pivotIn__.setNone()

    self.obj73917.graphClass_= graph_MT_pre__leftExpr
    if self.genGraphics:
       new_obj = graph_MT_pre__leftExpr(281.0,226.0,self.obj73917)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__leftExpr", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73917.graphObject_ = new_obj

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

    self.obj73932=MT_pre__leftExpr(self)
    self.obj73932.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73932.MT_label__.setValue('29')

    # MT_pivotOut__
    self.obj73932.MT_pivotOut__.setValue('')
    self.obj73932.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73932.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73932.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73932.MT_pivotIn__.setValue('')
    self.obj73932.MT_pivotIn__.setNone()

    self.obj73932.graphClass_= graph_MT_pre__leftExpr
    if self.genGraphics:
       new_obj = graph_MT_pre__leftExpr(317.0,127.0,self.obj73932)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__leftExpr", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73932.graphObject_ = new_obj

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

    self.obj73918=MT_pre__rightExpr(self)
    self.obj73918.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73918.MT_label__.setValue('23')

    # MT_pivotOut__
    self.obj73918.MT_pivotOut__.setValue('')
    self.obj73918.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73918.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73918.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73918.MT_pivotIn__.setValue('')
    self.obj73918.MT_pivotIn__.setNone()

    self.obj73918.graphClass_= graph_MT_pre__rightExpr
    if self.genGraphics:
       new_obj = graph_MT_pre__rightExpr(350.0,331.0,self.obj73918)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__rightExpr", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73918.graphObject_ = new_obj

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

    self.obj73933=MT_pre__rightExpr(self)
    self.obj73933.isGraphObjectVisual = True

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

    # MT_label__
    self.obj73933.MT_label__.setValue('30')

    # MT_pivotOut__
    self.obj73933.MT_pivotOut__.setValue('')
    self.obj73933.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj73933.MT_subtypeMatching__.setValue(('True', 0))
    self.obj73933.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj73933.MT_pivotIn__.setValue('')
    self.obj73933.MT_pivotIn__.setNone()

    self.obj73933.graphClass_= graph_MT_pre__rightExpr
    if self.genGraphics:
       new_obj = graph_MT_pre__rightExpr(441.0,174.0,self.obj73933)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__rightExpr", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
    else: new_obj = None
    self.obj73933.graphObject_ = new_obj

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

    self.obj73919=LHS(self)
    self.obj73919.isGraphObjectVisual = True

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

    # constraint
    self.obj73919.constraint.setValue('#===============================================================================\n# This code is executed after the nodes in the LHS have been matched.\n# You can access a matched node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# The given constraint must evaluate to a boolean expression:\n#    returning True enables the rule to be applied,\n#    returning False forbids the rule from being applied.\n#===============================================================================\nif (PreNode(\'19\')[\'name\']==\'isComposite\')and (PreNode(\'22\')[\'name\']==\'true\') and (PreNode(\'25\')[\'name\']==\'channel\')and (PreNode(\'27\')[\'name\']==\'sh_in\'):\n   return True\nreturn False\n')
    self.obj73919.constraint.setHeight(15)

    self.obj73919.graphClass_= graph_LHS
    if self.genGraphics:
       new_obj = graph_LHS(36.0,20.0,self.obj73919)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("LHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj73919.graphObject_ = new_obj

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

    # Connections for obj73895 (graphObject_: Obj73) of type MT_pre__ExitPoint
    self.drawConnections(
(self.obj73895,self.obj73910,[430.0, 115.0, 453.0, 159.0],"true", 2) )
    # Connections for obj73896 (graphObject_: Obj74) of type MT_pre__Transition
    self.drawConnections(
(self.obj73896,self.obj73911,[457.0, 215.0, 365.5, 203.5],"true", 2) )
    # Connections for obj73897 (graphObject_: Obj75) of type MT_pre__State
    self.drawConnections(
(self.obj73897,self.obj73909,[257.0, 115.0, 344.5, 115.0],"true", 2),
(self.obj73897,self.obj73916,[257.0, 115.0, 251.0, 160.0],"true", 2) )
    # Connections for obj73898 (graphObject_: Obj76) of type MT_pre__OUT2
    self.drawConnections(
 )
    # Connections for obj73899 (graphObject_: Obj77) of type MT_pre__Name
    self.drawConnections(
(self.obj73899,self.obj73915,[422.0, 361.0, 439.5, 288.0],"true", 2) )
    # Connections for obj73900 (graphObject_: Obj78) of type MT_pre__Trigger_T
    self.drawConnections(
(self.obj73900,self.obj73913,[455.0, 321.0, 488.5, 189.0],"true", 2),
(self.obj73900,self.obj73931,[455.0, 321.0, 360.0, 223.0],"true", 2) )
    # Connections for obj73901 (graphObject_: Obj79) of type MT_pre__Par
    self.drawConnections(
(self.obj73901,self.obj73906,[277.0, 301.0, 366.0, 311.0],"true", 2),
(self.obj73901,self.obj73907,[277.0, 301.0, 279.5, 331.0],"true", 2),
(self.obj73901,self.obj73912,[277.0, 301.0, 353.5, 208.0],"true", 2) )
    # Connections for obj73902 (graphObject_: Obj80) of type MT_pre__Inst
    self.drawConnections(
(self.obj73902,self.obj73908,[282.0, 361.0, 352.0, 361.0],"true", 2),
(self.obj73902,self.obj73914,[282.0, 361.0, 369.5, 288.0],"true", 2) )
    # Connections for obj73903 (graphObject_: Obj81) of type MT_pre__Attribute
    self.drawConnections(
 )
    # Connections for obj73924 (graphObject_: Obj98) of type MT_pre__Attribute
    self.drawConnections(
 )
    # Connections for obj73904 (graphObject_: Obj82) of type MT_pre__Equation
    self.drawConnections(
(self.obj73904,self.obj73917,[269.0, 293.0, 281.0, 226.0],"true", 2),
(self.obj73904,self.obj73918,[269.0, 293.0, 350.0, 331.0],"true", 2) )
    # Connections for obj73925 (graphObject_: Obj99) of type MT_pre__Equation
    self.drawConnections(
(self.obj73925,self.obj73932,[429.0, 113.0, 317.0, 127.0],"true", 2),
(self.obj73925,self.obj73933,[429.0, 113.0, 441.0, 174.0],"true", 2) )
    # Connections for obj73905 (graphObject_: Obj83) of type MT_pre__Constant
    self.drawConnections(
 )
    # Connections for obj73926 (graphObject_: Obj100) of type MT_pre__Constant
    self.drawConnections(
 )
    # Connections for obj73906 (graphObject_: Obj84) of type MT_pre__directLink_T
    self.drawConnections(
(self.obj73906,self.obj73900,[366.0, 311.0, 455.0, 321.0],"true", 2) )
    # Connections for obj73907 (graphObject_: Obj85) of type MT_pre__directLink_T
    self.drawConnections(
(self.obj73907,self.obj73902,[279.5, 331.0, 282.0, 361.0],"true", 2) )
    # Connections for obj73908 (graphObject_: Obj86) of type MT_pre__directLink_T
    self.drawConnections(
(self.obj73908,self.obj73899,[352.0, 361.0, 422.0, 361.0],"true", 2) )
    # Connections for obj73909 (graphObject_: Obj87) of type MT_pre__directLink_S
    self.drawConnections(
(self.obj73909,self.obj73895,[344.5, 115.0, 430.0, 115.0],"true", 2) )
    # Connections for obj73910 (graphObject_: Obj88) of type MT_pre__directLink_S
    self.drawConnections(
(self.obj73910,self.obj73896,[453.0, 159.0, 457.0, 215.0],"true", 2) )
    # Connections for obj73911 (graphObject_: Obj89) of type MT_pre__directLink_S
    self.drawConnections(
(self.obj73911,self.obj73898,[365.5, 203.5, 257.0, 204.0],"true", 2) )
    # Connections for obj73912 (graphObject_: Obj90) of type MT_pre__trace_link
    self.drawConnections(
(self.obj73912,self.obj73895,[353.5, 208.0, 430.0, 115.0],"true", 2) )
    # Connections for obj73913 (graphObject_: Obj91) of type MT_pre__trace_link
    self.drawConnections(
(self.obj73913,self.obj73895,[488.5, 189.0, 430.0, 115.0],"true", 2) )
    # Connections for obj73914 (graphObject_: Obj92) of type MT_pre__trace_link
    self.drawConnections(
(self.obj73914,self.obj73896,[369.5, 288.0, 457.0, 215.0],"true", 2) )
    # Connections for obj73915 (graphObject_: Obj93) of type MT_pre__trace_link
    self.drawConnections(
(self.obj73915,self.obj73896,[439.5, 288.0, 457.0, 215.0],"true", 2) )
    # Connections for obj73916 (graphObject_: Obj94) of type MT_pre__hasAttribute_S
    self.drawConnections(
(self.obj73916,self.obj73903,[251.0, 160.0, 245.0, 205.0],"true", 2) )
    # Connections for obj73931 (graphObject_: Obj101) of type MT_pre__hasAttribute_T
    self.drawConnections(
(self.obj73931,self.obj73924,[360.0, 223.0, 265.0, 125.0],"true", 2) )
    # Connections for obj73917 (graphObject_: Obj95) of type MT_pre__leftExpr
    self.drawConnections(
(self.obj73917,self.obj73903,[281.0, 226.0, 245.0, 205.0],"true", 2) )
    # Connections for obj73932 (graphObject_: Obj102) of type MT_pre__leftExpr
    self.drawConnections(
(self.obj73932,self.obj73924,[317.0, 127.0, 265.0, 125.0],"true", 2) )
    # Connections for obj73918 (graphObject_: Obj96) of type MT_pre__rightExpr
    self.drawConnections(
(self.obj73918,self.obj73905,[350.0, 331.0, 265.0, 345.0],"true", 2) )
    # Connections for obj73933 (graphObject_: Obj103) of type MT_pre__rightExpr
    self.drawConnections(
(self.obj73933,self.obj73926,[441.0, 174.0, 405.0, 205.0],"true", 2) )
    # Connections for obj73919 (graphObject_: Obj97) of type LHS
    self.drawConnections(
 )

newfunction = ExitPtConOPsOfExitPtOUT_Complete_MDL

loadedMMName = ['MoTifRule_META', 'MT_pre__UMLRT2Kiltera_MM_META']

atom3version = '0.3'