public ComplementCreationCommand(CompositionEngine TargetEngine, SimplePresentationElement ComplementKind)
: base("Create Complement '" + ComplementKind.Name + "'.")
{
this.ContextEngine = TargetEngine;
this.ComplementKind = ComplementKind;
this.Initialize();
}
public static SimplePresentationElement VariantDefinitionCreate(Domain OwnerEntity, IList <SimplePresentationElement> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_PROFESSIONAL, "create Link-Role Variant Definitions"))
{
return(null);
}
int NewNumber = EditedList.Count + 1;
string NewName = "VariantDef" + NewNumber.ToString();
var Definitor = new SimplePresentationElement(NewName, NewName.TextToIdentifier());
if (VariantDefinitionEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
/// <summary>
/// Constructor.
/// </summary>
public VisualConnectorsFormat(SimplePresentationElement DefaultTailVariant, string DefaultTailPlug,
SimplePresentationElement DefaultHeadVariant, string DefaultHeadPlug,
Brush LineBrush, DashStyle LineDash = null,
double LineThickness = DEFAULT_LINE_THICKNESS, double Opacity = 1.0, Brush BackgroundBrush = null,
EPathStyle PathStyle = EPathStyle.SinglelineStraight, EPathCorner PathCorner = EPathCorner.Rounded,
PenLineCap LineCap = PenLineCap.Round, PenLineJoin LineJoin = PenLineJoin.Round)
: base(BackgroundBrush, LineBrush, LineThickness, Opacity, LineDash, LineCap, LineJoin)
{
General.ContractRequiresNotNull(DefaultHeadVariant, DefaultTailVariant, LineBrush);
General.ContractRequiresNotAbsent(DefaultHeadPlug, DefaultTailPlug);
this.HeadPlugs = new EditableDictionary <SimplePresentationElement, string>(__HeadPlugs.TechName, this);
this.HeadPlugs.Add(DefaultHeadVariant, DefaultHeadPlug);
this.TailPlugs = new EditableDictionary <SimplePresentationElement, string>(__TailPlugs.TechName, this);
this.TailPlugs.Add(DefaultTailVariant, DefaultTailPlug);
this.PathStyle = PathStyle;
this.PathCorner = PathCorner;
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Indicates whether this Relationship Definition can link supplied origin and target Ideas,
/// considering its linking roles associability, variants and multiconnectability.
/// </summary>
public OperationResult <bool> CanLink(IdeaDefinition OriginIdea, IdeaDefinition TargetIdea,
SimplePresentationElement OriginVariant = null, SimplePresentationElement TargetVariant = null)
{
General.ContractRequiresNotNull(OriginIdea, TargetIdea);
if (!ValidateAssociabililty(OriginIdea, TargetIdea))
{
return(OperationResult.Failure <bool>("Origin and Target Ideas are not linkable."));
}
if (!ValidateVariants(OriginIdea, OriginVariant, TargetIdea, TargetVariant))
{
return(OperationResult.Failure <bool>("Variants are invalid for the intended linking."));
}
if (!ValidateMultiConnectability(OriginIdea, TargetIdea))
{
return(OperationResult.Failure <bool>("Already exists one non-multiconnectable role used."));
}
return(OperationResult.Success(true));
}
public void VariantsUpdater(SimplePresentationElement Variant, SimplePresentationElement Plug)
{
// IMPORTANT: Notice the use of this.ParentRelDef (the edited Agent) instead of
// this.TargetLinkRoleDef.OwnerRelationshipDef (the original Entity).
var ConnFmt = this.ParentRelDef.DefaultConnectorsFormat;
IDictionary <SimplePresentationElement, string> TargetCollection = null;
if (this.TargetLinkRoleDef.RoleType == ERoleType.Target)
{
TargetCollection = ConnFmt.HeadPlugs;
}
else
{
TargetCollection = ConnFmt.TailPlugs;
}
TargetCollection.AddOrReplace(Variant, Plug.TechName);
// PENDING: In the Editor update (at the whole Relationship Definition level),
// the unused Head and Tail Plugs per Variant should be deleted
// accordingly to the Link-Role-Def's Allowed Variants.
}
private static void PasteCreateComplement(View TargetView, Point TargetPosition, object Content)
{
OperationResult <VisualComplement> Complement = null;
SimplePresentationElement Kind = null;
string Property = null;
if (Content is BitmapSource)
{
Kind = Domain.ComplementDefImage;
Property = VisualComplement.PROP_FIELD_IMAGE;
}
else
{
if (Content is byte[])
{
Content = ((byte[])Content).BytesToString();
}
else
if (!(Content is string))
{
Content = Content.ToStringAlways();
}
Kind = Domain.ComplementDefText;
Property = VisualComplement.PROP_FIELD_TEXT;
}
Complement = ComplementCreationCommand.CreateComplement(TargetView.OwnerCompositeContainer, Kind, TargetView, null, TargetPosition);
if (Complement != null && Complement.WasSuccessful)
{
// IMPORTANT: The whole Content MUST be assigned in order to be undoable/readoable.
Complement.Result.SetPropertyField(Property, Content);
Complement.Result.Render();
}
}
protected bool ValidateVariants(IdeaDefinition OriginIdea, SimplePresentationElement OriginVariant,
IdeaDefinition TargetIdea, SimplePresentationElement TargetVariant)
{
// PENDING
return(true);
}
/// <summary>
/// Constructor
/// </summary>
public MarkerAssignment(EntityEditEngine Engine, MarkerDefinition Definitor, SimplePresentationElement Descriptor = null)
{
this.Definitor = Definitor;
this.Descriptor = Descriptor;
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
public static OperationResult <VisualComplement> CreateComplement(Idea DestinationComposite, SimplePresentationElement Kind, View TargetView,
VisualSymbol TargetSymbol, Point Position, double InitialWidth = 0.0)
{
General.ContractRequiresNotNull(DestinationComposite, Kind, TargetView);
if (DestinationComposite.IdeaDefinitor.CompositeContentDomain == null)
{
return(OperationResult.Failure <VisualComplement>("Destination Container doest not accept Composite-Content.", DestinationComposite));
}
DestinationComposite.EditEngine.StartCommandVariation("Create Complement");
VisualComplement NewComplement = null;
var Owner = (Kind.TechName.IsOneOf(Domain.ComplementDefCallout.TechName, Domain.ComplementDefQuote.TechName,
Domain.ComplementDefGroupRegion.TechName, Domain.ComplementDefGroupLine.TechName)
? Ownership.Create <View, VisualSymbol>(TargetSymbol)
: Ownership.Create <View, VisualSymbol>(TargetView));
NewComplement = new VisualComplement(Kind, Owner, Position, InitialWidth);
if (!Owner.IsGlobal && TargetSymbol != null)
{
TargetSymbol.AddComplement(NewComplement);
}
TargetView.PutComplement(NewComplement);
DestinationComposite.UpdateVersion();
DestinationComposite.EditEngine.CompleteCommandVariation();
return(OperationResult.Success(NewComplement));
}
public static bool VariantDefinitionDelete(Domain OwnerEntity, IList <SimplePresentationElement> EditedList, SimplePresentationElement VariantDef)
{
var Result = Display.DialogMessage("Confirmation", "Are you sure you want to Delete the '" + VariantDef.Name + "' Variant Definition?",
EMessageType.Question, System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxResult.No);
return(Result == MessageBoxResult.Yes);
}
public static bool VariantDefinitionEdit(Domain OwnerEntity, IList <SimplePresentationElement> EditedList, SimplePresentationElement VariantDef)
{
/*- if (!ProductDirector.ConfirmImmediateApply("Variant Definition", "DomainEdit.VariantDefinition", "ApplyDialogChangesDirectly"))
* return false; */
var InstanceController = EntityInstanceController.AssignInstanceController(VariantDef);
InstanceController.StartEdit();
var EditPanel = Display.CreateEditPanel(VariantDef, null, true, null, null, true, false, true /*, Expositor*/);
return(InstanceController.Edit(EditPanel, "Edit Link-Role Variant Definition - " + VariantDef.ToString()).IsTrue());
}
public static SimplePresentationElement VariantDefinitionClone(Domain OwnerEntity, IList <SimplePresentationElement> EditedList, SimplePresentationElement VariantDef)
{
var Result = VariantDef.CreateClone(ECloneOperationScope.Deep, null);
var NamesWereEquivalent = (Result.TechName == Result.Name.TextToIdentifier());
Result.Name = Result.Name + "(copy)"; // Auto-update of TechName when equivalents
if (!NamesWereEquivalent)
{
Result.TechName = Result.TechName + "_copy";
}
return(Result);
}
/// <summary>
/// Constructor
/// </summary>
public RoleBasedLink(Relationship RelationshipOwner, Idea AssociatedIdea, LinkRoleDefinition RoleDefinitor, SimplePresentationElement RoleVariant)
: base()
{
this.OwnerRelationship = RelationshipOwner;
this.AssociatedIdea = AssociatedIdea;
this.RoleDefinitor = RoleDefinitor;
this.RoleVariant = RoleVariant;
this.AssociatedIdea.AssociatingLinks.Add(this);
}
