public override void ElementDeleted(ElementDeletedEventArgs e)
{
DataContractBaseCanBeContainedOnContracts link = e.ModelElement as DataContractBaseCanBeContainedOnContracts;
Debug.Assert(link != null, "link != null");
DataContractBase sourceDataContractBase = link.DataContractBase;
Contract targetContractElement = link.Contract;
if (targetContractElement is DataContract)
{
DataContract dataContractElement = targetContractElement as DataContract;
RemoveDataElement(
dataContractElement.Store,
dataContractElement.DataMembers,
GetDataElement(dataContractElement.DataMembers, link.Id));
}
else if (targetContractElement is FaultContract)
{
FaultContract faultContractElement = targetContractElement as FaultContract;
RemoveDataElement(
faultContractElement.Store,
faultContractElement.DataMembers,
GetDataElement(faultContractElement.DataMembers, link.Id));
}
base.ElementDeleted(e);
}
/// <summary>
/// </summary>
/// <param name="e">Provides data for the ElementDeleted event.</param>
public override void ElementDeleted(ElementDeletedEventArgs e)
{
// Test the element
ParentShapeContainsNestedChildShapes link = e.ModelElement as ParentShapeContainsNestedChildShapes;
if (link == null)
{
return;
}
SoftwareComponentShape shape = link.ParentShape as SoftwareComponentShape;
if (shape != null)
{
shape.ArrangeShapes();
}
else if (link.NestedChildShapes.ModelElement is Layer)
{
LayerPackageShape shape2 = link.ParentShape as LayerPackageShape;
if (shape2 != null)
{
shape2.ArrangeShapes();
}
}
}
/// <summary>
/// DeleteRule: typeof(DiagramDisplayHasDiagramOrder), FireTime=LocalCommit, Priority=FrameworkDomainModel.BeforeDelayValidateRulePriority;
/// Make sure that deletion of a diagram order results in a reorder
/// </summary>
private static void DiagramOrderDeletedRule(ElementDeletedEventArgs e)
{
DiagramDisplayHasDiagramOrder link = (DiagramDisplayHasDiagramOrder)e.ModelElement;
Diagram diagram = link.Diagram;
if (!diagram.IsDeleted)
{
Store store = diagram.Store;
if (diagram.Partition == store.DefaultPartition) // This should never happen, but it is easy to check
{
if (null == DiagramDisplayHasDiagramOrder.GetDiagramDisplay(diagram))
{
DiagramDisplay displayContainer = link.DiagramDisplay;
if (displayContainer.IsDeleted)
{
ReadOnlyCollection <DiagramDisplay> displays = store.ElementDirectory.FindElements <DiagramDisplay>(false);
displayContainer = (displays.Count != 0) ? displays[0] : new DiagramDisplay(store);
}
new DiagramDisplayHasDiagramOrder(displayContainer, diagram);
}
}
}
else
{
DiagramDisplay displayContainer = link.DiagramDisplay;
if (!displayContainer.IsDeleted && displayContainer.OrderedDiagramCollection.Count == 0)
{
// No more diagrams, don't need the container
displayContainer.Delete();
}
}
}
/// <summary>
/// Called whenever a model element is deleted from the store.
/// </summary>
/// <param name="sender">ViewModelStore</param>
/// <param name="args">Event Arguments for notification of the removal of an ModelElement.</param>
private void OnElementDeleted(object sender, ElementDeletedEventArgs args)
{
if (args.ModelElement is DomainModelElement)
{
DomainModelElement modelElement = args.ModelElement as DomainModelElement;
List <Guid> shapes = GraphicalDependencyShapeStore.GetFromStore(modelElement.Id);
if (shapes != null)
{
if (shapes.Count > 0)
{
modelElement.Store.UndoManager.UndoState = UndoState.DisabledNoFlush;
using (Transaction t = modelElement.Store.TransactionManager.BeginTransaction("", true))
{
for (int i = shapes.Count - 1; i >= 0; i--)
{
ShapeElement shape = modelElement.Store.ElementDirectory.FindElement(shapes[i]) as ShapeElement;
if (shape != null)
{
shape.Delete();
}
}
t.Commit();
}
modelElement.Store.UndoManager.UndoState = UndoState.Enabled;
GraphicalDependencyShapeStore.RemoveFromStore(modelElement.Id);
}
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
Transition transition = (Transition)e.ModelElement;
if (!transition.Successor.IsDeleted && transition.Successor.Predecessors.Count == 0
&& !transition.Store.TransactionManager.CurrentTransaction.IsSerializing)
transition.Successor.Initial = true;
}
/// <summary>
/// Called whenever a model element is deleted from the store.
/// </summary>
/// <param name="sender">ViewModelStore</param>
/// <param name="args">Event Arguments for notification of the removal of an ModelElement.</param>
protected virtual void OnElementDeleted(object sender, ElementDeletedEventArgs args)
{
EventManager.GetEvent<ModelElementDeletedEvent>().Publish(args);
if( args.ModelElement is ElementLink )
EventManager.GetEvent<ModelElementLinkDeletedEvent>().Publish(args);
}
/// <summary>
/// Called whenever a model element is deleted from the store.
/// </summary>
/// <param name="sender">ViewModelStore</param>
/// <param name="args">Event Arguments for notification of the removal of an ModelElement.</param>
private void OnElementDeleted(object sender, ElementDeletedEventArgs args)
{
if (args.ModelElement is DomainModelElement)
{
DomainModelElement modelElement = args.ModelElement as DomainModelElement;
List<Guid> shapes = GraphicalDependencyShapeStore.GetFromStore(modelElement.Id);
if (shapes != null)
if (shapes.Count > 0)
{
modelElement.Store.UndoManager.UndoState = UndoState.DisabledNoFlush;
using (Transaction t = modelElement.Store.TransactionManager.BeginTransaction("", true))
{
for (int i = shapes.Count - 1; i >= 0; i--)
{
ShapeElement shape = modelElement.Store.ElementDirectory.FindElement(shapes[i]) as ShapeElement;
if (shape != null)
shape.Delete();
}
t.Commit();
}
modelElement.Store.UndoManager.UndoState = UndoState.Enabled;
GraphicalDependencyShapeStore.RemoveFromStore(modelElement.Id);
}
}
}
public void OnModelPropertyDeleted(ElementDeletedEventArgs e)
{
if (ModelPropertyDeleted != null)
{
ModelPropertyDeleted(e);
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
var inheritance = e.ModelElement as Inheritance;
if (inheritance != null)
{
if (inheritance.TargetEntityType != null)
{
// We need to invalidate the target entitytypeshape element; so base type name will be updated correctly.
foreach (var pe in PresentationViewsSubject.GetPresentation(inheritance.TargetEntityType))
{
var entityShape = pe as EntityTypeShape;
if (entityShape != null)
{
entityShape.Invalidate();
}
}
}
var tx = ModelUtils.GetCurrentTx(inheritance.Store);
Debug.Assert(tx != null);
if (tx != null &&
!tx.IsSerializing)
{
ViewModelChangeContext.GetNewOrExistingContext(tx).ViewModelChanges.Add(new InheritanceDelete(inheritance));
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
var inheritance = e.ModelElement as Inheritance;
if (inheritance != null)
{
if (inheritance.TargetEntityType != null)
{
// We need to invalidate the target entitytypeshape element; so base type name will be updated correctly.
foreach (var pe in PresentationViewsSubject.GetPresentation(inheritance.TargetEntityType))
{
var entityShape = pe as EntityTypeShape;
if (entityShape != null)
{
entityShape.Invalidate();
}
}
}
var tx = ModelUtils.GetCurrentTx(inheritance.Store);
Debug.Assert(tx != null);
if (tx != null
&& !tx.IsSerializing)
{
ViewModelChangeContext.GetNewOrExistingContext(tx).ViewModelChanges.Add(new InheritanceDelete(inheritance));
}
}
}
/// <summary>
/// DeleteRule: typeof(ORMSolutions.ORMArchitect.Core.ObjectModel.ExclusiveOrConstraintCoupler), FireTime=TopLevelCommit, Priority=DiagramFixupConstants.AddShapeRulePriority;
/// Split a single shape into two shapes when a exclusion constraint
/// is decoupled from a mandatory constraint
/// </summary>
private static void ExclusiveOrCouplerDeletedRule(ElementDeletedEventArgs e)
{
ExclusiveOrConstraintCoupler link = e.ModelElement as ExclusiveOrConstraintCoupler;
MandatoryConstraint mandatory = link.MandatoryConstraint;
ExclusionConstraint exclusion = link.ExclusionConstraint;
if (!mandatory.IsDeleted && !exclusion.IsDeleted)
{
LinkedElementCollection <PresentationElement> pels = PresentationViewsSubject.GetPresentation(mandatory);
int pelCount = pels.Count;
for (int i = 0; i < pelCount; ++i)
{
ExternalConstraintShape shape = pels[i] as ExternalConstraintShape;
if (shape != null)
{
ORMDiagram diagram = (ORMDiagram)shape.Diagram;
RectangleD bounds = shape.AbsoluteBounds;
double width = bounds.Width;
bounds.Offset(-width / 2, 0);
bounds = diagram.BoundsRules.GetCompliantBounds(shape, bounds);
shape.AbsoluteBounds = bounds;
bounds.Offset(width, 0);
diagram.PlaceORMElementOnDiagram(null, exclusion, bounds.Location, ORMPlacementOption.None, null, null);
}
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
DataContractBaseCanBeContainedOnContracts link = e.ModelElement as DataContractBaseCanBeContainedOnContracts;
Debug.Assert(link != null, "link != null");
DataContractBase sourceDataContractBase = link.DataContractBase;
Contract targetContractElement = link.Contract;
if(targetContractElement is DataContract)
{
DataContract dataContractElement = targetContractElement as DataContract;
RemoveDataElement(
dataContractElement.Store,
dataContractElement.DataMembers,
GetDataElement(dataContractElement.DataMembers, link.Id));
}
else if(targetContractElement is FaultContract)
{
FaultContract faultContractElement = targetContractElement as FaultContract;
RemoveDataElement(
faultContractElement.Store,
faultContractElement.DataMembers,
GetDataElement(faultContractElement.DataMembers, link.Id));
}
base.ElementDeleted(e);
}
/// <summary>
/// Called whenever a relationship of type ReferenceRSNodeReferencesShapeRelationshipNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnShapeNodeRemoved(ElementDeletedEventArgs args)
{
ReferenceRSNodeReferencesShapeRelationshipNodes con = args.ModelElement as ReferenceRSNodeReferencesShapeRelationshipNodes;
if (con != null)
{
DeleteShapeNode(con.ShapeRelationshipNode);
}
}
/// <summary>
/// Called whenever a relationship of type ReferenceRSNodeReferencesReferenceNode is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnReferenceNodeRemoved(ElementDeletedEventArgs args)
{
ReferenceRSNodeReferencesReferenceNode con = args.ModelElement as ReferenceRSNodeReferencesReferenceNode;
if (con != null)
{
DeleteReferenceNode(con.ReferenceNode);
}
}
/// <summary>
/// Called whenever a relationship of type SpecificElementsDiagramReferencesDomainClasses is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnReferenceRemoved(ElementDeletedEventArgs args)
{
SpecificElementsDiagramReferencesDomainClasses con = args.ModelElement as SpecificElementsDiagramReferencesDomainClasses;
if (con != null)
{
RemoveReference(con.DomainClass);
}
}
/// <summary>
/// Called whenever a model element is deleted from the store.
/// </summary>
/// <param name="sender">ViewModelStore</param>
/// <param name="args">Event Arguments for notification of the removal of an ModelElement.</param>
protected virtual void OnElementDeleted(object sender, ElementDeletedEventArgs args)
{
EventManager.GetEvent <ModelElementDeletedEvent>().Publish(args);
if (args.ModelElement is ElementLink)
{
EventManager.GetEvent <ModelElementLinkDeletedEvent>().Publish(args);
}
}
/// <summary>
/// Called whenever a relationship of type AttributedDomainElementHasProperties is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnDomainPropertyRemoved(ElementDeletedEventArgs args)
{
AttributedDomainElementHasProperties con = args.ModelElement as AttributedDomainElementHasProperties;
if (con != null)
{
DeleteProperty(con.DomainProperty);
}
}
/// <summary>
/// DeleteRule: typeof(ConstraintRoleSequenceHasRole)
/// </summary>
private static void ConstraintRoleSequenceHasRoleDeletedRule(ElementDeletedEventArgs e)
{
FactType factType = (e.ModelElement as ConstraintRoleSequenceHasRole).Role.FactType;
if (factType != null && !factType.IsDeleted)
{
FrameworkDomainModel.DelayValidateElement(factType, DelayValidateUnaryBinarization);
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
InterfaceInheritInterfaces link = e.ModelElement as InterfaceInheritInterfaces;
if (link != null)
{
RemoveTypedEntitySetConnectionFromNavigationProperties(link);
}
}
/// <summary>
/// Called whenever a relationship of type DesignerDiagramClassReferencesDiagramClasses is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnImportedDCRemoved(ElementDeletedEventArgs args)
{
DesignerDiagramClassReferencesImportedDiagramClasses con = args.ModelElement as DesignerDiagramClassReferencesImportedDiagramClasses;
if (con != null)
{
DeleteImportedDC(con);
}
}
/// <summary>
/// Called whenever a relationship of type DiagramClassViewHasRootDiagramNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnRootDiagramNodeRemoved(ElementDeletedEventArgs args)
{
DiagramClassViewHasRootDiagramNodes con = args.ModelElement as DiagramClassViewHasRootDiagramNodes;
if (con != null)
{
DeleteRootDiagramNode(con.RootDiagramNode);
}
}
private void OnChildElementDeleted(ElementDeletedEventArgs args)
{
ElementLink relationship = args.ModelElement as ElementLink;
if (DomainRoleInfo.GetSourceRolePlayer(relationship) == Element)
{
RemoveChildElement(DomainRoleInfo.GetTargetRolePlayer(relationship));
}
}
/// <summary>
/// Called whenever a relationship of type SerializationClassReferencesChildren is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnChildRemoved(ElementDeletedEventArgs args)
{
SerializationClassReferencesChildren con = args.ModelElement as SerializationClassReferencesChildren;
if (con != null)
{
DeleteChild(con.Child);
}
}
/// <summary>
/// Called whenever a relationship of type MetaModelHasModelContexts is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnModelContextRemoved(ElementDeletedEventArgs args)
{
MetaModelHasModelContexts con = args.ModelElement as MetaModelHasModelContexts;
if (con != null)
{
DeleteModelContext(con.BaseModelContext);
}
}
/// <summary>
/// Called whenever a relationship of type SerializationClassReferencesAttributes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnAttributeRemoved(ElementDeletedEventArgs args)
{
SerializationClassReferencesAttributes con = args.ModelElement as SerializationClassReferencesAttributes;
if (con != null)
{
DeleteAttribute(con.Child);
}
}
/// <summary>
/// Called whenever a relationship of type RelationshipShapeClassReferencesReferenceRelationship is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnRSShapeElementRemoved(ElementDeletedEventArgs args)
{
RelationshipShapeClassReferencesReferenceRelationship con = args.ModelElement as RelationshipShapeClassReferencesReferenceRelationship;
if (con != null)
{
DeleteElement();
}
}
/// <summary>
/// Called whenever a relationship of type DiagramClassViewHasRootDiagramNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnReferenceRemoved(ElementDeletedEventArgs args)
{
ModalDiagramReferencesDomainClass con = args.ModelElement as ModalDiagramReferencesDomainClass;
if (con != null)
{
RemoveReference(con.DomainClass);
}
}
/// <summary>
/// Called whenever a relationship of type EmbeddingDiagramNodeHasEmbeddingDiagramNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnEmbeddingDiagramNodeRemoved(ElementDeletedEventArgs args)
{
EmbeddingDiagramNodeHasEmbeddingDiagramNodes con = args.ModelElement as EmbeddingDiagramNodeHasEmbeddingDiagramNodes;
if (con != null)
{
DeleteEmbeddingDiagramNode(con.TargetEmbeddingDiagramNode);
}
}
/// <summary>
/// Called whenever a relationship of type SerializationModelHasChildren is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args">Arguments.</param>
protected virtual void OnChildRemoved(ElementDeletedEventArgs args)
{
SerializationModelHasChildren con = args.ModelElement as SerializationModelHasChildren;
if (con != null)
{
DeleteChild(con.SerializationClass);
}
}
/// <summary>
/// Called whenever a relationship of type EmbeddingRSNodeReferencesEmbeddingNode is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnEmbeddingNodeRemoved(ElementDeletedEventArgs args)
{
EmbeddingRSNodeReferencesEmbeddingNode con = args.ModelElement as EmbeddingRSNodeReferencesEmbeddingNode;
if (con != null)
{
DeleteEmbeddingNode(con.EmbeddingNode);
}
}
/// <summary>
/// DeleteRule: typeof(UniquenessConstraintIsForUniqueness)
/// Propagate deletion of a Uniqueness
/// </summary>
private static void UniquenessDeletedRule(ElementDeletedEventArgs e)
{
UniquenessConstraint constraint = ((UniquenessConstraintIsForUniqueness)e.ModelElement).UniquenessConstraint;
if (!constraint.IsDeleted)
{
constraint.Delete();
}
}
/// <summary>
/// DeleteRule: typeof(ORMSolutions.ORMArchitect.Core.ObjectModel.FactTypeHasReadingOrder)
/// </summary>
private static void ReadingOrderDeletedRule(ElementDeletedEventArgs e)
{
FactType factType;
if (!(factType = ((FactTypeHasReadingOrder)e.ModelElement).FactType).IsDeleted)
{
FrameworkDomainModel.DelayValidateElement(factType, UpdateChildNamesForFactTypeDelayed);
}
}
/// <summary>
/// Called whenever a relationship of type ShapeClassReferencesDomainClass is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnShapeElementRemoved(ElementDeletedEventArgs args)
{
ShapeClassReferencesDomainClass con = args.ModelElement as ShapeClassReferencesDomainClass;
if (con != null)
{
DeleteElement();
}
}
/// <summary>
/// Called whenever a relationship of type ExternModelContextReferencesModelContext is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args">Arguments.</param>
protected virtual void OnModelContextRemoved(ElementDeletedEventArgs args)
{
ExternModelContextReferencesModelContext con = args.ModelElement as ExternModelContextReferencesModelContext;
if (con != null)
{
DeleteModelContext(con.ModelContext);
}
}
/// <summary>
/// DeleteRule: typeof(InformationTypeFormatIsForValueType)
/// </summary>
private static void InformationTypeFormatBridgeDetachedRule(ElementDeletedEventArgs e)
{
InformationTypeFormat format = ((InformationTypeFormatIsForValueType)e.ModelElement).InformationTypeFormat;
if (!format.IsDeleted &&
TestRebuildAbstractionModel(format.Model))
{
AddTransactedModelElement(format, ModelElementModification.AbstractionElementDetached);
}
}
/// <summary>
/// Called whenever a child element is deleted.
/// </summary>
/// <param name="e"></param>
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
DiagramHasChildren con = e.ModelElement as DiagramHasChildren;
if (con != null)
{
NodeShape nodeShape = con.ChildShape;
Diagram diagram = con.Diagram;
if (nodeShape != null && diagram != null)
{
diagram.RemoveFromShapeMapping(nodeShape);
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
ShapeElementContainsChildShapes con = e.ModelElement as ShapeElementContainsChildShapes;
if (con != null)
{
NodeShape childShape = con.ChildShape;
NodeShape parentShape = con.ParentShape;
if (childShape != null && parentShape != null)
{
parentShape.RemoveFromShapeMapping(childShape);
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
var associationConnector = e.ModelElement as AssociationConnector;
if (associationConnector != null)
{
var tx = ModelUtils.GetCurrentTx(associationConnector.Store);
Debug.Assert(tx != null);
if (tx != null
&& !tx.IsSerializing)
{
ViewModelChangeContext.GetNewOrExistingContext(tx)
.ViewModelChanges.Add(new AssociationConnectorDelete(associationConnector));
}
}
}
private void OnElementDeleted(ElementDeletedEventArgs args)
{
if (this.SelectedSpecificItemVM != null)
if (this.SelectedSpecificItemVM.Element.Id == args.ElementId)
this.SelectedSpecificItemVM = null;
for (int i = SpecificItemVMs.Count - 1; i >= 0; i--)
{
if (SpecificItemVMs[i].Element.Id == args.ElementId)
{
SpecificItemVMs[i].Dispose();
SpecificItemVMs.RemoveAt(i);
}
}
UpdateIndices();
}
/// <summary>
/// DeleteRule: typeof(ORMSolutions.ORMArchitect.Core.ObjectModel.ConstraintRoleSequenceHasRole)
/// </summary>
private static void ConstraintRoleDeletedRule(ElementDeletedEventArgs e)
{
ConstraintRoleSequenceHasRole link = (ConstraintRoleSequenceHasRole)e.ModelElement;
IConstraint constraint = link.ConstraintRoleSequence.Constraint;
if (constraint != null)
{
if (IsRelevantConstraint(constraint))
{
FactTypeConstraintPatternChanged(link.Role.BinarizedFactType);
}
switch (constraint.ConstraintType)
{
// UNDONE: Incremental uniqueness changes
case ConstraintType.InternalUniqueness:
case ConstraintType.ExternalUniqueness:
SignificantObjectTypeChange(constraint.PreferredIdentifierFor);
break;
}
}
}
public override void ElementDeleted(ElementDeletedEventArgs e)
{
base.ElementDeleted(e);
ModelProperty property = e.ModelElement as ModelProperty;
// TODO: Add nested support
if (property != null && property.ModelClass != null)
{
Transaction transaction = property.Store.TransactionManager.CurrentTransaction.TopLevelTransaction;
if (transaction != null && !transaction.IsSerializing && transaction.Context.ContextInfo.ContainsKey(property.Name))
{
Model model = transaction.Context.ContextInfo[property.Name] as Model;
if (model != null)
{
model.OnModelPropertyDeleted(e);
transaction.Context.ContextInfo.Remove(property.Name);
}
}
}
}
/// <summary>
/// Called whenever a relationship of type TreeNodeReferencesInheritanceNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnInheritanceNodeRemoved(ElementDeletedEventArgs args)
{
TreeNodeReferencesInheritanceNodes con = args.ModelElement as TreeNodeReferencesInheritanceNodes;
if (con != null)
{
DeleteInheritanceNode(con.InheritanceNode);
}
}
public void OnModelPropertyDeleted(ElementDeletedEventArgs e)
{
control.Clear();
}
private void OnElementDeleted(ElementDeletedEventArgs args)
{
this.ViewModelStore.EventManager.GetEvent<ErrorListRemoveItem>().Publish(this.Id);
}
/// <summary>
/// Called whenever a model element is deleted from the store.
/// </summary>
/// <param name="sender">ViewModelStore</param>
/// <param name="args">Event Arguments for notification of the removal of an ModelElement.</param>
private void OnElementDeleted(object sender, ElementDeletedEventArgs args)
{
if (!ModelData.DoSendModelEvents)
return;
EventManager.GetEvent<ModelElementDeletedEvent>().Publish(args);
if( args.ModelElement is ElementLink )
EventManager.GetEvent<ModelElementLinkDeletedEvent>().Publish(args);
}
/// <summary>
/// Survey event handler for deletion of an <see cref="Objectification"/> relationship
/// </summary>
private static void ObjectificationDeletedEvent(object sender, ElementDeletedEventArgs e)
{
INotifySurveyElementChanged eventNotify;
ModelElement element = e.ModelElement;
if (null != (eventNotify = (element.Store as IORMToolServices).NotifySurveyElementChanged))
{
Objectification objectification = (Objectification)element;
ObjectType nestingType = objectification.NestingType;
if (!objectification.IsImplied)
{
FactType nestedFactType = objectification.NestedFactType;
if (!nestingType.IsDeleted)
{
eventNotify.ElementChanged(nestingType, SurveyGlyphQuestionTypes);
foreach (Role role in nestingType.PlayedRoleCollection)
{
eventNotify.ElementChanged(role, SurveyGlyphQuestionTypes);
}
}
if (!nestedFactType.IsDeleted)
{
eventNotify.ElementChanged(nestedFactType, SurveyGlyphQuestionTypes);
}
}
else if (!nestingType.IsDeleted)
{
eventNotify.ElementAdded(nestingType, null);
}
}
}
/// <summary>
/// Survey event handler when a role player is deleted. Handles conversion
/// of a unary <see cref="FactType"/> to a non-unary FactType and role display updates.
/// </summary>
private static void RolePlayerDeletedEvent(object sender, ElementDeletedEventArgs e)
{
INotifySurveyElementChanged eventNotify;
ModelElement element = e.ModelElement;
if (null != (eventNotify = (element.Store as IORMToolServices).NotifySurveyElementChanged))
{
ObjectTypePlaysRole link = (ObjectTypePlaysRole)element;
Role role = link.PlayedRole;
if (!role.IsDeleted)
{
if (link.RolePlayer.IsImplicitBooleanValue)
{
eventNotify.ElementAdded(role, role.FactType);
}
else
{
eventNotify.ElementChanged(role, SurveyGlyphQuestionTypes);
eventNotify.ElementRenamed(role);
}
}
}
}
/// <summary>
/// Called whenever a relationship of type DomainModelTreeViewReferencesRootNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnChildRootNodeRemoved(ElementDeletedEventArgs args)
{
DomainModelTreeViewReferencesRootNodes con = args.ModelElement as DomainModelTreeViewReferencesRootNodes;
if (con != null)
{
DeleteRootNode(con.RootNode);
}
}
/// <summary>
/// DeleteRule: typeof(ConstraintRoleSequenceHasRole)
/// </summary>
private static void ConstraintRoleSequenceHasRoleDeletedRule(ElementDeletedEventArgs e)
{
FactType factType = (e.ModelElement as ConstraintRoleSequenceHasRole).Role.FactType;
if (factType != null && !factType.IsDeleted)
{
FrameworkDomainModel.DelayValidateElement(factType, DelayValidateUnaryBinarization);
}
}
/// <summary>
/// 删除包 从而删除自动生成的文件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DeletePackage(object sender, ElementDeletedEventArgs e)
{
// Don't handle changes in undo or load from file:
if (modelingStore.InUndoRedoOrRollback || modelingStore.InSerializationTransaction) return;
IElement element = e.ModelElement as IElement;
string modelName = ModelNameByType(element, 2);
bool isExist = isExistModel(element, 2, modelName);
if (isExist)
{
return;
}
RemoveProjectItemByType(element, 2, modelName);
}
/// <summary>
/// Called whenever a relationship of type SerializationClassReferencesAttributes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnAttributeRemoved(ElementDeletedEventArgs args)
{
SerializationClassReferencesAttributes con = args.ModelElement as SerializationClassReferencesAttributes;
if (con != null)
{
DeleteAttribute(con.Child);
}
}
/// <summary>
/// Called whenever a relationship of type SerializationClassReferencesChildren is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnChildRemoved(ElementDeletedEventArgs args)
{
SerializationClassReferencesChildren con = args.ModelElement as SerializationClassReferencesChildren;
if (con != null)
{
DeleteChild(con.Child);
}
}
public void OnModelPropertyDeleted(ElementDeletedEventArgs e)
{
if (ModelPropertyDeleted != null)
ModelPropertyDeleted(e);
}
/// <summary>
/// Called whenever a relationship of type MetaModelHasModelContexts is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnModelContextRemoved(ElementDeletedEventArgs args)
{
MetaModelHasModelContexts con = args.ModelElement as MetaModelHasModelContexts;
if (con != null)
{
DeleteModelContext(con.BaseModelContext);
}
}
/// <summary>
/// DeleteRule: typeof(ObjectTypePlaysRole)
/// </summary>
private static void ObjectTypePlaysRoleDeletedRule(ElementDeletedEventArgs e)
{
// After this point, it is unknown whether the FactType was a unary, so we just delete it for now
ObjectTypePlaysRole link = e.ModelElement as ObjectTypePlaysRole;
ObjectType objectType = link.RolePlayer;
Role role;
FactType factType;
if (objectType.IsImplicitBooleanValue)
{
if (!(role = link.PlayedRole).IsDeleted &&
null != (factType = role.FactType) &&
!factType.IsDeleted)
{
factType.Delete();
}
if (!objectType.IsDeleted)
{
objectType.Delete();
}
}
}
private void OnRolePlayerDeleted(ElementDeletedEventArgs args)
{
OnPropertyChanged("PropertyValue");
}
/// <summary>
/// Called whenever a relationship of type TreeNodeReferencesReferenceRSNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnReferenceRSNodeRemoved(ElementDeletedEventArgs args)
{
TreeNodeReferencesReferenceRSNodes con = args.ModelElement as TreeNodeReferencesReferenceRSNodes;
if (con != null)
{
DeleteReferenceRSNode(con.ReferenceRSNode);
}
}
private void DiagramRemovedEvent(object sender, ElementDeletedEventArgs e)
{
ModelElement element = e.ModelElement;
if (element.Store.DefaultPartition == element.Partition)
{
myDiagramSetChanged = true;
if (element == myDiagramView.Diagram)
{
// Note that this is unlikely, the diagram will be disassociated first
AdjustVisibility(false, true);
}
}
}
/// <summary>
/// Called if the hosted element was deleted.
/// </summary>
/// <param name="args">Data</param>
protected virtual void OnHostedElementDeleted(ElementDeletedEventArgs args)
{
this.HostedElement = null;
}
/// <summary>
/// Called whenever a relationship of type TreeNodeReferencesShapeClassNodes is deleted and
/// the element hosted by this model is the source.
/// </summary>
/// <param name="args"></param>
private void OnShapeClassNodeRemoved(ElementDeletedEventArgs args)
{
TreeNodeReferencesShapeClassNodes con = args.ModelElement as TreeNodeReferencesShapeClassNodes;
if (con != null)
{
DeleteShapeClassNode(con.ShapeClassNode);
}
}