/// <summary>
/// Activate the Name property in the Properties Window
/// for the specified element
/// </summary>
/// <param name="targetElement">The underlying model element with a name property</param>
protected void ActivateNameProperty(ModelElement targetElement)
{
Store store = Store;
EditorUtility.ActivatePropertyEditor(
(store as IORMToolServices).ServiceProvider,
DomainTypeDescriptor.CreateNamePropertyDescriptor(targetElement),
false);
}
/// <summary>
/// Implements IModelErrorActivation.ActivateModelError
/// </summary>
protected new bool ActivateModelError(ModelError error)
{
RingConstraintTypeNotSpecifiedError ringTypeError;
bool retVal = true;
if (null != (ringTypeError = error as RingConstraintTypeNotSpecifiedError))
{
Store store = Store;
RingConstraint constraint = ringTypeError.RingConstraint;
EditorUtility.ActivatePropertyEditor(
(store as IORMToolServices).ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(constraint, RingConstraint.RingTypeDomainPropertyId),
true);
}
else
{
retVal = base.ActivateModelError(error);
}
return(retVal);
}
/// <summary>
/// Implements <see cref="IModelErrorActivation.ActivateModelError"/> for
/// the <see cref="ValueComparisonConstraintOperatorNotSpecifiedError"/>
/// </summary>
protected new bool ActivateModelError(ModelError error)
{
ValueComparisonConstraintOperatorNotSpecifiedError operatorError;
ValueComparisonRolesNotComparableError comparabilityError;
ValueComparisonConstraint constraint;
Store store;
bool retVal = true;
if (null != (operatorError = error as ValueComparisonConstraintOperatorNotSpecifiedError))
{
store = Store;
constraint = operatorError.ValueComparisonConstraint;
EditorUtility.ActivatePropertyEditor(
(store as IORMToolServices).ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(constraint, ValueComparisonConstraint.OperatorDomainPropertyId),
true);
}
else if (null != (comparabilityError = error as ValueComparisonRolesNotComparableError))
{
constraint = comparabilityError.ValueComparisonConstraint;
LinkedElementCollection <Role> constraintRoles = constraint.RoleCollection;
Role role1;
Role role2;
ObjectTypePlaysRole rolePlayerLink1;
ObjectTypePlaysRole rolePlayerLink2;
ObjectType rolePlayer1 = null;
ObjectType rolePlayer2 = null;
Role[] valueRoles1 = null;
Role[] valueRoles2 = null;
// The default behavior is to activate the role sequence
// for editing. However, if the problem is with a single
// resolved value type, and the units are correct, then
// we need to select the first directly detached object.
if (constraintRoles.Count == 2 &&
null != (rolePlayerLink1 = ObjectTypePlaysRole.GetLinkToRolePlayer(role1 = constraintRoles[0])) &&
null != (rolePlayerLink2 = ObjectTypePlaysRole.GetLinkToRolePlayer(role2 = constraintRoles[1])) &&
(rolePlayerLink1.RolePlayer == rolePlayerLink2.RolePlayer ||
(null != (valueRoles1 = role1.GetValueRoles()) &&
null != (valueRoles2 = role2.GetValueRoles()) &&
DataType.IsComparableValueType(rolePlayer1 = valueRoles1[0].RolePlayer, rolePlayer2 = valueRoles2[0].RolePlayer, !constraint.IsDirectional))))
{
bool verifiedReferenceMode = true;
if (valueRoles1 != null)
{
ORMModel model = null;
ReferenceMode referenceMode1 = (valueRoles1.Length > 1) ?
ReferenceMode.FindReferenceModeFromEntityNameAndValueName(rolePlayer1.Name, valueRoles1[1].RolePlayer.Name, model = constraint.ResolvedModel) :
null;
ReferenceMode referenceMode2 = (valueRoles2.Length > 1) ?
ReferenceMode.FindReferenceModeFromEntityNameAndValueName(rolePlayer2.Name, valueRoles2[1].RolePlayer.Name, model ?? constraint.ResolvedModel) :
null;
bool referenceMode1IsUnit = referenceMode1 != null && referenceMode1.Kind.ReferenceModeType == ReferenceModeType.UnitBased;
bool referenceMode2IsUnit = referenceMode2 != null && referenceMode2.Kind.ReferenceModeType == ReferenceModeType.UnitBased;
verifiedReferenceMode = referenceMode1IsUnit ? (referenceMode2IsUnit && referenceMode1 == referenceMode2) : !referenceMode2IsUnit;
}
if (verifiedReferenceMode)
{
// Find a connected role player
foreach (ExternalConstraintLink constraintLink in MultiShapeUtility.GetEffectiveAttachedLinkShapes <ExternalConstraintLink>(this))
{
FactTypeShape factTypeShape;
if (constraintLink.AssociatedConstraintRole.Role == role1 &&
null != (factTypeShape = constraintLink.FromShape as FactTypeShape))
{
foreach (RolePlayerLink rolePlayerLinkShape in MultiShapeUtility.GetEffectiveAttachedLinkShapes <RolePlayerLink>(factTypeShape))
{
if (rolePlayerLinkShape.AssociatedRolePlayerLink == rolePlayerLink1)
{
Diagram.ActiveDiagramView.Selection.Set(new DiagramItem(rolePlayerLinkShape.ToShape));
return(true);
}
}
}
}
}
}
ActivateNewRoleSequenceConnectAction(null);
}
else
{
retVal = base.ActivateModelError(error);
}
return(retVal);
}
/// <summary>
/// Add shared model error activation handlers. Activation handlers are
/// static, this is called once during intitial load.
/// </summary>
/// <param name="store">The <see cref="Store"/></param>
public static void RegisterModelErrorActivators(Store store)
{
IORMToolServices toolServices;
IORMModelErrorActivationService activationService;
if (null != (toolServices = store as IORMToolServices) &&
null != (activationService = toolServices.ModelErrorActivationService))
{
#region Role error activation
activationService.RegisterErrorActivator(
typeof(Role),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is RolePlayerRequiredError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
RoleTypeDescriptor.GetRolePlayerDisplayPropertyDescriptor((Role)selectedElement),
true);
}
else if (error is ValueConstraintError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, Role.ValueRangeTextDomainPropertyId),
false);
}
else if (error is CardinalityRangeOverlapError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
RoleTypeDescriptor.CardinalityDisplayPropertyDescriptor,
false);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // Role error activation
#region ValueConstraint error activation
activationService.RegisterErrorActivator(
typeof(ValueConstraint),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is ValueConstraintError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, ValueConstraint.TextDomainPropertyId),
false);
}
else if (error is ConstraintDuplicateNameError)
{
ActivateNameProperty(selectedElement);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // ValueConstraint error activation
#region CardinalityConstraint error activation
activationService.RegisterErrorActivator(
typeof(CardinalityConstraint),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is CardinalityRangeOverlapError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, CardinalityConstraint.TextDomainPropertyId),
false);
}
else if (error is ConstraintDuplicateNameError)
{
ActivateNameProperty(selectedElement);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // CardinalityConstraint error activation
#region SetConstraint error activation
activationService.RegisterErrorActivator(
typeof(SetConstraint),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is ConstraintDuplicateNameError)
{
ActivateNameProperty(selectedElement);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // SetConstraint error activation
#region FrequencyConstraint error activation
activationService.RegisterErrorActivator(
typeof(FrequencyConstraint),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is FrequencyConstraintExactlyOneError)
{
((FrequencyConstraint)selectedElement).ConvertToUniquenessConstraint();
}
else if (error is FrequencyConstraintNonRestrictiveRangeError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, FrequencyConstraint.MinFrequencyDomainPropertyId),
false);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // FrequencyConstraint error activation
#region RingConstraint error activation
activationService.RegisterErrorActivator(
typeof(RingConstraint),
false,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is RingConstraintTypeNotSpecifiedError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, RingConstraint.RingTypeDomainPropertyId),
true);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // RingConstraint error activation
#region ValueComparisonConstraint error activation
activationService.RegisterErrorActivator(
typeof(ValueComparisonConstraint),
false,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
if (error is ValueComparisonConstraintOperatorNotSpecifiedError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, ValueComparisonConstraint.OperatorDomainPropertyId),
true);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // ValueComparisonConstraint error activation
#region SetComparisonConstraint error activation
activationService.RegisterErrorActivator(
typeof(SetComparisonConstraint),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
ConstraintDuplicateNameError duplicateName;
if (null != (duplicateName = error as ConstraintDuplicateNameError))
{
ActivateNameProperty(selectedElement);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // SetComparisonConstraint error activation
#region ObjectType error activation
activationService.RegisterErrorActivator(
typeof(ObjectType),
false,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
bool retVal = true;
PopulationMandatoryError populationMandatory;
if (error is DataTypeNotSpecifiedError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
ObjectTypeTypeDescriptor.DataTypeDisplayPropertyDescriptor,
true);
}
else if (error is EntityTypeRequiresReferenceSchemeError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, ObjectType.ReferenceModeDisplayDomainPropertyId),
true);
}
else if (error is ValueConstraintError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, ObjectType.ValueRangeTextDomainPropertyId),
false);
}
else if (error is CardinalityRangeOverlapError)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
ObjectTypeTypeDescriptor.CardinalityDisplayPropertyDescriptor,
false);
}
else if (error is ObjectTypeDuplicateNameError)
{
ActivateNameProperty(selectedElement);
}
else if (error is ObjectifiedInstanceRequiredError || error is TooFewEntityTypeRoleInstancesError)
{
ORMDesignerPackage.SamplePopulationEditorWindow.ActivateModelError(error);
}
else if (null != (populationMandatory = error as PopulationMandatoryError))
{
retVal = ORMDesignerPackage.SamplePopulationEditorWindow.AutoCorrectMandatoryError(populationMandatory, (ObjectType)selectedElement);
}
else
{
retVal = false;
}
return(retVal);
});
#endregion // ObjectType error activation
#region FactType error activation
activationService.RegisterErrorActivator(
typeof(FactType),
true,
delegate(IORMToolServices services, ModelElement selectedElement, ModelError error)
{
PopulationMandatoryError populationMandatory;
TooFewReadingRolesError tooFew;
TooManyReadingRolesError tooMany;
ReadingRequiresUserModificationError userModification;
DuplicateReadingSignatureError duplicateSignature;
FactTypeRequiresReadingError noReading;
ValueConstraintError valueError;
CardinalityRangeOverlapError cardinalityRangeError;
FactType factType;
ImpliedInternalUniquenessConstraintError implConstraint;
Reading reading = null;
bool retVal = true;
if (null != (populationMandatory = error as PopulationMandatoryError))
{
retVal = ORMDesignerPackage.SamplePopulationEditorWindow.AutoCorrectMandatoryError(populationMandatory, null, (FactType)selectedElement);
}
else if (null != (tooFew = error as TooFewReadingRolesError))
{
reading = tooFew.Reading;
}
else if (null != (tooMany = error as TooManyReadingRolesError))
{
reading = tooMany.Reading;
}
else if (null != (noReading = error as FactTypeRequiresReadingError))
{
factType = noReading.FactType;
Debug.Assert(factType != null);
ORMReadingEditorToolWindow newWindow = ORMDesignerPackage.ReadingEditorWindow;
newWindow.Show();
newWindow.ActivateReading(factType);
}
else if (null != (userModification = error as ReadingRequiresUserModificationError))
{
reading = userModification.Reading;
}
else if (null != (duplicateSignature = error as DuplicateReadingSignatureError))
{
factType = (FactType)selectedElement;
LinkedElementCollection <Reading> readings = duplicateSignature.ReadingCollection;
foreach (Reading testReading in readings)
{
if (testReading.ReadingOrder.FactType == factType)
{
reading = testReading;
break;
}
}
if (reading == null)
{
Objectification objectification;
if (null != (objectification = factType.Objectification))
{
foreach (Reading testReading in readings)
{
if (testReading.ReadingOrder.FactType.ImpliedByObjectification == objectification)
{
reading = testReading;
break;
}
}
}
if (reading == null)
{
// Defensive, shouldn't happen.
reading = readings[0];
}
}
}
else if (null != (implConstraint = error as ImpliedInternalUniquenessConstraintError))
{
IServiceProvider provider;
IVsUIShell shell;
if (null != (provider = services.ServiceProvider) &&
null != (shell = (IVsUIShell)provider.GetService(typeof(IVsUIShell))))
{
Guid g = new Guid();
int pnResult;
shell.ShowMessageBox(0, ref g, ResourceStrings.PackageOfficialName,
ResourceStrings.ImpliedInternalConstraintFixMessage,
"", 0, OLEMSGBUTTON.OLEMSGBUTTON_YESNO,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGICON.OLEMSGICON_QUERY, 0, out pnResult);
if (pnResult == (int)DialogResult.Yes)
{
implConstraint.FactType.RemoveImpliedInternalUniquenessConstraints();
}
}
}
else if (null != (valueError = error as ValueConstraintError))
{
if (valueError.ContextValueConstraint is RoleValueConstraint)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
DomainTypeDescriptor.CreatePropertyDescriptor(selectedElement, ObjectType.ValueRangeTextDomainPropertyId),
false);
}
else
{
retVal = false;
}
}
else if (null != (cardinalityRangeError = error as CardinalityRangeOverlapError))
{
if (cardinalityRangeError.CardinalityConstraint is ObjectTypeCardinalityConstraint)
{
EditorUtility.ActivatePropertyEditor(
services.ServiceProvider,
ObjectTypeTypeDescriptor.CardinalityDisplayPropertyDescriptor,
false);
}
else
{
retVal = false;
}
}
else if (error is TooFewFactTypeRoleInstancesError || error is ObjectifyingInstanceRequiredError)
{
ORMDesignerPackage.SamplePopulationEditorWindow.ActivateModelError(error);
}
else
{
retVal = false;
}
if (reading != null)
{
// Open the reading editor window and activate the reading
ORMReadingEditorToolWindow window = ORMDesignerPackage.ReadingEditorWindow;
window.Show();
window.ActivateReading(reading);
}
return(retVal);
});
#endregion // FactType error activation
}
}
