// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Creates and returns a Relationship Visual Representation shortcut (as Main Central/Main Symbol)
/// to the target Relationship, for the specified target view, center position, symbol and connectors format,
/// plus indication as a shortcut.
/// </summary>
public static RelationshipVisualRepresentation CreateRelationshipVisualRepresentation(Relationship Target,
View TargetView,
Point CenterPosition,
bool AsShortcut = false)
{
var Representator = new RelationshipVisualRepresentation(Target, TargetView)
{
IsShortcut = AsShortcut
};
var Width = Target.RelationshipDefinitor.Value.DefaultSymbolFormat.InitialWidth.SubstituteFor(0, ProductDirector.DefaultRelationshipCentralSymbolSize.Width);
var Height = Target.RelationshipDefinitor.Value.DefaultSymbolFormat.InitialHeight.SubstituteFor(0, ProductDirector.DefaultRelationshipCentralSymbolSize.Height);
// Notice that "hidden" symbols are not adjusted/snapped to grid
if (TargetView.SnapToGrid && !(Target.RelationshipDefinitor.Value.IsSimple && Target.RelationshipDefinitor.Value.HideCentralSymbolWhenSimple))
{
var SnappedArea = TargetView.GetGridSnappedArea(CenterPosition, Width, Height);
if (!Target.RelationshipDefinitor.Value.DefaultSymbolFormat.HasFixedWidth)
{
Width = SnappedArea.Width;
}
if (!Target.RelationshipDefinitor.Value.DefaultSymbolFormat.HasFixedWidth)
{
Height = SnappedArea.Height;
}
CenterPosition = new Point(SnappedArea.X + SnappedArea.Width / 2.0, SnappedArea.Y + SnappedArea.Height / 2.0);
}
var Body = new VisualShape(Representator, EVisualRepresentationPart.RelationshipCentralSymbol, CenterPosition, Width, Height)
{
IsAutoPositionable = true // Very important (for users) to work more easily
};
Representator.AddVisualPart(Body);
// Append possible Group Region Complement
if (Target.IdeaDefinitor.HasGroupRegion)
{
var Params = VisualComplement.GetGroupRegionInitialParams(Body);
ComplementCreationCommand.CreateComplement(TargetView.OwnerCompositeContainer, Domain.ComplementDefGroupRegion, TargetView, Body, Params.Item1, Params.Item2);
}
// Append possible Group Line Complement
if (Target.IdeaDefinitor.HasGroupLine)
{
ComplementCreationCommand.CreateComplement(TargetView.OwnerCompositeContainer, Domain.ComplementDefGroupLine, TargetView, Body, VisualComplement.GetGroupLineInitialPosition(Body));
}
// NOTE: This does not render because the connectors are expected to be added later.
return(Representator);
}
private void ReappointReferences(RelationshipVisualRepresentation SourceRelVisRep,
RelationshipVisualRepresentation ClonedRelVisRep,
List <Capsule <VisualRepresentation, VisualRepresentation> > InterrelationsMap,
double DeltaX, double DeltaY)
{
// NOTE: Each InterrelationsMap capsule contains: Value0=Original Representation, Value1=Cloned Representation.
foreach (var SourceVisConn in SourceRelVisRep.VisualConnectors)
{
var InterRel = InterrelationsMap.FirstOrDefault(
intrel => intrel.Value0.RepresentedIdea == SourceVisConn.RepresentedLink.AssociatedIdea);
if (InterRel == null || InterRel.Value1 == null)
{
continue;
}
var ClonedRoleLink = new RoleBasedLink(ClonedRelVisRep.RepresentedRelationship, InterRel.Value1.RepresentedIdea,
SourceVisConn.RepresentedLink.RoleDefinitor, SourceVisConn.RepresentedLink.RoleVariant);
if (SourceVisConn.RepresentedLink.Descriptor != null)
{
ClonedRoleLink.Descriptor = (SimplePresentationElement)SourceVisConn.RepresentedLink.Descriptor.CreateClone();
}
// Next, the origin and target symbols are pointed and eventually replaced by the cloned ones
// (if they were within the pasted visual representations)
VisualSymbol OriginSymbol = SourceVisConn.OriginSymbol;
var OriginInterRel = InterrelationsMap.FirstOrDefault(intrel => intrel.Value0.MainSymbol == SourceVisConn.OriginSymbol);
if (OriginInterRel != null)
{
OriginSymbol = OriginInterRel.Value1.MainSymbol;
}
VisualSymbol TargetSymbol = SourceVisConn.TargetSymbol;
var TargetInterRel = InterrelationsMap.FirstOrDefault(intrel => intrel.Value0.MainSymbol == SourceVisConn.TargetSymbol);
if (TargetInterRel != null)
{
TargetSymbol = TargetInterRel.Value1.MainSymbol;
}
var ClonedVisConn = new VisualConnector(ClonedRelVisRep, ClonedRoleLink, OriginSymbol, TargetSymbol,
new Point(SourceVisConn.OriginPosition.X + DeltaX, SourceVisConn.OriginPosition.Y + DeltaY),
new Point(SourceVisConn.TargetPosition.X + DeltaX, SourceVisConn.TargetPosition.Y + DeltaY));
ClonedVisConn.IntermediatePosition = (SourceVisConn.IntermediatePosition == Display.NULL_POINT
? Display.NULL_POINT
: new Point(SourceVisConn.IntermediatePosition.X + DeltaX, SourceVisConn.IntermediatePosition.Y + DeltaY));
ClonedRelVisRep.RepresentedRelationship.AddLink(ClonedRoleLink);
ClonedRelVisRep.AddVisualPart(ClonedVisConn);
}
ClonedRelVisRep.Render();
}
protected override void OnMouseMove(MouseEventArgs e)
{
MousePositionPrevious = MousePositionCurrent;
MousePositionCurrent = e.GetPosition(BaseLayer);
DeterminePointedVisual(MousePositionCurrent);
// Extend Relationship if moving instead of clicking for Edit In-Place
if ((OwnerManager.OwnerView.Engine.RunningMouseCommand == null ||
OwnerManager.OwnerView.Engine.RunningMouseCommand is RelationshipCreationCommand) &&
IsAbleToExtendRelationship && !MousePositionCurrent.IsNear(MousePositionPrevious) &&
(ESymbolManipulationAction)IntendedAction_ == ESymbolManipulationAction.EditInPlace)
{
RelationshipVisualRepresentation TargetRelationRep = ManipulatedObject is VisualSymbol symbol
? symbol.OwnerRepresentation as RelationshipVisualRepresentation
: null;
if (TargetRelationRep != null)
{
var Engine = OwnerManager.OwnerView.Engine;
Engine.RunningMouseCommand =
new RelationshipCreationCommand(Engine,
TargetRelationRep.RepresentedRelationship.RelationshipDefinitor.Value);
Engine.RunningMouseCommand.Execute();
Engine.RunningMouseCommand.Continue(e, true);
}
IsAbleToExtendRelationship = false;
}
if (IsManipulating)
{
ManipulationOperation(this, Mouse.LeftButton == MouseButtonState.Released, false, false,
Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl),
Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift),
Keyboard.IsKeyDown(Key.LeftAlt),
Keyboard.IsKeyDown(Key.RightAlt),
false);
Visualize();
}
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Creates and returns a copy of the supplied original Relationship and its Visual Representation, for the specified target-view and position.
/// </summary>
public static OperationResult <RelationshipVisualRepresentation> CreateRelationshipAndRepresentationCopy(RelationshipVisualRepresentation OriginalRelationshipRep,
View TargetView, Point Position)
{
// PENDING: SHOW A LITTLE CIRCLE FOR SIMPLE MAIN-SYMBOL HIDING RELATIONSHIPS.
var NewRelationship = OriginalRelationshipRep.RepresentedRelationship.GenerateIndependentRelationshipDuplicate();
var NewRepresentator = CreateRelationshipVisualRepresentation(NewRelationship, TargetView, Position);
NewRepresentator.MainSymbol.IsAutoPositionable = OriginalRelationshipRep.MainSymbol.IsAutoPositionable;
NewRepresentator.MainSymbol.AreDetailsShown = OriginalRelationshipRep.MainSymbol.AreDetailsShown;
NewRepresentator.MainSymbol.ResizeTo(OriginalRelationshipRep.MainSymbol.BaseWidth,
OriginalRelationshipRep.MainSymbol.BaseHeight);
NewRepresentator.MainSymbol.DetailsPosterHeight = OriginalRelationshipRep.MainSymbol.DetailsPosterHeight;
foreach (var Complement in OriginalRelationshipRep.MainSymbol.AttachedComplements)
{
var NewComplementTarget = (Complement.Target.IsGlobal
? Ownership.Create <View, VisualSymbol>(TargetView)
: Ownership.Create <View, VisualSymbol>(NewRepresentator.MainSymbol));
var NewComplement = Complement.GenerateIndependentDuplicate(NewComplementTarget);
if (!NewComplement.Target.IsGlobal)
{
NewComplement.BaseCenter = new Point(NewComplement.BaseCenter.X + (NewComplementTarget.OwnerLocal.BaseCenter.X - OriginalRelationshipRep.MainSymbol.BaseCenter.X),
NewComplement.BaseCenter.Y + (NewComplementTarget.OwnerLocal.BaseCenter.Y - OriginalRelationshipRep.MainSymbol.BaseCenter.Y));
}
NewRepresentator.MainSymbol.AddComplement(NewComplement);
TargetView.PutComplement(NewComplement);
}
return(OperationResult.Success(NewRepresentator));
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
public static OperationResult <Relationship> CreateRelationship(Idea DestinationComposite, RelationshipDefinition Definitor, View TargetView,
VisualRepresentation OriginRepresentation, Point OriginPosition,
VisualRepresentation TargetRepresentation, Point TargetPosition,
bool ExtendFromOriginRelationship = true, // (Shift not pressed) Applicable only when origin and target are both relationships. Else (Shift pressed) create Rel. from Target to Origin.
bool ExtendExistingRelationship = true) // (Right-Alt not pressed) Applicable only when origin is a not (simple and hiding-central-symbol) relationship. Else (Right-Alt pressed) created Rel. from Rel.
{
bool EditInPlace = false;
General.ContractRequiresNotNull(DestinationComposite, Definitor, TargetView, OriginRepresentation);
var MaxQuota = AppExec.CurrentLicenseEdition.TechName.SelectCorresponding(LicensingConfig.IdeasCreationQuotas);
if (!ProductDirector.ValidateEditionLimit(DestinationComposite.OwnerComposition.DeclaredIdeas.Count() + 1, MaxQuota, "create", "Ideas (Concepts + Relationships)"))
{
return(OperationResult.Failure <Relationship>("This product edition cannot create more than " + MaxQuota + " Ideas."));
}
if (!ExtendFromOriginRelationship && (TargetRepresentation == null || !(TargetRepresentation.RepresentedIdea is Relationship)))
{
ExtendFromOriginRelationship = true;
}
var PotentialOriginRelationship = OriginRepresentation.RepresentedIdea as Relationship;
var PotentialTargetRelationship = (TargetRepresentation == null ? (Relationship)null : TargetRepresentation.RepresentedIdea as Relationship);
bool CreatingNewRelationship = (/*?*/ !ExtendExistingRelationship || /*?*/ !((PotentialOriginRelationship != null && PotentialOriginRelationship.RelationshipDefinitor.Value == Definitor) ||
(PotentialTargetRelationship != null && PotentialTargetRelationship.RelationshipDefinitor.Value == Definitor)));
bool?ExtensionFromOriginRelationship = (CreatingNewRelationship ? (bool?)null : (PotentialOriginRelationship != null && ExtendFromOriginRelationship));
if (!CreatingNewRelationship && TargetRepresentation == null)
{
if (OriginRepresentation is RelationshipVisualRepresentation)
{
return(OperationResult.Success(((RelationshipVisualRepresentation)OriginRepresentation).RepresentedRelationship, "Creating new Relationship."));
}
else
{
return(OperationResult.Failure <Relationship>("There is no targeted Idea to relate."));
}
}
if (DestinationComposite.IdeaDefinitor.CompositeContentDomain == null)
{
return(OperationResult.Failure <Relationship>("Destination Container doest not accept Composite-Content.", DestinationComposite));
}
if (DestinationComposite.CompositeContentDomain.GlobalId != Definitor.OwnerDomain.GlobalId)
{
return(OperationResult.Failure <Relationship>("The destination container only accepts content of the '" + DestinationComposite.CompositeContentDomain.Name + "' Domain."));
}
Relationship WorkingRelationship = null;
LinkRoleDefinition OriginLinkRoleDef = null;
RoleBasedLink OriginLink = null;
DestinationComposite.EditEngine.StartCommandVariation("Create Relationship");
if (CreatingNewRelationship)
{
if (TargetRepresentation != null)
{
var CanLink = Definitor.CanLink(OriginRepresentation.RepresentedIdea.IdeaDefinitor, TargetRepresentation.RepresentedIdea.IdeaDefinitor);
if (!CanLink.Result)
{
DestinationComposite.EditEngine.DiscardCommandVariation();
return(OperationResult.Failure <Relationship>(CanLink.Message));
}
}
string NewName = Definitor.Name;
var AppendNumToName = AppExec.GetConfiguration <bool>("IdeaEditing", "Relationship.OnCreationAppendDefNameAndNumber", true);
if (AppendNumToName)
{
NewName = NewName + " (Idea " + (DestinationComposite.CompositeIdeas.Count + 1).ToString() + ")";
}
WorkingRelationship = new Relationship(DestinationComposite.OwnerComposition, Definitor, NewName, NewName.TextToIdentifier());
if (Definitor.IsVersionable)
{
WorkingRelationship.Version = new VersionCard();
}
WorkingRelationship.AddToComposite(DestinationComposite);
OriginLinkRoleDef = Definitor.GetLinkForRole(ERoleType.Origin);
OriginLink = new RoleBasedLink(WorkingRelationship, OriginRepresentation.RepresentedIdea, OriginLinkRoleDef, OriginLinkRoleDef.AllowedVariants[0]);
WorkingRelationship.AddLink(OriginLink);
PotentialOriginRelationship = WorkingRelationship;
EditInPlace = true;
}
else
{
OperationResult <bool> CanLink = OperationResult.Success(true);
if (ExtensionFromOriginRelationship.IsTrue())
{
WorkingRelationship = PotentialOriginRelationship;
}
else
{
WorkingRelationship = (PotentialTargetRelationship != null ? PotentialTargetRelationship : PotentialOriginRelationship);
}
if (TargetRepresentation != null)
{
CanLink = EvaluateLinkability(Definitor, OriginRepresentation, TargetRepresentation,
PotentialOriginRelationship, PotentialTargetRelationship, WorkingRelationship);
if (!CanLink.Result)
{
DestinationComposite.EditEngine.DiscardCommandVariation();
return(OperationResult.Failure <Relationship>("Cannot create/extend Relationship. Cause: " + CanLink.Message));
}
}
}
LinkRoleDefinition WorkingLinkRoleDef = null;
RoleBasedLink WorkingLink = null;
if (TargetRepresentation != null && (CreatingNewRelationship || (WorkingRelationship == PotentialOriginRelationship &&
ExtensionFromOriginRelationship.IsTrue())))
{
WorkingLinkRoleDef = Definitor.GetLinkForRole(ERoleType.Target);
if (WorkingRelationship.Links.Where(link => link.RoleDefinitor == WorkingLinkRoleDef &&
link.AssociatedIdea == TargetRepresentation.RepresentedIdea).Any())
{
DestinationComposite.EditEngine.DiscardCommandVariation();
return(OperationResult.Failure <Relationship>("Cannot create Target Link. Cause: Already exists one of the same role-type associating the same Idea."));
}
WorkingLink = new RoleBasedLink(WorkingRelationship, TargetRepresentation.RepresentedIdea, WorkingLinkRoleDef, WorkingLinkRoleDef.AllowedVariants[0]);
WorkingRelationship.AddLink(WorkingLink);
}
if (OriginRepresentation != null && !CreatingNewRelationship &&
WorkingRelationship == PotentialTargetRelationship && !ExtensionFromOriginRelationship.IsTrue())
{
WorkingLinkRoleDef = Definitor.GetLinkForRole(ERoleType.Origin);
if (WorkingRelationship.Links.Where(link => link.RoleDefinitor == WorkingLinkRoleDef &&
link.AssociatedIdea == OriginRepresentation.RepresentedIdea).Any())
{
DestinationComposite.EditEngine.DiscardCommandVariation();
return(OperationResult.Failure <Relationship>("Cannot create Origin Link. Cause: Already exists one of the same role-type associating the same Idea."));
}
WorkingLink = new RoleBasedLink(WorkingRelationship, OriginRepresentation.RepresentedIdea, WorkingLinkRoleDef, WorkingLinkRoleDef.AllowedVariants[0]);
WorkingRelationship.AddLink(WorkingLink);
}
RelationshipVisualRepresentation Representator = null;
VisualSymbol CentralSymbol = null;
if (TargetPosition != Display.NULL_POINT &&
OriginPosition != Display.NULL_POINT)
{
VisualConnector OriginConnector = null;
var InitialPosition = OriginPosition;
var EdgeOriginPosition = OriginPosition;
var EdgeTargetPosition = TargetPosition;
if (CreatingNewRelationship)
{
// Force connect from Symbols' centers.
if (OriginRepresentation != null)
{
EdgeOriginPosition = OriginPosition.DetermineNearestIntersectingPoint(TargetPosition, TargetView.Presenter,
OriginRepresentation.MainSymbol.Graphic,
TargetView.VisualHitTestFilter);
}
if (TargetRepresentation == null)
{
InitialPosition = TargetPosition;
}
else
{
EdgeTargetPosition = TargetPosition.DetermineNearestIntersectingPoint(OriginPosition, TargetView.Presenter,
TargetRepresentation.MainSymbol.Graphic,
TargetView.VisualHitTestFilter);
InitialPosition = EdgeOriginPosition.DetermineCenterRespect(EdgeTargetPosition);
}
// Create representation
Representator = CreateRelationshipVisualRepresentation(WorkingRelationship, TargetView, InitialPosition);
CentralSymbol = Representator.MainSymbol;
// Notice that here the Origin connector is being drawn, so the Target plug is empty/none (because is connected to the Relationship Central/Main Symbol).
OriginConnector = new VisualConnector(Representator, OriginLink, OriginRepresentation.MainSymbol, CentralSymbol, OriginPosition, CentralSymbol.BaseCenter);
}
else
{
if (WorkingRelationship == PotentialOriginRelationship)
{
Representator = (RelationshipVisualRepresentation)OriginRepresentation;
}
else
{
Representator = (RelationshipVisualRepresentation)TargetRepresentation;
}
CentralSymbol = OriginRepresentation.MainSymbol;
InitialPosition = CentralSymbol.BaseCenter;
}
VisualConnector TargetConnector = null;
VisualConnector OriginAutoRefConnector = null;
if (TargetRepresentation != null)
{
TargetConnector = new VisualConnector(Representator, WorkingLink, CentralSymbol, TargetRepresentation.MainSymbol, InitialPosition, TargetPosition);
if (WorkingRelationship == PotentialOriginRelationship)
{
OriginAutoRefConnector = CentralSymbol.OriginConnections.FirstOrDefault(conn => conn.OriginSymbol == TargetRepresentation.MainSymbol);
}
}
if (CreatingNewRelationship)
{
Representator.AddVisualPart(OriginConnector);
}
if (TargetConnector != null)
{
Representator.AddVisualPart(TargetConnector);
}
if (OriginAutoRefConnector != null)
{
Representator.BendAutoRefConnectors(OriginAutoRefConnector, TargetConnector);
}
Representator.Render();
}
DestinationComposite.UpdateVersion();
DestinationComposite.EditEngine.CompleteCommandVariation();
var InformedRelationship = WorkingRelationship;
if (WorkingRelationship == PotentialTargetRelationship &&
PotentialOriginRelationship != null)
{
InformedRelationship = PotentialOriginRelationship;
}
return(OperationResult.Success(InformedRelationship, null, null, CentralSymbol.OwnerRepresentation, EditInPlace));
}
