// TODO : In some cases, we may have a filter based on both a UML Metaclass and a Stereotype
  // In such a specific case, a specific implementation is probably needed
  //
  // This case may especially occur in the case of dynamic creation of stereotype associations.
  @Override
  public Object getAdaptedValue(Object containerElement) {
    Object semanticElement = super.getAdaptedValue(containerElement);

    if (semanticElement instanceof Element) {
      Element element = (Element) semanticElement;
      // Looks for a compatible Stereotype application
      for (Object metaclassWanted : getWantedMetaclasses()) {

        if (metaclassWanted instanceof Stereotype) {
          EObject stereotypeApplication = null;

          stereotypeApplication = element.getStereotypeApplication((Stereotype) metaclassWanted);
          if (stereotypeApplication == null) {
            List<Stereotype> subStereotypes =
                element.getAppliedSubstereotypes((Stereotype) metaclassWanted);
            for (Stereotype subSteretoype : subStereotypes) {
              stereotypeApplication = element.getStereotypeApplication(subSteretoype);
              if (stereotypeApplication != null) {
                break;
              }
            }
          }

          if (stereotypeApplication != null) {
            return stereotypeApplication;
          }
        }
      }
    }

    // If no stereotype application is found, return the UML Element
    return semanticElement;
  }
  public Collection getAllModelElementsOfKind(Object nsa, Object type) {
    if (!(nsa instanceof Element)) {
      return new ArrayList<Element>();
    }
    Class theType = null;
    if (type instanceof String) {
      try {
        theType = Class.forName((String) type);
      } catch (ClassNotFoundException e) {
        throw new IllegalArgumentException(e);
      }
    } else if (type instanceof Class) {
      theType = (Class) type;
    } else {
      throw new IllegalArgumentException("type must be instance of Class or String"); // $NON-NLS-1$
    }
    if (!Element.class.isAssignableFrom(theType)) {
      throw new IllegalArgumentException("type must represent an Element"); // $NON-NLS-1$
    }

    Collection<Element> result = new ArrayList<Element>();

    for (Element element : ((Namespace) nsa).allOwnedElements()) {
      if (theType.isAssignableFrom(element.getClass())) {
        result.add(element);
      }
    }

    return result;
  }
 /**
  *
  * <!-- begin-user-doc -->
  * <!-- end-user-doc -->
  *
  * @generated
  */
 @Override
 public Element getOwner() {
   Element owner = basicGetOwner();
   return owner != null && owner.eIsProxy()
       ? (Element) eResolveProxy((InternalEObject) owner)
       : owner;
 }
  @Override
  protected boolean isCompatibleMetaclass(Object containerElement, Object metaclass) {
    Element semanticElement = UMLUtil.resolveUMLElement(containerElement);

    if (semanticElement == null) {
      return false;
    }

    if (metaclass instanceof Stereotype) {
      Stereotype stereotype = (Stereotype) metaclass;
      boolean res = semanticElement.getAppliedStereotype(stereotype.getQualifiedName()) != null;
      if (!res) {
        EClass definition = stereotype.getDefinition();
        for (EObject e : semanticElement.getStereotypeApplications()) {
          EClass c = e.eClass();
          if (definition != null && definition.isSuperTypeOf(c)) {
            res = true;
            break;
          }
        }
      }
      return res;
    }

    // TODO : We should use super.isCompatibleMetaclass(), but the super-implementation
    // may not be compatible with our implementation of getAdaptedValue()
    if (metaclass instanceof EClassifier) {
      return ((EClassifier) metaclass).isInstance(semanticElement);
    }

    return false;
  }
 /**
  * Returns the image for the element
  *
  * @param editPart the edit part that displays the element
  * @return the image
  */
 public Image getImage(GraphicalEditPart editPart) {
   Element element = getUMLElement(editPart);
   String key = "";
   if (element instanceof NamedElement) {
     key = ((NamedElement) element).getName() + "::" + ((NamedElement) element).getVisibility();
   } else if (element != null) {
     key = element.getClass().getName();
   } else {
     return null;
   }
   ImageRegistry imageRegistry = Activator.getDefault().getImageRegistry();
   Image image = imageRegistry.get(key);
   ImageDescriptor descriptor = null;
   if (image == null) {
     AdapterFactory factory = Activator.getDefault().getItemProvidersAdapterFactory();
     IItemLabelProvider labelProvider =
         (IItemLabelProvider) factory.adapt(getUMLElement(editPart), IItemLabelProvider.class);
     if (labelProvider != null) {
       descriptor =
           ExtendedImageRegistry.getInstance()
               .getImageDescriptor(labelProvider.getImage(getUMLElement(editPart)));
     }
     if (descriptor == null) {
       descriptor = ImageDescriptor.getMissingImageDescriptor();
     }
     imageRegistry.put(key, descriptor);
     image = imageRegistry.get(key);
   }
   return image;
 }
 private static void print(MessageSort messageSort, Element source, Element target) {
   StringBuffer buf = new StringBuffer();
   if (messageSort != null) {
     buf.append(messageSort.getName());
     buf.append("[");
   }
   buf.append("Source: ");
   if (source != null) {
     buf.append(source.eClass().getName());
     if (source instanceof NamedElement) {
       buf.append("(");
       buf.append(((NamedElement) source).getName());
       buf.append(")");
     }
   } else {
     buf.append("null");
   }
   buf.append(", Target: ");
   if (target != null) {
     buf.append(target.eClass().getName());
     if (target instanceof NamedElement) {
       buf.append("(");
       buf.append(((NamedElement) target).getName());
       buf.append(")");
     }
   } else {
     buf.append("null");
   }
   buf.append("]");
   System.out.println(new String(buf));
 }
  /**
   * Returns the name of the type with its qualified name
   *
   * @param type a type
   * @return the name of the type with its qualified name
   */
  public static String getTypeLabel(Type type, Namespace model) {
    String label = ""; // $NON-NLS-1$

    List<Package> importedPackages = new ArrayList<Package>(model.getImportedPackages());

    List<Package> visitedPackages = new ArrayList<Package>();
    Package currentPackage = type.getNearestPackage();

    boolean rootFound = false;

    while (currentPackage != null && !rootFound) {
      visitedPackages.add(currentPackage);
      if (importedPackages.contains(currentPackage) || currentPackage == model) {
        rootFound = true;
      }
      Element owner = currentPackage.getOwner();
      while (owner != null && !(owner instanceof Package)) owner = owner.getOwner();

      currentPackage = owner != null ? (Package) owner : null;
    }

    for (int i = visitedPackages.size() - 1; i >= 0; i--) {
      label += visitedPackages.get(i).getName() + "::"; // $NON-NLS-1$
    }

    return label + type.getName();
  }
예제 #8
0
  /**
   * Adds listeners on
   *
   * <ul>
   *   <li>Affixed Child Node
   *   <li>graphical parent, when its a {@link Property} (we add the listener on its Type)
   * </ul>
   */
  public void activate() {

    IGraphicalEditPart gep =
        (IGraphicalEditPart) getDecoratorTarget().getAdapter(IGraphicalEditPart.class);
    assert gep != null;
    View view = ((View) gep.getModel());

    if (view instanceof Node) {
      // the location of the decorator can change if it's an Affixed Child
      // Node
      if (isInherited((Node) view) && Util.isAffixedChildNode(gep)) {
        DiagramEventBroker.getInstance(gep.getEditingDomain())
            .addNotificationListener(gep.getNotationView(), notificationListener);
      }
    }

    // if the graphical parent is a Property, we add a listener on the type
    // of the property, to refresh the decoration
    EObject parent = view.eContainer();
    if (parent instanceof DecorationNode) {
      parent = parent.eContainer();
    }
    if (parent instanceof View) {
      EObject el = ((View) parent).getElement();
      if (el instanceof Property) {
        DiagramEventBroker.getInstance(gep.getEditingDomain())
            .addNotificationListener(
                el, UMLPackage.eINSTANCE.getTypedElement_Type(), notificationListener);
      }
    }

    /*
     * We listen the changes on the UML parent, in order to know if the
     * element is changing of parent Adding a listener using the following
     * EReference doesn't work UMLPackage.eINSTANCE.getElement_Owner();
     * UMLPackage.eINSTANCE.getProperty_Class();
     * UMLPackage.eINSTANCE.getNamedElement_Namespace(); that's why we
     * listen the parent
     */
    if (view.getElement() instanceof Element) {
      Element semanticElement = (Element) view.getElement();

      /*
       * We need add a listener only if the element is an element which
       * can be inherited, like Property, Operation, Signal, Classifier...
       */
      if (semanticElement != null && canBeInherited(semanticElement)) {
        // we listen if the container of the element changes!
        if (semanticElement.eContainer() != null) {
          DiagramEventBroker.getInstance(gep.getEditingDomain())
              .addNotificationListener(semanticElement.eContainer(), notificationListener);
        }
      }
    }
  }
 /**
  * Get all available root packages.
  *
  * @param element ELement
  * @return List of root packages
  */
 public List<Package> getAllAvailableRootPackages(Element element) {
   // <%script type="uml.Element" name="allAvailableRootPackages"%>
   // <%(getRootContainer().filter("Package") +
   // rootPackagesFromImportedModel).nMinimize()%>
   final List<Package> packages = Lists.newArrayList();
   packages.add(element.getModel());
   packages.addAll(
       Lists.newArrayList(
           Iterables.filter(element.getModel().getImportedPackages(), Model.class)));
   return packages;
 }
 @Override
 public void activate() {
   super.activate();
   // if stereotype has been applied, compartment has to be created
   final GraphicalEditPart editPart = (GraphicalEditPart) getHost();
   Element UMLEelement = (Element) editPart.resolveSemanticElement();
   Iterator<EObject> iterator = UMLEelement.getStereotypeApplications().iterator();
   while (iterator.hasNext()) {
     final EObject appliedstereotype = (EObject) iterator.next();
     createAppliedStereotypeCompartment(appliedstereotype);
   }
 }
 @Override
 public boolean select(Element e) {
   boolean isMapped =
       e.eResource().getResourceSet() instanceof IUIElementMapMap
           && ((IUIElementMapMap) e.eResource().getResourceSet()).getElementFor(e) != null;
   if (isMapped) {
     if (e instanceof TypedElement
         && e instanceof MultiplicityElement
         && ((TypedElement) e).getType() != null) {
       return EmfClassifierUtil.isPersistentComplexStructure(((TypedElement) e).getType());
     }
   }
   return false;
 }
  /**
   * @see
   *     org.eclipse.nebula.widgets.nattable.edit.gui.AbstractDialogCellEditor#createDialogInstance()
   * @return
   */
  @Override
  public Object createDialogInstance() {
    int columnIndex = this.layerCell.getColumnIndex();
    int rowIndex = this.layerCell.getRowIndex();
    Object row = this.manager.getRowElement(rowIndex);
    Object column = this.manager.getColumnElement(columnIndex);
    row = AxisUtils.getRepresentedElement(row);
    column = AxisUtils.getRepresentedElement(column);
    Element editedElement = null;
    Object feature = null;
    if (row instanceof EObject && column == this.axisElement) {
      editedElement = (Element) row;
      feature = column;
    } else {
      editedElement = (Element) column;
      feature = row;
    }

    EStructuralFeature realFeature = null;
    EObject realEditedObject = null;
    Stereotype stereotype = null;
    List<Stereotype> stereotypesWithEditedFeatureAppliedOnElement = null;
    if (feature instanceof EStructuralFeature) {
      realFeature = (EStructuralFeature) feature;
      realEditedObject = editedElement;
    } else {
      final String id = AxisUtils.getPropertyId(this.axisElement);
      stereotypesWithEditedFeatureAppliedOnElement =
          UMLTableUtils.getAppliedSteretoypesWithThisProperty(editedElement, id);
      stereotype = stereotypesWithEditedFeatureAppliedOnElement.get(0);
      realEditedObject =
          editedElement.getStereotypeApplication(
              stereotypesWithEditedFeatureAppliedOnElement.get(0));
      Property prop = UMLTableUtils.getRealStereotypeProperty(editedElement, id);
      realFeature = realEditedObject.eClass().getEStructuralFeature(prop.getName());
    }
    if (stereotypesWithEditedFeatureAppliedOnElement != null
        && stereotypesWithEditedFeatureAppliedOnElement.size() > 1) {
      // FIXME : not yet managed
    } else {
      this.dialog =
          createDialog(
              realEditedObject,
              realFeature,
              stereotype,
              editedElement.eResource().getResourceSet());
    }
    return this.dialog;
  }
예제 #13
0
  /** @generated */
  protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info)
      throws ExecutionException {

    Comment newElement = UMLFactory.eINSTANCE.createComment();

    Element owner = (Element) getElementToEdit();
    owner.getOwnedComments().add(newElement);

    ElementInitializers.getInstance().init_Comment_2109(newElement);

    doConfigure(newElement, monitor, info);

    ((CreateElementRequest) getRequest()).setNewElement(newElement);
    return CommandResult.newOKCommandResult(newElement);
  }
 /**
  * return the root package from an element
  *
  * @param elem the element
  * @return the root package
  */
 protected org.eclipse.uml2.uml.Package getToPackage(Element elem) {
   org.eclipse.uml2.uml.Package tmp = elem.getNearestPackage();
   while (tmp.getOwner() != null && (tmp.getOwner() instanceof Package)) {
     tmp = (org.eclipse.uml2.uml.Package) tmp.getOwner();
   }
   return tmp;
 }
  /**
   * @see
   *     org.eclipse.gmf.runtime.diagram.core.listener.NotificationListener#notifyChanged(org.eclipse.emf.common.notify.Notification)
   * @param notification
   */
  public void notifyChanged(Notification notification) {
    Object feature = notification.getFeature();
    boolean headChanged = false;
    if (NotationPackage.eINSTANCE.getFontStyle_FontHeight().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_FontName().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_Bold().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_Italic().equals(feature)) {
      headChanged = true;
    } else if (notification.getNotifier() instanceof EAnnotation
        && UMLVisualInformationPapyrusConstant.STEREOTYPE_ANNOTATION
            == ((EAnnotation) notification.getNotifier()).getSource()) {
      headChanged = true;
    } else if ((notification.getNotifier() instanceof DynamicEObjectImpl)
        && (hostSemanticElement != null)
        && (hostSemanticElement.getStereotypeApplications().contains(notification.getNotifier()))) {
      headChanged = true;
    } else if (PapyrusStereotypeListener.MODIFIED_STEREOTYPE == notification.getEventType()) {
      headChanged = true;
    } else if (notification instanceof StereotypeCustomNotification) {
      headChanged = true;
    }
    if (headChanged) {
      Display.getDefault()
          .asyncExec(
              new Runnable() {

                public void run() {
                  impactLayout();
                }
              });
    }
  }
예제 #16
0
  /**
   * this method returns the icon image that represents the first applied stereotype.
   *
   * @param element the stereotyped element
   * @return {@link image} of the icon
   */
  public static Image getIconElement(Element element, boolean withVisibilityDecorator) {

    List<Stereotype> stereotypeList = element.getAppliedStereotypes();
    if (stereotypeList == null || stereotypeList.isEmpty()) {
      return null;
    }
    return getIconElement(element, stereotypeList.get(0), withVisibilityDecorator);
  }
  /**
   * Default Constructor.
   *
   * @param parentShell the parent shell
   * @param theElement the UML element to be modified
   */
  public ChooseSetStereotypeDialog(Shell parentShell, org.eclipse.uml2.uml.Element theElement) {
    super(parentShell, "Applicable Stereotypes: ", "Applied Stereotypes: ");
    labelProvider = new StereotypeLabelProvider();
    decoratedContentProposalProvider = new StereotypeContentProposalProvider();

    Iterator<Stereotype> stereotypes = theElement.getAppliedStereotypes().iterator();
    while (stereotypes.hasNext()) {
      selectedElementList.addElement(stereotypes.next());
    }

    stereotypes = theElement.getApplicableStereotypes().iterator();
    while (stereotypes.hasNext()) {
      Stereotype current = stereotypes.next();
      if (!selectedElementList.contains(current)) {
        possibleElementList.addElement(current);
      }
    }
  }
 protected String getStereotype(Element element) {
   final List stereotypes = element.getAppliedStereotypes();
   if (stereotypes != null && stereotypes.size() != 0) {
     final StringBuffer sb = new StringBuffer();
     appendStereotype(element, sb, false);
     return sb.toString();
   }
   return CoreStringUtil.Constants.EMPTY_STRING;
 }
예제 #19
0
 public static String getDocumentationText(Element umlElement) {
   if (!umlElement.getOwnedComments().isEmpty()) {
     return umlElement.getOwnedComments().get(0).getBody();
   }
   EAnnotation topcasedDocAnnotation =
       umlElement.getEAnnotation("http://www.topcased.org/documentation");
   if (topcasedDocAnnotation != null) {
     return topcasedDocAnnotation.getDetails().get("documentation");
   }
   for (EObject obj :
       EcoreUtil2.findAllByType(umlElement.getModel().eAllContents(), Comment.class)) {
     Comment c = (Comment) obj;
     for (EObject annotatedObject : c.getAnnotatedElements()) {
       if (annotatedObject == umlElement) {
         return c.getBody();
       }
     }
   }
   return null;
 }
예제 #20
0
  public void ProcessComments(org.eclipse.uml2.uml.Element e1) {
    RefOntoUML.Element e2 = GetElement(e1);

    // ownedComment
    RefOntoUML.Comment c2;
    for (org.eclipse.uml2.uml.Comment c1 : e1.getOwnedComments()) {
      c2 = myfactory.createComment();
      DealComment(c1, c2);

      e2.getOwnedComment().add(c2);
    }
  }
예제 #21
0
 /** As its name says, retrieves the output ports for a given element. */
 public static List<org.eclipse.uml2.uml.Port> getOutputPortsForElement(Element elt) {
   LinkedList<org.eclipse.uml2.uml.Port> found_output_ports =
       new LinkedList<org.eclipse.uml2.uml.Port>();
   for (Element child : elt.getOwnedElements()) {
     if (child instanceof org.eclipse.uml2.uml.Port) {
       if (isAnOutputPort((org.eclipse.uml2.uml.Port) child)) {
         found_output_ports.add((org.eclipse.uml2.uml.Port) child);
       }
     }
   }
   return found_output_ports;
 }
예제 #22
0
 /** As its name says, retrieves the input ports for a given element. */
 public static List<Port> getInputPortsForElement(Element elt) {
   LinkedList<Port> found_input_ports = new LinkedList<org.eclipse.uml2.uml.Port>();
   for (Element child : elt.getOwnedElements()) {
     if (child instanceof NamedElement && child instanceof org.eclipse.uml2.uml.Port) {
       if (isAnInputPort((org.eclipse.uml2.uml.Port) child)) {
         Port found_port = (org.eclipse.uml2.uml.Port) child;
         found_input_ports.add(found_port);
       }
     }
   }
   return found_input_ports;
 }
예제 #23
0
 /**
  * return the top-level owner of an element. This function returns the same value as getModel, if
  * the top-level element is a model. While this is the case for models, model libraries have a
  * top-level package (not a model). In this case, getTop returns the top-level package whereas
  * getModel would return null.
  *
  * @param element
  * @return the top-level owning package
  */
 public static Package getTop(Element element) {
   while (element != null) {
     Element owner = element.getOwner();
     if (owner == null) {
       if (element instanceof Package) {
         return (Package) element;
       }
     }
     element = owner;
   }
   return null;
 }
예제 #24
0
  /** Removes the listeners and the decorations */
  public void deactivate() {
    removeDecoration();

    IGraphicalEditPart gep =
        (IGraphicalEditPart) getDecoratorTarget().getAdapter(IGraphicalEditPart.class);
    assert gep != null;
    DiagramEventBroker.getInstance(gep.getEditingDomain())
        .removeNotificationListener(gep.getNotationView(), notificationListener);
    View view = ((View) gep.getModel());

    if (view instanceof Node) {
      // the location of the decorator can change if it's an Affixed Child
      // Node
      if (isInherited((Node) view) && Util.isAffixedChildNode(gep)) {
        DiagramEventBroker.getInstance(gep.getEditingDomain())
            .removeNotificationListener(gep.getNotationView(), notificationListener);
      }
    }
    EObject parent = view.eContainer();
    if (parent instanceof View) {
      EObject el = ((View) parent).getElement();
      if (el instanceof Property) {
        DiagramEventBroker.getInstance(gep.getEditingDomain())
            .removeNotificationListener(
                el, UMLPackage.eINSTANCE.getTypedElement_Type(), notificationListener);
      }
    }

    if (view.getElement() instanceof Element) {
      Element semanticElement = (Element) view.getElement();
      if (semanticElement != null) {
        if (semanticElement.eContainer() != null) {
          DiagramEventBroker.getInstance(gep.getEditingDomain())
              .addNotificationListener(semanticElement.eContainer(), notificationListener);
        }
      }
    }
  }
예제 #25
0
 /** @generated */
 protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info)
     throws ExecutionException {
   Comment newElement = UMLFactory.eINSTANCE.createComment();
   EObject target = getElementToEdit();
   ModelAddData data = PolicyChecker.getCurrent().getChildAddData(diagram, target, newElement);
   if (data.isPermitted()) {
     if (data.isPathDefined()) {
       if (!data.execute(target, newElement))
         return CommandResult.newErrorCommandResult(
             "Failed to follow the policy-specified for the insertion of the new element");
     } else {
       Element qualifiedTarget = (Element) target;
       qualifiedTarget.getOwnedComments().add(newElement);
     }
   } else {
     return CommandResult.newErrorCommandResult(
         "The active policy restricts the addition of this element");
   }
   ElementInitializers.getInstance().init_Comment_3201(newElement);
   doConfigure(newElement, monitor, info);
   ((CreateElementRequest) getRequest()).setNewElement(newElement);
   return CommandResult.newOKCommandResult(newElement);
 }
  @Override
  public String stereotypesOnlyToDisplay() {
    Object hostModel = getHost().getModel();
    String result = ""; // $NON-NLS-1$
    View view = (View) hostModel;
    EObject viewElement = view.getElement();
    Element element = (Element) viewElement;
    Iterator<Stereotype> listStereotype = element.getAppliedStereotypes().iterator();
    StringBuffer buffer = new StringBuffer();
    while (listStereotype.hasNext()) {
      Stereotype stereotypec = listStereotype.next();
      String stereotype_string = stereotypec.getQualifiedName();
      buffer.append(stereotype_string);
      if (listStereotype.hasNext()) {
        buffer.append(","); // $NON-NLS-1$
      }
    }
    result = buffer.toString();

    if (result.length() != 0) {
      String stereotypespresentationKind =
          AppliedStereotypeHelper.getAppliedStereotypePresentationKind(view);

      // vertical representation
      if (UMLVisualInformationPapyrusConstant.STEREOTYPE_TEXT_VERTICAL_PRESENTATION.equals(
          stereotypespresentationKind)) {
        return Activator.ST_LEFT
            + stereotypesToDisplay(Activator.ST_RIGHT + "\n" + Activator.ST_LEFT, result, "")
            + Activator.ST_RIGHT;
      } else { // horizontal representation
        return Activator.ST_LEFT + stereotypesToDisplay(", ", result, "") + Activator.ST_RIGHT;
      }
    }

    return result;
  }
 /** {@inheritDoc} */
 public void deactivate() {
   // retrieve the view and the element managed by the edit part
   View view = getView();
   if (view == null) {
     return;
   }
   getDiagramEventBroker().removeNotificationListener(view, this);
   if (hostSemanticElement == null) {
     return;
   }
   // remove listeners to applied stereotyped
   for (EObject stereotypeApplication : hostSemanticElement.getStereotypeApplications()) {
     getDiagramEventBroker().removeNotificationListener(stereotypeApplication, this);
   }
   // remove notification on element
   getDiagramEventBroker().removeNotificationListener(hostSemanticElement, this);
   // removes the reference to the semantic element
   hostSemanticElement = null;
 }
 public void activate() {
   // retrieve the view and the element managed by the edit part
   View view = getView();
   if (view == null) {
     return;
   }
   hostSemanticElement = getUMLElement();
   // adds a listener on the view and the element controlled by the
   // editpart
   getDiagramEventBroker().addNotificationListener(view, this);
   if (hostSemanticElement == null) {
     return;
   }
   getDiagramEventBroker().addNotificationListener(hostSemanticElement, this);
   // adds the listener for stereotype application and applied stereotypes
   // add listener to react to the application and remove of a stereotype
   // add a lister to each already applied stereotyped
   for (EObject stereotypeApplication : hostSemanticElement.getStereotypeApplications()) {
     getDiagramEventBroker().addNotificationListener(stereotypeApplication, this);
   }
   currentHeadHeight = getHeadHeight();
 }
 protected void appendStereotype(
     final Element element, final StringBuffer sb, final boolean includeWrappers) {
   boolean first = true;
   final List stereotypes = element.getAppliedStereotypes();
   if (stereotypes.isEmpty()) {
     return;
   }
   if (includeWrappers) {
     sb.append("<<"); // $NON-NLS-1$
   }
   final Iterator iter = stereotypes.iterator();
   while (iter.hasNext()) {
     final Stereotype stereotype = (Stereotype) iter.next();
     if (!first) {
       sb.append(","); // $NON-NLS-1$
     }
     first = false;
     sb.append(stereotype.getName());
   }
   if (includeWrappers) {
     sb.append(">>"); // $NON-NLS-1$
   }
 }
예제 #30
0
 @Override
 public void undo() {
   for (Stereotype stereotype : stereotypes) {
     element.unapplyStereotype(stereotype);
   }
 }