public void CreateComposition(bool IsForDomainCreation = false)
{
var CurrentWindow = Display.GetCurrentWindow();
CurrentWindow.Cursor = Cursors.Wait;
var PreviousActiveDoc = this.WorkspaceDirector.ActiveDocument;
this.WorkspaceDirector.ActiveDocument = null; // Must deactive previous to create+activate the opening Composition.
CompositionEngine.CreateActiveCompositionEngine(this, this.Visualizer, IsForDomainCreation);
var Result = CompositionEngine.Materialize();
if (Result.Item1 == null)
{
CurrentWindow.Cursor = Cursors.Arrow;
Display.DialogMessage("Error!", "Cannot create new Composition.\n\nProblem: " + Result.Item2, EMessageType.Warning);
this.WorkspaceDirector.ActiveDocument = PreviousActiveDoc;
return;
}
// Start visual interactive editing and show document view.
this.WorkspaceDirector.LoadDocument(Result.Item1.TargetComposition);
Result.Item1.Start();
if (IsForDomainCreation)
{
Display.DialogMessage("Attention!",
"Domains are created with a base Composition.\n" +
"So, later it can be saved as the Domain's template.");
DomainServices.DomainEdit(Result.Item1.TargetComposition.CompositeContentDomain);
}
else
{
var EditOnNewComposition = AppExec.GetConfiguration <bool>("Composition", "EditOnNewComposition", true);
if (EditOnNewComposition)
{
Result.Item1.EditCompositionProperties();
}
}
CurrentWindow.Cursor = Cursors.Arrow;
}
/// <summary>
/// Exposes the commands which can be consumed.
/// </summary>
public void ExposeCommands()
{
WorkCommand ExposedWorkCommand = null;
// =========================================================================================================
SimpleElement ExposedArea = new SimpleElement("Domain", "Domain");
SimpleElement ExposedGroup = new SimpleElement("Definition", "Definition");
this.CommandAreas_.Add(ExposedArea);
this.CommandGroups_.PutIntoSublist(ExposedArea.TechName, ExposedGroup);
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("EditDomain");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DomainEdit(Doc.TargetComposition.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Edit Domain...", ExposedWorkCommand.Name, "Edit the Domain of the current Composition", "book_edit.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
/* this would confuse the user? */
ExposedWorkCommand = new GenericCommand("NewDomain");
ExposedWorkCommand.Apply = (par => ProductDirector.CompositionDirector.CreateComposition(true));
ExposedWorkCommand.CanApply = (par => true);
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("New Domain", ExposedWorkCommand.Name, "Creates a new Domain (and its empty template Composition).", "book_star.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
ExposedWorkCommand = new GenericCommand("OpenDomain");
ExposedWorkCommand.Apply = (par => ProductDirector.CompositionDirector.OpenDomainAndCreateCompositionOfIt(true));
ExposedWorkCommand.CanApply = (par => true);
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Open Domain", ExposedWorkCommand.Name, "Opens a Domain for editing (and creates its emtpy template Composition).", "folder_book.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("SaveDomainAs");
ExposedWorkCommand.Apply =
(par =>
{
var Engine = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Engine == null)
{
return;
}
var Confirmation = Display.DialogMessage("Confirmation", "Save also the current Composition as Domain's Template for create new ones?\n" +
"(Note: Later, it can be used or just start empty Compositions)",
EMessageType.Question, MessageBoxButton.YesNoCancel, MessageBoxResult.Yes);
if (Confirmation == MessageBoxResult.Cancel || Confirmation == MessageBoxResult.None)
{
return;
}
var SaveTemplate = (Confirmation == MessageBoxResult.Yes);
//T Console.WriteLine("Saving Domain as...");
var InitialRoute = (Engine.DomainLocation != null
? Engine.DomainLocation.LocalPath
: (Engine.FullLocation == null
? Path.Combine(AppExec.UserDataDirectory,
Engine.TargetComposition.CompositeContentDomain.TechName)
: Path.Combine(Path.GetDirectoryName(Engine.FullLocation.LocalPath),
Engine.TargetComposition.CompositeContentDomain.TechName)));
var TargetRoute = Display.DialogGetSaveFile("Save Domain as",
FileDataType.FileTypeDomain.Extension,
FileDataType.FileTypeDomain.FilterForSave,
InitialRoute);
if (TargetRoute == null)
{
return;
}
var CurrentWindow = Display.GetCurrentWindow();
CurrentWindow.Cursor = Cursors.Wait;
var TargetDomain = Engine.TargetComposition.CompositeContentDomain;
Visual Snapshot = null;
if (SaveTemplate && TargetDomain.OwnerComposition.ActiveView != null)
{
Snapshot = TargetDomain.OwnerComposition.ActiveView
.ToVisualSnapshot(DocumentEngine.PART_SNAPSHOT_WIDTH, DocumentEngine.PART_SNAPSHOT_HEIGHT);
}
TargetDomain.SetTemplateSaving(SaveTemplate);
var Result = DocumentEngine.StoreToLocation <Domain>(TargetDomain, Domain.__ClassDefinitor.Name,
TargetDomain.Classification.ContentTypeCode,
TargetRoute, DomainDocumentUri, true, false,
TargetDomain, Snapshot);
if (!Result.IsAbsent())
{
CurrentWindow.Cursor = Cursors.Arrow;
Display.DialogMessage("Error!", "Cannot save Domain.\n\nProblem: " + Result, EMessageType.Warning);
return;
}
Engine.DomainLocation = TargetRoute;
this.WorkspaceDirector.ShellProvider.RefreshSelection();
CurrentWindow.Cursor = Cursors.Arrow;
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Save Domain As", ExposedWorkCommand.Name, "Saves the current Domain to the specified file.", "book_saveas.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
// Ordered list of quick access commands
this.QuickExposedCommands.Add(this.CommandExpositors["NewDomain"]);
this.QuickExposedCommands.Add(this.CommandExpositors["OpenDomain"]);
this.QuickExposedCommands.Add(this.CommandExpositors["EditDomain"]);
this.QuickExposedCommands.Add(this.CommandExpositors["SaveDomainAs"]);
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Concept Definitions...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainConcepts(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Concept Defs...", ExposedWorkCommand.Name, "Edit the Concept Definitions of the Domain", "imtc_concept.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Relationship Definitions...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainRelationships(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Relationship Defs...", ExposedWorkCommand.Name, "Edit the Relationship Definitions of the Domain", "imtc_relationship.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Link-Role Variant Definitions...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainLinkRoleVariants(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Link-Role Variant Defs...", ExposedWorkCommand.Name, "Edit the Link-Role Variant Definitions of the Domain", "link_role_variants.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Marker Definitions...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainMarkers(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Marker Defs...", ExposedWorkCommand.Name, "Edit the Marker Definitions of the Domain", "award_star_edit.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Table-Structure Definitions...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.EditDomainTableDefinitions(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Table-Structure Defs...", ExposedWorkCommand.Name, "Edit the Table-Structure Definitions of the Domain", "table_alter.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
ExposedWorkCommand = new GenericCommand("Base Tables...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.EditDomainBaseTables(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Base Tables...", ExposedWorkCommand.Name, "Edit the Base Tables of the Domain", "table_multiple.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("External Languages...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainExternalLanguages(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("External Languages...", ExposedWorkCommand.Name, "Edit the External Languages declared for the Domain", "page_white_code_red.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
ExposedWorkCommand = new GenericCommand("Idea-Def Clusters...");
ExposedWorkCommand.Apply =
(par =>
{
var Doc = (CompositionEngine)this.WorkspaceDirector.ActiveDocumentEngine;
if (Doc == null)
{
return;
}
DomainServices.DefineDomainIdeaDefClusters(Doc.CurrentView.OwnerCompositeContainer.CompositeContentDomain);
});
ExposedWorkCommand.CanApply = (par => (this.WorkspaceDirector.ActiveDocument != null));
this.CommandExpositors.Add(ExposedWorkCommand.Name, new WorkCommandExpositor("Idea-Def Clusters...", ExposedWorkCommand.Name, "Edit the Idea-Definition Clusters of the Domain", "def_clusters.png",
EShellCommandCategory.Document, ExposedArea.TechName, ExposedGroup.TechName, ExposedWorkCommand));
// -------------------------------------------------------------------------------------
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Goes to the specified object either in a diagram View and/or its maintenance editor.
/// Returns indication of successful goto.
/// </summary>
public bool GoToObject(object Target)
{
if (Target is Idea)
{
var TargetIdea = Target as Idea;
var Representator = TargetIdea.VisualRepresentators.FirstOrDefault();
if (Representator == null)
{
return(false);
}
Representator.DisplayingView.Engine.ShowView(Representator.DisplayingView);
Representator.DisplayingView.Presenter.PostCall(
vpres =>
{
vpres.OwnerView.Manipulator.ApplySelection(Representator.MainSymbol);
vpres.OwnerView.Presenter.BringIntoView(Representator.MainSymbol.BaseArea);
});
return(true);
}
if (Target is VisualComplement)
{
var TargetComplement = Target as VisualComplement;
var TargetView = TargetComplement.GetDisplayingView();
TargetView.Engine.ShowView(TargetView);
TargetView.Presenter.PostCall(
vpres =>
{
vpres.OwnerView.Manipulator.ApplySelection(TargetComplement);
vpres.OwnerView.Presenter.BringIntoView(TargetComplement.BaseArea);
});
return(true);
}
if (Target is View)
{
var TargetView = Target as View;
CompositionEngine.EditViewProperties(TargetView);
return(true);
}
if (Target is Composition)
{
var TargetCompo = Target as Composition;
TargetCompo.Engine.EditCompositionProperties();
return(true);
}
if (Target is Domain)
{
var TargetDomain = Target as Domain;
DomainServices.DomainEdit(TargetDomain);
return(true);
}
if (Target is ConceptDefinition)
{
var TargetDef = Target as ConceptDefinition;
DomainServices.DefineDomainConcepts(TargetDef.OwnerDomain, TargetDef);
return(true);
}
if (Target is RelationshipDefinition)
{
var TargetDef = Target as RelationshipDefinition;
DomainServices.DefineDomainRelationships(TargetDef.OwnerDomain, TargetDef);
return(true);
}
if (Target is MarkerDefinition)
{
var TargetDef = Target as MarkerDefinition;
DomainServices.DefineDomainMarkers(this.TargetComposition.CompositeContentDomain, TargetDef);
return(true);
}
if (Target is TableDefinition)
{
var TargetDef = Target as TableDefinition;
DomainServices.EditDomainTableDefinitions(TargetDef.OwnerDomain, TargetDef);
return(true);
}
if (Target is SimplePresentationElement) // Link-Role Variant
{
var TargetDef = Target as SimplePresentationElement;
if (this.TargetComposition.CompositeContentDomain.LinkRoleVariants.Contains(TargetDef))
{
DomainServices.DefineDomainLinkRoleVariants(this.TargetComposition.CompositeContentDomain, TargetDef);
return(true);
}
}
// PENDING: Find "Base Tables" and "Descriptors"
// (would require to have two target objects in the finding operation, one for the owner, other for the descriptor).
return(false);
}
public void OpenDomainAndCreateCompositionOfIt(bool IsForOpenDomain, Uri Location = null, bool CanEditPropertiesOfNewCompo = true)
{
bool OpenCompositionStoredWithDomain = true;
if (IsForOpenDomain)
{
Console.WriteLine("Opening Domain (and creating its Composition)...");
}
else
{
Console.WriteLine("Creating new Composition of Domain...");
}
if (Location == null)
{
var Selection = DomainSelector.SelectDomain(AppExec.ApplicationSpecificDefinitionsDirectory,
(IsForOpenDomain ? null :
"Select Domain file to create Composition..."),
!IsForOpenDomain);
if (Selection == null)
{
return;
}
Location = Selection.Item1;
OpenCompositionStoredWithDomain = (IsForOpenDomain || Selection.Item2);
// If 'Basic Domain' was selected...
if (Location == null)
{
this.CreateComposition();
return;
}
/* Previously...
* Location = Display.DialogGetOpenFile("Select Domain",
* FileDataType.FileTypeDomain.Extension,
* FileDataType.FileTypeDomain.FilterForOpen); */
}
if (Location == null)
{
return;
}
/* NOT APPLICABLE FOR DOMAINS
* // Switch to document if already opened
* var CurrentlyOpenedDoc = this.WorkspaceDirector.Documents
* .FirstOrDefault(doc => doc.DocumentEditEngine.Location != null && !doc.DocumentEditEngine.Location.LocalPath.IsAbsent()
* && doc.DocumentEditEngine.Location.LocalPath == Location.LocalPath);
*
* if (CurrentlyOpenedDoc != null)
* {
* this.WorkspaceDirector.ActivateDocument(CurrentlyOpenedDoc);
* return;
* }
*/
/* unnecessary
* if (IsForOpenDomain)
* Application.Current.MainWindow.PostCall(mainwin =>
* Display.DialogMessage("Attention!",
* "Domains must are created with a base Composition.\n" +
* "So, later it can be saved as the Domain's template."); */
var CurrentWindow = Display.GetCurrentWindow();
CurrentWindow.Cursor = Cursors.Wait;
var PreviousActiveDoc = this.WorkspaceDirector.ActiveDocument;
this.WorkspaceDirector.ActiveDocument = null; // Must deactive previous to create+activate the opening Composition.
CompositionEngine.CreateActiveCompositionEngine(this, this.Visualizer, IsForOpenDomain);
var DomainLoad = CompositionEngine.MaterializeDomain(Location);
if (DomainLoad.Item1 == null)
{
CurrentWindow.Cursor = Cursors.Arrow;
Display.DialogMessage("Error!", "Cannot open Domain.\n\nProblem: " + DomainLoad.Item2, EMessageType.Warning);
this.WorkspaceDirector.ActiveDocument = PreviousActiveDoc;
return;
}
var Result = CompositionEngine.Materialize(null, DomainLoad.Item1, OpenCompositionStoredWithDomain);
if (Result.Item1 == null)
{
CurrentWindow.Cursor = Cursors.Arrow;
Display.DialogMessage("Error!", "Cannot create Composition of Domain.\n\nProblem: " + Result.Item2, EMessageType.Warning);
this.WorkspaceDirector.ActiveDocument = PreviousActiveDoc;
return;
}
// Start visual interactive editing and show document view.
Result.Item1.DomainLocation = Location;
this.WorkspaceDirector.LoadDocument(Result.Item1.TargetDocument);
Result.Item1.Start();
if (IsForOpenDomain)
{
DomainServices.DomainEdit(Result.Item1.TargetComposition.CompositeContentDomain);
}
else
if (CanEditPropertiesOfNewCompo)
{
var EditOnNewComposition = AppExec.GetConfiguration <bool>("Composition", "EditOnNewComposition", true);
if (EditOnNewComposition)
{
Result.Item1.EditCompositionProperties();
}
}
CurrentWindow.Cursor = Cursors.Arrow;
}