Пример #1
0
  public void updateModelChoiceField(
      AbstractClass srcClazz, Association ass, ModelChoiceField mcf) {

    ModelChoiceField modelChoiceFieldForAssociation =
        ClassDiagramUtils.getModelChoiceFieldForAssociation(ass, srcClazz);

    int parseInt = modelChoiceFieldForAssociation.getMax_bound();
    // at least bounds must be compatible with constraints in the dt model
    boolean b = (((ModelChoiceField) mcf).getMax_bound() > parseInt) && (parseInt != -1);
    if (headless) {
      if (b) {
        mcf.setMax_bound(parseInt);
      }
    } else {
      if (b) {
        cc.append(
            SetCommand.create(
                domain, mcf, FormPackage.eINSTANCE.getModelChoiceField_Max_bound(), parseInt));
      }
    }
    // maybe the name or Label have been changed must be based on target name/Label if exists
    String id = modelChoiceFieldForAssociation.getId();
    if (updateId && !id.equals(mcf.getId())) {
      updateId(mcf, id);
    }
    String label = modelChoiceFieldForAssociation.getLabel();
    if (updateLabel && !label.equals(mcf.getLabel())) {
      updateLabel(mcf, label);
    }
  }
Пример #2
0
  public void updateAttributeFields(
      FormContainer formContainer, FormElement formElement, Attribute att) {
    FormElement fieldForAttribute = null;
    if (formContainer instanceof FormSearch) {
      fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(att);
    } else if (formContainer instanceof FormClass || formContainer instanceof FormWorkflow) {
      fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(att);
    }

    if (!fieldForAttribute.getClass().isInstance(formElement)) {
      // mismatch so we replace the Field
      FormGroup eContainer = (FormGroup) formElement.eContainer();
      boolean contains = eContainer.getChildren().contains(formElement);

      if (headless) {
        EList<FormElement> children = null;
        if (contains) {
          children = eContainer.getChildren();
        } else {
          children = eContainer.getDisabled();
        }
        // add the new Field
        children.add(fieldForAttribute);
        // remove
        children.remove(formElement);
      } else {
        if (contains) {
          cc.append(
              AddCommand.create(
                  domain,
                  eContainer,
                  FormPackage.eINSTANCE.getFormGroup_Children(),
                  fieldForAttribute));
        } else {
          cc.append(
              AddCommand.create(
                  domain,
                  eContainer,
                  FormPackage.eINSTANCE.getFormGroup_Disabled(),
                  fieldForAttribute));
        }
        Command rmCmd = RemoveCommand.create(domain, formElement);
        cc.append(rmCmd);
      }
    }
  }
Пример #3
0
  protected void synchronizeMissingAttributes(
      FormContainer o,
      List<FormElement> children,
      AbstractClass real_class,
      Set<FormGroup> groups,
      String filterNS) {

    List<Attribute> allAttributes = real_class.getAllAttributes();

    // get FormElement that miss
    ArrayList<Attribute> missAtt = new ArrayList<Attribute>();

    if (allAttributes != null) {
      missAtt.addAll(allAttributes);
    }

    for (FormElement formElement : children) {
      ModelElement ref = formElement.getRef();
      if (ref != null && ref instanceof Attribute) {
        // linked element is attribute so remove this attribute from the missing list
        missAtt.remove(ref);
      }
    }

    EList<FormGroup> allSubGroups = o.getAllSubGroups();
    groups.addAll(allSubGroups);

    // now we have the attribute missing list
    // initialize missing Field
    for (Attribute attribute : missAtt) {
      // Field or searchField
      FormElement fieldForAttribute = null;
      if (o instanceof FormSearch) {
        fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(attribute);
      } else if (o instanceof FormClass || o instanceof FormWorkflow) {
        fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(attribute);
      } else {
        System.out.println("SynchronizeWithClass.synchronizeMissingAttributes() o :" + o);
      }
      if (WorkflowInitialization.filterFormElement(filterNS, fieldForAttribute)) {

        // get where to add the field
        FormGroup parent = null;
        // mybe a group exist with ref to the attribute container
        AbstractClass eContainer = (AbstractClass) attribute.eContainer();
        // search for matching group

        for (FormGroup formGroup : groups) {
          ModelElement ref = formGroup.getRef();
          if (ref != null && ref.equals(eContainer)) {
            // matching group founded
            parent = formGroup;
            break;
          }
        }
        if (createMissingGroup && parent == null) {
          parent = ClassInitialization.createGroup(eContainer);
          groups.add(parent);
          addChild(o, parent);
        }
        if (parent == null) {
          parent = o;
        }

        // add new Field to the parent
        addChild(parent, fieldForAttribute);
      }
    }
  }
Пример #4
0
  protected void synchronizeMissingAssociations(
      FormContainer o,
      List<FormElement> children,
      AbstractClass real_class,
      Set<FormGroup> groups,
      String filterNS) {

    List<Association> allAssociations = real_class.getAllSourceAssociations();

    // get FormElement that miss
    ArrayList<Association> missAtt = new ArrayList<Association>();

    if (allAssociations != null) {
      missAtt.addAll(allAssociations);
    }

    for (FormElement formElement : children) {
      ModelElement ref = formElement.getRef();
      if (ref != null && ref instanceof Association) {
        // linked element is attribute so remove this attribute from the missing list
        missAtt.remove(ref);
      }
    }

    EList<FormGroup> allSubGroups = o.getAllSubGroups();
    groups.addAll(allSubGroups);

    // now we have the attribute missing list
    // initialize missing Field
    for (Association ass : missAtt) {

      FormElement fieldForAssociation = null;
      if (o instanceof FormClass || o instanceof FormWorkflow) {
        fieldForAssociation = ClassDiagramUtils.getModelChoiceFieldForAssociation(ass, real_class);
      } else if (o instanceof FormSearch) {
        fieldForAssociation =
            ClassDiagramUtils.transformAssociationIntoModelChoiceSearchField(ass, real_class);
      }

      if (WorkflowInitialization.filterFormElement(filterNS, fieldForAssociation)) {

        // get where to add the field
        FormGroup parent = null;
        // mybe a group exist with ref to the attribute container

        // search for matching group

        for (FormGroup formGroup : groups) {
          ModelElement ref = formGroup.getRef();
          if (ref instanceof AbstractClass
              && ((AbstractClass) ref).getSourceAssociations().contains(ass)) {
            // matching group founded
            parent = formGroup;
            break;
          }
        }

        if (createMissingGroup && parent == null) {
          AbstractClass source = null;
          EList<AbstractClass> sources = ass.getSource();
          if (sources.size() == 1) {
            source = sources.get(0);
          } else {
            EList<AbstractClass> allLinkedAbstractClass = real_class.getAllLinkedAbstractClass();
            boolean contains = allLinkedAbstractClass.contains(sources.get(0));
            if (contains) {
              source = sources.get(0);
            } else {
              source = sources.get(1);
            }
          }
          parent = ClassInitialization.createGroup(source);
          addChild(o, parent);
        }

        // add new Field to the parent
        if (parent == null) {
          parent = o;
        }
        addChild(parent, fieldForAssociation);
      }
    }
  }