public static ConceptDefinition ConceptDefinitionCreate(Domain OwnerEntity, IList <ConceptDefinition> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_FREE, "create Concept Definitions"))
{
return(null);
}
var ItemsCount = OwnerEntity.RelationshipDefinitions.Count + EditedList.Count;
var MaxQuota = AppExec.CurrentLicenseEdition.TechName.SelectCorresponding(LicensingConfig.IdeaDefinitionsCreationQuotas);
if (!ProductDirector.ValidateEditionLimit(ItemsCount + 1, MaxQuota, "create", "Idea Definitions (Concept Defs. + Relationship Defs.)"))
{
return(null);
}
int NewNumber = EditedList.Count + 1;
string NewName = "ConceptDef" + NewNumber.ToString();
var Definitor = new ConceptDefinition(OwnerEntity, Domain.GenericConceptDefinition,
NewName, NewName.TextToIdentifier(), Shapes.RoundedRectangle);
if (ConceptDefinitionEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="OwnerComposition">Composition owning this Concept.</param>
/// <param name="Definitor">Definitor of the Concept.</param>
/// <param name="Name">Name of the Concept.</param>
/// <param name="TechName">Technical Name of the Concept.</param>
/// <param name="Summary">Summary of the Concept.</param>
/// <param name="Pictogram">Image representing the Concept.</param>
public Concept(Composition OwnerComposition, ConceptDefinition Definitor,
string Name, string TechName, string Summary = "", ImageSource Pictogram = null)
: base(OwnerComposition, Name, TechName, Summary, Pictogram)
{
this.ConceptDefinitor = Definitor.Assign();
this.CompositeContentDomain = Definitor.CompositeContentDomain ?? Definitor.OwnerDomain;
if (this.OwnerComposition != null && this.OwnerComposition.UsedDomains != null) // UsedDomains will only be null when creating the Composition (which is a Concept also)
{
this.OwnerComposition.UsedDomains.AddNew(Definitor.OwnerDomain);
}
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Changes the underlying definition to the specified one and propagate the necessary changes.
/// </summary>
public void ApplyConceptDefinitionChange(ConceptDefinition NewDefinition)
{
var PreviousDefinitor = this.ConceptDefinitor.Value;
if (PreviousDefinitor.IsEqual(NewDefinition))
{
return;
}
this.ConceptDefinitor = NewDefinition.Assign();
this.ApplyIdeaDefinitionChange(PreviousDefinitor); // Must be last, because updates graphics
}
public static ConceptDefinition ConceptDefinitionClone(Domain OwnerEntity, IList <ConceptDefinition> EditedList, ConceptDefinition ConceptDef)
{
var Result = new ConceptDefinition();
Result.PopulateFrom(ConceptDef, null, ECloneOperationScope.Deep);
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);
}
public static bool ConceptDefinitionEdit(Domain SourceDomain, IList <ConceptDefinition> EditedList, ConceptDefinition ConceptDef)
{
/*- if (!ProductDirector.ConfirmImmediateApply("Concept Definition", "DomainEdit.ConceptDefinition", "ApplyDialogChangesDirectly"))
* return false; */
var CurrentWindow = Display.GetCurrentWindow();
CurrentWindow.Cursor = Cursors.Wait;
var InstanceController = EntityInstanceController.AssignInstanceController(ConceptDef,
(current, previous, editpanels) =>
{
var CurrentDetailsEditor = (GlobalDetailsDefinitor)editpanels.First(editpanel => editpanel is GlobalDetailsDefinitor);
return(CurrentDetailsEditor.UpdateRelatedDetailDefinitions(ConceptDef));
});
var DetDefEd = GlobalDetailsDefinitor.CreateGlobalDetailsDefinitor(InstanceController.EntityEditor, ConceptDef);
InstanceController.StartEdit();
var VisualSymbolFormatter = new VisualSymbolFormatSubform("DefaultSymbolFormat");
var TemplateEd = new TemplateEditor();
TemplateEd.Initialize(SourceDomain, SourceDomain.CurrentExternalLanguage.TechName, typeof(Concept), ConceptDef,
IdeaDefinition.__OutputTemplates, Domain.__OutputTemplatesForConcepts, false,
Tuple.Create <string, ImageSource, string, Action <string> >("Insert predefined...", Display.GetAppImage("page_white_wrench.png"), "Inserts a system predefined Output-Template text, at the current selection.",
text => { var tpl = DomainServices.GetPredefinedOutputTemplate(); if (tpl != null)
{
TemplateEd.SteSyntaxEditor.ReplaceTextAtSelection(tpl);
}
}),
Tuple.Create <string, ImageSource, string, Action <string> >("Test", Display.GetAppImage("page_white_wrench.png"), "Test the Template against a source Concept.",
text => RememberedTemplateTestConcept[SourceDomain.OwnerComposition] =
TemplateTester.TestTemplate(typeof(Concept), ConceptDef, IdeaDefinition.__OutputTemplates.Name,
ConceptDef.GetGenerationFinalTemplate(TemplateEd.CurrentTemplate.Language, text, TemplateEd.ChbExtendsBaseTemplate.IsChecked.IsTrue()),
SourceDomain.OwnerComposition,
RememberedTemplateTestConcept.GetValueOrDefault(SourceDomain.OwnerComposition)
.NullDefault(SourceDomain.OwnerComposition.CompositeIdeas.OrderBy(idea => idea.Name)
.FirstOrDefault(idea => idea.IdeaDefinitor == ConceptDef)
.NullDefault(SourceDomain.OwnerComposition.DeclaredIdeas
.FirstOrDefault(idea => idea is Concept))))));
var TemplateTab = TabbedEditPanel.CreateTab(DomainServices.TABKEY_DEF_OUTTEMPLATE, "Output-Templates", "Definitions of Output-Templates", TemplateEd);
var SpecTabs = General.CreateList(
TabbedEditPanel.CreateTab(DomainServices.TABKEY_DEF_ARRANGE, "Arrange", "Settings for relate and group ideas.",
new ArrangeTabForConceptDef(ConceptDef)),
TabbedEditPanel.CreateTab(DomainServices.TABKEY_DEF_FORMAT, "Symbol format", "Definition for the Symbol format.",
VisualSymbolFormatter),
TabbedEditPanel.CreateTab(DomainServices.TABKEY_DEF_DETAILS, "Details", "Details definition.", DetDefEd),
TemplateTab);
var ExtraGeneralContentsPanel = new Grid();
ExtraGeneralContentsPanel.ColumnDefinitions.Add(new ColumnDefinition());
ExtraGeneralContentsPanel.ColumnDefinitions.Add(new ColumnDefinition());
var ExtraGenContentPanelLeft = new StackPanel();
Grid.SetColumn(ExtraGenContentPanelLeft, 0);
ExtraGeneralContentsPanel.Children.Add(ExtraGenContentPanelLeft);
var ExtraGenContentPanelRight = new StackPanel();
Grid.SetColumn(ExtraGenContentPanelRight, 1);
ExtraGeneralContentsPanel.Children.Add(ExtraGenContentPanelRight);
ExtraGenContentPanelLeft = new StackPanel();
ExtraGenContentPanelLeft.Width = 316;
ExtraGeneralContentsPanel.Children.Add(ExtraGenContentPanelLeft);
var Expositor = new EntityPropertyExpositor(ConceptDefinition.__IsComposable.TechName);
Expositor.LabelMinWidth = 130;
ExtraGenContentPanelLeft.Children.Add(Expositor);
Expositor = new EntityPropertyExpositor(ConceptDefinition.__IsVersionable.TechName);
Expositor.LabelMinWidth = 130;
ExtraGenContentPanelLeft.Children.Add(Expositor);
Expositor = new EntityPropertyExpositor(ConceptDefinition.__RepresentativeShape.TechName);
Expositor.LabelMinWidth = 130;
ExtraGenContentPanelLeft.Children.Add(Expositor);
Expositor.PostCall(expo =>
{
var Combo = expo.ValueEditor as ComboBox;
if (Combo != null)
{
var Panel = new FrameworkElementFactory(typeof(WrapPanel));
Panel.SetValue(WrapPanel.WidthProperty, 810.0);
Panel.SetValue(WrapPanel.ItemWidthProperty, 200.0);
// Don't work as expected: Panel.SetValue(WrapPanel.OrientationProperty, Orientation.Vertical);
var Templ = new ItemsPanelTemplate(Panel);
Combo.ItemsPanel = Templ;
}
}, true);
Expositor = new EntityPropertyExpositor(ConceptDefinition.__PreciseConnectByDefault.TechName);
Expositor.LabelMinWidth = 130;
ExtraGenContentPanelLeft.Children.Add(Expositor);
var ClosuredExpositor = new EntityPropertyExpositor(IdeaDefinition.__Cluster.TechName);
ClosuredExpositor.LabelMinWidth = 130;
ExtraGenContentPanelRight.Children.Add(ClosuredExpositor);
var PropCtl = InstanceController.GetPropertyController(IdeaDefinition.__Cluster.TechName);
PropCtl.ComplexOptionsProviders =
Tuple.Create <IRecognizableElement, Action <object> >(
new SimplePresentationElement("Edit Clusters", "EditClusters", "Edit Clusters", Display.GetAppImage("def_clusters.png")),
obj =>
{
if (DomainServices.DefineDomainIdeaDefClusters(SourceDomain, DomainServices.TABKEY_IDEF_CLUSTER_CONCEPT))
{
ClosuredExpositor.RetrieveAvailableItems();
}
}).IntoArray();
var EditPanel = Display.CreateEditPanel(ConceptDef, SpecTabs, true, null, Display.TABKEY_TECHSPEC + General.STR_SEPARATOR + DomainServices.TABKEY_DEF_OUTTEMPLATE,
true, false, true, true, ExtraGeneralContentsPanel);
EditPanel.Loaded +=
((sender, args) =>
{
var OwnerWindow = EditPanel.GetNearestVisualDominantOfType <Window>();
OwnerWindow.MinWidth = 770;
OwnerWindow.MinHeight = 550;
OwnerWindow.PostCall(wnd => CurrentWindow.Cursor = Cursors.Arrow);
});
if (IdeaDefinition.__OutputTemplates.IsAdvanced)
{
EditPanel.ShowAdvancedMembersChanged +=
((show) =>
{
TemplateTab.SetVisible(show);
if (!show)
{
var OwnerTabControl = TemplateTab.GetNearestDominantOfType <TabControl>();
if (OwnerTabControl.SelectedItem == TemplateTab)
{
OwnerTabControl.SelectedIndex = 0;
}
}
});
}
var Previewer = new VisualElementPreviewer(VisualSymbolFormatter.VisualElementFormatter.ExpoLineBrush,
VisualSymbolFormatter.VisualElementFormatter.ExpoLineThickness,
VisualSymbolFormatter.VisualElementFormatter.ExpoLineDash,
VisualSymbolFormatter.VisualElementFormatter.ExpoMainBackground);
Previewer.AttachSource(ConceptDef);
Previewer.Margin = new Thickness(4);
EditPanel.HeaderContent = Previewer;
var Result = InstanceController.Edit(EditPanel, "Edit Concept Definition - " + ConceptDef.ToString(), true, null,
CONDEFWND_INI_WIDTH, CONDEFWND_INI_HEIGHT).IsTrue();
return(Result);
}
public static bool ConceptDefinitionDelete(Domain OwnerEntity, IList <ConceptDefinition> EditedList, ConceptDefinition ConceptDef)
{
var Result = Display.DialogMessage("Confirmation", "Are you sure you want to Delete the '" + ConceptDef.Name + "' Concept Definition?",
EMessageType.Question, System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxResult.No);
return(Result == MessageBoxResult.Yes);
}
private static Concept CreateConceptForPaste(View TargetView, Point TargetPosition, ConceptDefinition ConceptDef, bool StartEdit = false)
{
var Creation = ConceptCreationCommand.CreateConcept(TargetView.OwnerCompositeContainer, ConceptDef,
TargetView, TargetPosition, 0, 0, true);
if (Creation == null || !Creation.WasSuccessful)
{
return(null);
}
if (StartEdit)
{
TargetView.Presenter.PostCall(pres => TargetView.EditInPlace(Creation.Result.MainSymbol));
}
return(Creation.Result);
}
/// <summary>
/// Create a value set from an enumeration
/// </summary>
public ValueSet CreateValueSetFromEnum(Type enumType)
{
// Does this have Everest attributes?
if (enumType.GetCustomAttribute <StructureAttribute>() != null)
{
return(CreateValueFromEverestEnum(enumType));
}
else
{
ValueSet retVal = new ValueSet();
var baseUri = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.BaseUri.ToString();
// XmlType?
XmlTypeAttribute xTypeAtt = enumType.GetCustomAttribute <XmlTypeAttribute>();
DescriptionAttribute descriptionAtt = enumType.GetCustomAttribute <DescriptionAttribute>();
retVal.Name = enumType.Name;
retVal.Identifier = String.Format("{0}/ValueSet/@{1}", baseUri, enumType.Name);
retVal.Version = enumType.Assembly.GetName().Version.ToString();
retVal.Id = retVal.Identifier;
retVal.VersionId = retVal.Version;
// Description
if (descriptionAtt != null)
{
retVal.Description = descriptionAtt.Description;
}
// Use the company attribute
var companyAtt = enumType.Assembly.GetCustomAttribute <AssemblyCompanyAttribute>();
if (companyAtt != null)
{
retVal.Publisher = companyAtt.Company;
}
// Date of the assembly file
if (!String.IsNullOrEmpty(enumType.Assembly.Location) && File.Exists(enumType.Assembly.Location))
{
retVal.Date = new SVC.Messaging.FHIR.DataTypes.DateOnly()
{
DateValue = new FileInfo(enumType.Assembly.Location).LastWriteTime
}
}
;
retVal.Timestamp = retVal.Date.DateValue.Value;
retVal.Status = new SVC.Messaging.FHIR.DataTypes.PrimitiveCode <string>("testing");
// Definition
retVal.Define = new ValueSetDefinition();
if (xTypeAtt != null)
{
retVal.Define.System = new Uri(String.Format("{0}#{1}", xTypeAtt.Namespace, xTypeAtt.TypeName));
}
else
{
retVal.Define.System = new Uri(String.Format("{0}/ValueSet/@{1}", baseUri, enumType.Name));
}
// Now populate
foreach (var value in enumType.GetFields(BindingFlags.Static | BindingFlags.Public))
{
var definition = new ConceptDefinition();
definition.Code = new SVC.Messaging.FHIR.DataTypes.PrimitiveCode <string>(MARC.Everest.Connectors.Util.ToWireFormat(value.GetValue(null)));
definition.Abstract = false;
descriptionAtt = value.GetCustomAttribute <DescriptionAttribute>();
if (descriptionAtt != null)
{
definition.Display = descriptionAtt.Description;
}
retVal.Define.Concept.Add(definition);
}
return(retVal);
}
}
public ArrangeTabForConceptDef(ConceptDefinition ConceptDef)
: this()
{
this.ConceptDef = ConceptDef;
}
