/**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence participantStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        participantStep.addStep(InteractionViewsRepository.Participant.Properties.class);
    propertiesStep.addStep(InteractionViewsRepository.Participant.Properties.name);
    propertiesStep.addStep(InteractionViewsRepository.Participant.Properties.type);
    propertiesStep.addStep(InteractionViewsRepository.Participant.Properties.description);

    composer =
        new PartComposer(participantStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == InteractionViewsRepository.Participant.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == InteractionViewsRepository.Participant.Properties.name) {
              return createNameText(parent);
            }
            if (key == InteractionViewsRepository.Participant.Properties.type) {
              return createTypeFlatComboViewer(parent);
            }
            if (key == InteractionViewsRepository.Participant.Properties.description) {
              return createDescriptionText(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence projectStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        projectStep.addStep(EweViewsRepository.Project.Properties.class);
    propertiesStep.addStep(EweViewsRepository.Project.Properties.name);
    propertiesStep.addStep(EweViewsRepository.Project.Properties.defaultTarget);

    composer =
        new PartComposer(projectStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EweViewsRepository.Project.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == EweViewsRepository.Project.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == EweViewsRepository.Project.Properties.defaultTarget) {
              return createDefaultTargetFlatComboViewer(parent, widgetFactory);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence subflowStateStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        subflowStateStep.addStep(FlowViewsRepository.SubflowState.Properties.class);
    propertiesStep.addStep(FlowViewsRepository.SubflowState.Properties.subflow);
    propertiesStep.addStep(FlowViewsRepository.SubflowState.Properties.actions);
    propertiesStep.addStep(FlowViewsRepository.SubflowState.Properties.description);

    composer =
        new PartComposer(subflowStateStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == FlowViewsRepository.SubflowState.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.SubflowState.Properties.subflow) {
              return createSubflowFlatComboViewer(parent, widgetFactory);
            }
            if (key == FlowViewsRepository.SubflowState.Properties.actions) {
              return createActionsTableComposition(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.SubflowState.Properties.description) {
              return createDescriptionText(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence exhibitStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        exhibitStep.addStep(AmlViewsRepository.Exhibit.Properties.class);
    propertiesStep.addStep(AmlViewsRepository.Exhibit.Properties.annotation);
    propertiesStep.addStep(AmlViewsRepository.Exhibit.Properties.id);

    composer =
        new PartComposer(exhibitStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == AmlViewsRepository.Exhibit.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == AmlViewsRepository.Exhibit.Properties.annotation) {
              return createAnnotationAdvancedTableComposition(parent);
            }
            if (key == AmlViewsRepository.Exhibit.Properties.id) {
              return createIdText(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence foreignKeyStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        foreignKeyStep.addStep(DatabaseViewsRepository.ForeignKey.Properties.class);
    propertiesStep.addStep(DatabaseViewsRepository.ForeignKey.Properties.name);
    propertiesStep.addStep(DatabaseViewsRepository.ForeignKey.Properties.target);
    propertiesStep.addStep(DatabaseViewsRepository.ForeignKey.Properties.elements);
    propertiesStep.addStep(DatabaseViewsRepository.ForeignKey.Properties.comments);

    composer =
        new PartComposer(foreignKeyStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == DatabaseViewsRepository.ForeignKey.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == DatabaseViewsRepository.ForeignKey.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == DatabaseViewsRepository.ForeignKey.Properties.target) {
              return createTargetFlatComboViewer(parent, widgetFactory);
            }
            if (key == DatabaseViewsRepository.ForeignKey.Properties.elements) {
              return createElementsTableComposition(widgetFactory, parent);
            }
            if (key == DatabaseViewsRepository.ForeignKey.Properties.comments) {
              return createCommentsTextarea(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence serviceRefStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        serviceRefStep.addStep(EipViewsRepository.ServiceRef.Properties.class);
    propertiesStep.addStep(EipViewsRepository.ServiceRef.Properties.name);
    propertiesStep.addStep(EipViewsRepository.ServiceRef.Properties.reference);
    propertiesStep.addStep(EipViewsRepository.ServiceRef.Properties.operations);

    composer =
        new PartComposer(serviceRefStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EipViewsRepository.ServiceRef.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EipViewsRepository.ServiceRef.Properties.name) {
              return createNameText(parent);
            }
            if (key == EipViewsRepository.ServiceRef.Properties.reference) {
              return createReferenceText(parent);
            }
            if (key == EipViewsRepository.ServiceRef.Properties.operations) {
              return createOperationsMultiValuedEditor(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence guidancePackageStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        guidancePackageStep.addStep(UmaViewsRepository.GuidancePackage.Properties.class);
    propertiesStep.addStep(UmaViewsRepository.GuidancePackage.Properties.name);
    propertiesStep.addStep(UmaViewsRepository.GuidancePackage.Properties.ownedMethodContentMember);
    propertiesStep.addStep(UmaViewsRepository.GuidancePackage.Properties.reusedPackage);

    composer =
        new PartComposer(guidancePackageStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == UmaViewsRepository.GuidancePackage.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == UmaViewsRepository.GuidancePackage.Properties.name) {
              return createNameText(parent);
            }
            if (key == UmaViewsRepository.GuidancePackage.Properties.ownedMethodContentMember) {
              return createOwnedMethodContentMemberAdvancedTableComposition(parent);
            }
            if (key == UmaViewsRepository.GuidancePackage.Properties.reusedPackage) {
              return createReusedPackageAdvancedReferencesTable(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence simpleNamedTypeStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        simpleNamedTypeStep.addStep(TypeslibraryViewsRepository.SimpleNamedType.Properties.class);
    propertiesStep.addStep(TypeslibraryViewsRepository.SimpleNamedType.Properties.name);
    propertiesStep.addStep(TypeslibraryViewsRepository.SimpleNamedType.Properties.type);

    composer =
        new PartComposer(simpleNamedTypeStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == TypeslibraryViewsRepository.SimpleNamedType.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == TypeslibraryViewsRepository.SimpleNamedType.Properties.name) {
              return createNameText(parent);
            }
            if (key == TypeslibraryViewsRepository.SimpleNamedType.Properties.type) {
              return createTypeFlatComboViewer(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence identifierStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        identifierStep.addStep(EntityrelationViewsRepository.Identifier.Properties.class);
    propertiesStep.addStep(EntityrelationViewsRepository.Identifier.Properties.name);
    propertiesStep.addStep(EntityrelationViewsRepository.Identifier.Properties.attributes);
    propertiesStep.addStep(EntityrelationViewsRepository.Identifier.Properties.comments);

    composer =
        new PartComposer(identifierStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EntityrelationViewsRepository.Identifier.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == EntityrelationViewsRepository.Identifier.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == EntityrelationViewsRepository.Identifier.Properties.attributes) {
              return createAttributesReferencesTable(widgetFactory, parent);
            }
            if (key == EntityrelationViewsRepository.Identifier.Properties.comments) {
              return createCommentsTextarea(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence interactionUseStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        interactionUseStep.addStep(InteractionViewsRepository.InteractionUse.Properties.class);
    propertiesStep.addStep(InteractionViewsRepository.InteractionUse.Properties.name);
    propertiesStep.addStep(InteractionViewsRepository.InteractionUse.Properties.type);
    propertiesStep.addStep(InteractionViewsRepository.InteractionUse.Properties.interaction_);
    propertiesStep.addStep(InteractionViewsRepository.InteractionUse.Properties.description);

    composer =
        new PartComposer(interactionUseStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == InteractionViewsRepository.InteractionUse.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == InteractionViewsRepository.InteractionUse.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == InteractionViewsRepository.InteractionUse.Properties.type) {
              return createTypeText(widgetFactory, parent);
            }
            if (key == InteractionViewsRepository.InteractionUse.Properties.interaction_) {
              return createInteractionFlatComboViewer(parent, widgetFactory);
            }
            if (key == InteractionViewsRepository.InteractionUse.Properties.description) {
              return createDescriptionText(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence bindingElementStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        bindingElementStep.addStep(EnvironmentViewsRepository.BindingElement.Properties.class);
    propertiesStep.addStep(EnvironmentViewsRepository.BindingElement.Properties.boundElement);
    propertiesStep.addStep(EnvironmentViewsRepository.BindingElement.Properties.bindingExpression);
    propertiesStep.addStep(EnvironmentViewsRepository.BindingElement.Properties.description);

    composer =
        new PartComposer(bindingElementStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EnvironmentViewsRepository.BindingElement.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EnvironmentViewsRepository.BindingElement.Properties.boundElement) {
              return createBoundElementEMFComboViewer(parent);
            }
            if (key == EnvironmentViewsRepository.BindingElement.Properties.bindingExpression) {
              return createBindingExpressionText(parent);
            }
            if (key == EnvironmentViewsRepository.BindingElement.Properties.description) {
              return createDescriptionTextarea(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence entityStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        entityStep.addStep(EntityrelationViewsRepository.Entity.Properties.class);
    propertiesStep.addStep(EntityrelationViewsRepository.Entity.Properties.name);
    propertiesStep.addStep(EntityrelationViewsRepository.Entity.Properties.attributes);
    propertiesStep.addStep(EntityrelationViewsRepository.Entity.Properties.comments);

    composer =
        new PartComposer(entityStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EntityrelationViewsRepository.Entity.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EntityrelationViewsRepository.Entity.Properties.name) {
              return createNameText(parent);
            }
            if (key == EntityrelationViewsRepository.Entity.Properties.attributes) {
              return createAttributesAdvancedTableComposition(parent);
            }
            if (key == EntityrelationViewsRepository.Entity.Properties.comments) {
              return createCommentsTextarea(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence blockStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        blockStep.addStep(EntityViewsRepository.Block.Properties.class);
    propertiesStep.addStep(EntityViewsRepository.Block.Properties.name);
    propertiesStep.addStep(EntityViewsRepository.Block.Properties.description);

    composer =
        new PartComposer(blockStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EntityViewsRepository.Block.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EntityViewsRepository.Block.Properties.name) {
              return createNameText(parent);
            }
            if (key == EntityViewsRepository.Block.Properties.description) {
              return createDescriptionTextarea(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence qualificationPackageStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        qualificationPackageStep.addStep(UmaViewsRepository.QualificationPackage.Properties.class);
    propertiesStep.addStep(UmaViewsRepository.QualificationPackage.Properties.name);
    propertiesStep.addStep(
        UmaViewsRepository.QualificationPackage.Properties.ownedMethodContentMember);
    propertiesStep.addStep(UmaViewsRepository.QualificationPackage.Properties.reusedPackage);

    composer =
        new PartComposer(qualificationPackageStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == UmaViewsRepository.QualificationPackage.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == UmaViewsRepository.QualificationPackage.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key
                == UmaViewsRepository.QualificationPackage.Properties.ownedMethodContentMember) {
              return createOwnedMethodContentMemberTableComposition(widgetFactory, parent);
            }
            if (key == UmaViewsRepository.QualificationPackage.Properties.reusedPackage) {
              return createReusedPackageReferencesTable(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence reliabilityStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        reliabilityStep.addStep(AmlViewsRepository.Reliability.Properties.class);
    propertiesStep.addStep(AmlViewsRepository.Reliability.Properties.description);
    propertiesStep.addStep(AmlViewsRepository.Reliability.Properties.label);
    propertiesStep.addStep(AmlViewsRepository.Reliability.Properties.ordinal);
    propertiesStep.addStep(AmlViewsRepository.Reliability.Properties.symbol);

    composer =
        new PartComposer(reliabilityStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == AmlViewsRepository.Reliability.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == AmlViewsRepository.Reliability.Properties.description) {
              return createDescriptionText(parent);
            }
            if (key == AmlViewsRepository.Reliability.Properties.label) {
              return createLabelText(parent);
            }
            if (key == AmlViewsRepository.Reliability.Properties.ordinal) {
              return createOrdinalText(parent);
            }
            if (key == AmlViewsRepository.Reliability.Properties.symbol) {
              return createSymbolText(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence transformerStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        transformerStep.addStep(EipViewsRepository.Transformer.Properties.class);
    propertiesStep.addStep(EipViewsRepository.Transformer.Properties.name);
    propertiesStep.addStep(EipViewsRepository.Transformer.Properties.toChannels);
    propertiesStep.addStep(EipViewsRepository.Transformer.Properties.fromChannels);

    composer =
        new PartComposer(transformerStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EipViewsRepository.Transformer.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EipViewsRepository.Transformer.Properties.name) {
              return createNameText(parent);
            }
            if (key == EipViewsRepository.Transformer.Properties.toChannels) {
              return createToChannelsAdvancedReferencesTable(parent);
            }
            if (key == EipViewsRepository.Transformer.Properties.fromChannels) {
              return createFromChannelsAdvancedReferencesTable(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence resourceAccessStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        resourceAccessStep.addStep(DroidViewsRepository.ResourceAccess.Properties.class);
    propertiesStep.addStep(DroidViewsRepository.ResourceAccess.Properties.package_);
    propertiesStep.addStep(DroidViewsRepository.ResourceAccess.Properties.externalResource);

    composer =
        new PartComposer(resourceAccessStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == DroidViewsRepository.ResourceAccess.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == DroidViewsRepository.ResourceAccess.Properties.package_) {
              return createPackage_Text(widgetFactory, parent);
            }
            if (key == DroidViewsRepository.ResourceAccess.Properties.externalResource) {
              return createExternalResourceText(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence viewElementStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        viewElementStep.addStep(ViewViewsRepository.ViewElement.Properties.class);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.name);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.label);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.widget);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.required);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.type);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.actions);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.events);
    propertiesStep.addStep(ViewViewsRepository.ViewElement.Properties.description);

    composer =
        new PartComposer(viewElementStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == ViewViewsRepository.ViewElement.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.name) {
              return createNameText(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.label) {
              return createLabelText(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.widget) {
              return createWidgetFlatComboViewer(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.required) {
              return createRequiredCheckbox(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.type) {
              return createTypeFlatComboViewer(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.actions) {
              return createActionsAdvancedTableComposition(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.events) {
              return createEventsAdvancedTableComposition(parent);
            }
            if (key == ViewViewsRepository.ViewElement.Properties.description) {
              return createDescriptionText(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence methodStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        methodStep.addStep(EvidenceViewsRepository.Method.Properties.class);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.id);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.timing);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.custody);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.provenance);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.event);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.name);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.content);
    propertiesStep.addStep(EvidenceViewsRepository.Method.Properties.property);

    composer =
        new PartComposer(methodStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EvidenceViewsRepository.Method.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.id) {
              return createIdText(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.timing) {
              return createTimingAdvancedTableComposition(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.custody) {
              return createCustodyAdvancedTableComposition(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.provenance) {
              return createProvenanceAdvancedTableComposition(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.event) {
              return createEventAdvancedTableComposition(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.name) {
              return createNameText(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.content) {
              return createContentText(parent);
            }
            if (key == EvidenceViewsRepository.Method.Properties.property) {
              return createPropertyAdvancedTableComposition(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence eClassStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        eClassStep.addStep(EcoreViewsRepository.EClass.Properties.class);
    propertiesStep.addStep(EcoreViewsRepository.EClass.Properties.name);
    CompositionStep abstractionStep =
        propertiesStep.addStep(EcoreViewsRepository.EClass.Properties.Abstraction.class);
    abstractionStep.addStep(EcoreViewsRepository.EClass.Properties.Abstraction.abstract_);
    abstractionStep.addStep(EcoreViewsRepository.EClass.Properties.Abstraction.interface_);

    CompositionStep inheritanceStep =
        eClassStep.addStep(EcoreViewsRepository.EClass.Inheritance.class);
    inheritanceStep.addStep(EcoreViewsRepository.EClass.Inheritance.eSuperTypes);
    inheritanceStep.addStep(EcoreViewsRepository.EClass.Inheritance.eGenericSuperTypes);

    composer =
        new PartComposer(eClassStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EcoreViewsRepository.EClass.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Properties.Abstraction.class) {
              return createAbstractionHBox(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Properties.Abstraction.abstract_) {
              return createAbstract_Checkbox(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Properties.Abstraction.interface_) {
              return createInterface_Checkbox(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Inheritance.class) {
              return createInheritanceGroup(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Inheritance.eSuperTypes) {
              return createESuperTypesReferencesTable(widgetFactory, parent);
            }
            if (key == EcoreViewsRepository.EClass.Inheritance.eGenericSuperTypes) {
              return createEGenericSuperTypesTableComposition(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence transitionStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        transitionStep.addStep(GraalViewsRepository.Transition.Properties.class);
    propertiesStep.addStep(GraalViewsRepository.Transition.Properties.guard);
    propertiesStep.addStep(GraalViewsRepository.Transition.Properties.kind);
    propertiesStep.addStep(GraalViewsRepository.Transition.Properties.source);
    propertiesStep.addStep(GraalViewsRepository.Transition.Properties.target);
    propertiesStep.addStep(GraalViewsRepository.Transition.Properties.description);

    composer =
        new PartComposer(transitionStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == GraalViewsRepository.Transition.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == GraalViewsRepository.Transition.Properties.guard) {
              return createGuardText(parent);
            }
            if (key == GraalViewsRepository.Transition.Properties.kind) {
              return createKindEMFComboViewer(parent);
            }
            if (key == GraalViewsRepository.Transition.Properties.source) {
              return createSourceFlatComboViewer(parent);
            }
            if (key == GraalViewsRepository.Transition.Properties.target) {
              return createTargetFlatComboViewer(parent);
            }
            if (key == GraalViewsRepository.Transition.Properties.description) {
              return createDescriptionTextarea(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence flatReferenceTableSampleStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        flatReferenceTableSampleStep.addStep(
            EefnrViewsRepository.FlatReferenceTableSample.Properties.class);
    propertiesStep.addStep(
        EefnrViewsRepository.FlatReferenceTableSample.Properties
            .flatreferencetableRequiredProperty);
    propertiesStep.addStep(
        EefnrViewsRepository.FlatReferenceTableSample.Properties
            .flatreferencetableOptionalProperty);

    composer =
        new PartComposer(flatReferenceTableSampleStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EefnrViewsRepository.FlatReferenceTableSample.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key
                == EefnrViewsRepository.FlatReferenceTableSample.Properties
                    .flatreferencetableRequiredProperty) {
              return createFlatreferencetableRequiredPropertyFlatReferencesTable(parent);
            }
            if (key
                == EefnrViewsRepository.FlatReferenceTableSample.Properties
                    .flatreferencetableOptionalProperty) {
              return createFlatreferencetableOptionalPropertyFlatReferencesTable(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence hasRoleInStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        hasRoleInStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.class);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.id);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.timing);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.custody);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.provenance);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.event);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.role);
    propertiesStep.addStep(EvidenceViewsRepository.HasRoleIn.Properties.organization);

    composer =
        new PartComposer(hasRoleInStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.id) {
              return createIdText(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.timing) {
              return createTimingTableComposition(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.custody) {
              return createCustodyTableComposition(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.provenance) {
              return createProvenanceTableComposition(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.event) {
              return createEventTableComposition(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.role) {
              return createRoleText(widgetFactory, parent);
            }
            if (key == EvidenceViewsRepository.HasRoleIn.Properties.organization) {
              return createOrganizationFlatComboViewer(parent, widgetFactory);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence viewStateStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        viewStateStep.addStep(FlowViewsRepository.ViewState.Properties.class);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.name);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.actions);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.newInstance);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.refresh);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.viewContainers);
    propertiesStep.addStep(FlowViewsRepository.ViewState.Properties.description);

    composer =
        new PartComposer(viewStateStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == FlowViewsRepository.ViewState.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.name) {
              return createNameText(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.actions) {
              return createActionsTableComposition(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.newInstance) {
              return createNewInstanceCheckbox(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.refresh) {
              return createRefreshCheckbox(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.viewContainers) {
              return createViewContainersReferencesTable(widgetFactory, parent);
            }
            if (key == FlowViewsRepository.ViewState.Properties.description) {
              return createDescriptionText(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.ISWTPropertiesEditionPart#
   *     createControls(org.eclipse.swt.widgets.Composite)
   */
  public void createControls(Composite view) {
    CompositionSequence creationEventStep =
        new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        creationEventStep.addStep(UmlViewsRepository.CreationEvent.Properties.class);
    propertiesStep.addStep(UmlViewsRepository.CreationEvent.Properties.name);
    propertiesStep.addStep(UmlViewsRepository.CreationEvent.Properties.visibility);
    propertiesStep.addStep(UmlViewsRepository.CreationEvent.Properties.clientDependency);
    propertiesStep.addStep(UmlViewsRepository.CreationEvent.Properties.owningTemplateParameter);
    propertiesStep.addStep(UmlViewsRepository.CreationEvent.Properties.templateParameter);

    composer =
        new PartComposer(creationEventStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == UmlViewsRepository.CreationEvent.Properties.class) {
              return createPropertiesGroup(parent);
            }
            if (key == UmlViewsRepository.CreationEvent.Properties.name) {
              return createNameText(parent);
            }
            if (key == UmlViewsRepository.CreationEvent.Properties.visibility) {
              return createVisibilityEMFComboViewer(parent);
            }
            if (key == UmlViewsRepository.CreationEvent.Properties.clientDependency) {
              return createClientDependencyAdvancedReferencesTable(parent);
            }
            if (key == UmlViewsRepository.CreationEvent.Properties.owningTemplateParameter) {
              return createOwningTemplateParameterFlatComboViewer(parent);
            }
            if (key == UmlViewsRepository.CreationEvent.Properties.templateParameter) {
              return createTemplateParameterFlatComboViewer(parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }
  /**
   * {@inheritDoc}
   *
   * @see org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart#
   *     createControls(org.eclipse.ui.forms.widgets.FormToolkit, org.eclipse.swt.widgets.Composite)
   */
  public void createControls(final FormToolkit widgetFactory, Composite view) {
    CompositionSequence itemStep = new BindingCompositionSequence(propertiesEditionComponent);
    CompositionStep propertiesStep =
        itemStep.addStep(ChecklistViewsRepository.Item.Properties.class);
    propertiesStep.addStep(ChecklistViewsRepository.Item.Properties.identifier);
    propertiesStep.addStep(ChecklistViewsRepository.Item.Properties.description);
    propertiesStep.addStep(ChecklistViewsRepository.Item.Properties.reference);
    propertiesStep.addStep(ChecklistViewsRepository.Item.Properties.result);
    propertiesStep.addStep(ChecklistViewsRepository.Item.Properties.comment);

    composer =
        new PartComposer(itemStep) {

          @Override
          public Composite addToPart(Composite parent, Object key) {
            if (key == ChecklistViewsRepository.Item.Properties.class) {
              return createPropertiesGroup(widgetFactory, parent);
            }
            if (key == ChecklistViewsRepository.Item.Properties.identifier) {
              return createIdentifierText(widgetFactory, parent);
            }
            if (key == ChecklistViewsRepository.Item.Properties.description) {
              return createDescriptionText(widgetFactory, parent);
            }
            if (key == ChecklistViewsRepository.Item.Properties.reference) {
              return createReferenceText(widgetFactory, parent);
            }
            if (key == ChecklistViewsRepository.Item.Properties.result) {
              return createResultEMFComboViewer(widgetFactory, parent);
            }
            if (key == ChecklistViewsRepository.Item.Properties.comment) {
              return createCommentText(widgetFactory, parent);
            }
            return parent;
          }
        };
    composer.compose(view);
  }