/// <summary>
/// Test whether a given model element is acceptable to this ConnectionBuilder as the source of a connection.
/// </summary>
/// <param name="candidate">The model element to test.</param>
/// <param name="forSourceAndTarget">false: this method is called to query only the source of a new connection, true: after this call the <see cref="CanAcceptAsSourceAndTarget"/> method will be called.</param>
/// <returns>Whether the element can be used as the source of a connection.</returns>
private bool CanAcceptAsSource(SOURCE_ELEMENT candidate, bool forSourceAndTarget)
{
ICompartmentMouseActionTrackable candidateShape = GetFirstCompartmentShapeForModelElement(candidate);
if (candidateShape == null) // must be a regular shap
{
rememberedSourceShape = candidate;
rememberedSourceEntry = new SelectedCompartmentPart()
{
IsRegularShape = true
};
return(CanAcceptAsCompartmentSource(rememberedSourceShape, SelectedCompartmentPartType.None, null));
}
else
{
rememberedSourceShape = candidate;
SelectedCompartmentPart entry =
(forSourceAndTarget
? candidateShape.MouseTrack.entryBelowMouseDown
: candidateShape.MouseTrack.entryNowHoveringAbove).Clone();
// the Compartment Title is never valid as a source
if (entry.Element is ElementListCompartment)
{
return(false);
}
if (entry.Type == SelectedCompartmentPartType.None ||
(entry.Type == SelectedCompartmentPartType.Head && !allowHeadAsSource) ||
(entry.Type == SelectedCompartmentPartType.Element && !(entry.Element is SOURCE_COMPARTMENT_ENTRY)))
{
return(false);
}
if (!forSourceAndTarget)
{
rememberedSourceEntry = entry;
// everything fine for me. now ask the user to decide
return(CanAcceptAsCompartmentSource(rememberedSourceShape, rememberedSourceEntry.Type,
rememberedSourceEntry.Element as SOURCE_COMPARTMENT_ENTRY));
}
return(true);
}
}
/// <summary>
/// Eventhandler
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Shape_MouseDown(object sender, DiagramMouseEventArgs e)
{
entryBelowMouseDown = entryNowHoveringAbove.Clone();
}
public ElementLink Connect(ModelElement source, ModelElement target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
// TODO bei fehler mit base in svn vergleichen ;)
if (source != rememberedSourceShape || target != rememberedTargetShape)
{
Debug.Fail("Cannot create Connection for other then the rememberd ones.");
throw new InvalidOperationException();
}
if (CanAcceptSourceAndTarget(source, target))
{
if (source is SOURCE_ELEMENT)
{
if (target is TARGET_ELEMENT)
{
SOURCE_ELEMENT sourceAccepted = (SOURCE_ELEMENT)source;
TARGET_ELEMENT targetAccepted = (TARGET_ELEMENT)target;
ElementLink result;
if (rememberedSourceEntry.IsRegularShape)
{
result = CreateElementLink(sourceAccepted,
SelectedCompartmentPartType.None,
null,
targetAccepted,
rememberedTargetEntry.Type,
rememberedTargetEntry.Element as TARGET_COMPARTMENT_ENTRY);
}
else if (rememberedTargetEntry.IsRegularShape)
{
result = CreateElementLink(sourceAccepted,
rememberedSourceEntry.Type,
rememberedSourceEntry.Element as SOURCE_COMPARTMENT_ENTRY,
targetAccepted,
SelectedCompartmentPartType.None,
null);
}
else
{
result = CreateElementLink(sourceAccepted,
rememberedSourceEntry.Type,
rememberedSourceEntry.Element as SOURCE_COMPARTMENT_ENTRY,
targetAccepted,
rememberedTargetEntry.Type,
rememberedTargetEntry.Element as TARGET_COMPARTMENT_ENTRY);
}
if (DomainClassInfo.HasNameProperty(result))
{
DomainClassInfo.SetUniqueName(result);
}
rememberedSourceEntry = null;
rememberedTargetEntry = null;
rememberedSourceShape = null;
rememberedTargetShape = null;
return(result);
}
}
}
Debug.Fail("Having agreed that the connection can be accepted we should never fail to make one.");
throw new InvalidOperationException();
}
/// <summary>
/// Test whether a given pair of model elements are acceptable to this ConnectionBuilder as the source and target of a connection
/// </summary>
/// <param name="candidateSource">The model element to test as a source</param>
/// <param name="candidateTarget">The model element to test as a target</param>
/// <returns>Whether the elements can be used as the source and target of a connection</returns>
private bool CanAcceptAsSourceAndTarget(SOURCE_ELEMENT candidateSource, TARGET_ELEMENT candidateTarget)
{
if (!allowSelfReference && candidateSource == candidateTarget)
{
return(false);
}
if (candidateSource != rememberedSourceShape)
{
return(false);
}
ICompartmentMouseActionTrackable targetShape = GetFirstCompartmentShapeForModelElement(candidateTarget);
if (targetShape == null) // it is a regular shape
{
rememberedTargetShape = candidateTarget;
rememberedTargetEntry = new SelectedCompartmentPart()
{
IsRegularShape = true
};
return(CanAcceptAsCompartmentTarget(rememberedTargetShape,
SelectedCompartmentPartType.None,
null) &&
CanAcceptAsCompartmentSourceAndTarget(rememberedSourceShape,
rememberedSourceEntry.Type,
rememberedSourceEntry.Element as SOURCE_COMPARTMENT_ENTRY,
rememberedTargetShape,
SelectedCompartmentPartType.None,
null));
}
else
{
rememberedTargetShape = candidateTarget;
rememberedTargetEntry = targetShape.MouseTrack.entryNowHoveringAbove.Clone();
// the Compartment Title is never valid as a target
if (rememberedTargetEntry.Element is ElementListCompartment)
{
return(false);
}
if (rememberedTargetEntry.Type == SelectedCompartmentPartType.None ||
(rememberedTargetEntry.Type == SelectedCompartmentPartType.Head && !allowHeadAsTarget) ||
(rememberedTargetEntry.Type == SelectedCompartmentPartType.Element && !(rememberedTargetEntry.Element is TARGET_COMPARTMENT_ENTRY)))
{
return(false);
}
// check some standart cases for source is compartment shape
if (!rememberedSourceEntry.IsRegularShape)
{
if (rememberedSourceEntry.Type == SelectedCompartmentPartType.None ||
(rememberedSourceEntry.Type == SelectedCompartmentPartType.Head && !allowHeadAsSource) ||
(rememberedSourceEntry.Type == SelectedCompartmentPartType.Element && !(rememberedSourceEntry.Element is SOURCE_COMPARTMENT_ENTRY)))
{
return(false);
}
}
// everything fine for me. now ask the user to decide
if (!CanAcceptAsCompartmentTarget(rememberedTargetShape, rememberedTargetEntry.Type, rememberedTargetEntry.Element as TARGET_COMPARTMENT_ENTRY))
{
return(false);
}
if (rememberedSourceEntry.IsRegularShape)
{
return(CanAcceptAsCompartmentSourceAndTarget(rememberedSourceShape,
SelectedCompartmentPartType.None,
null,
rememberedTargetShape,
rememberedTargetEntry.Type,
rememberedTargetEntry.Element as TARGET_COMPARTMENT_ENTRY));
}
else
{
return(CanAcceptAsCompartmentSourceAndTarget(rememberedSourceShape,
rememberedSourceEntry.Type,
rememberedSourceEntry.Element as SOURCE_COMPARTMENT_ENTRY,
rememberedTargetShape,
rememberedTargetEntry.Type,
rememberedTargetEntry.Element as TARGET_COMPARTMENT_ENTRY));
}
}
}
