/// <summary>
/// Instantiates an existent Domain from the supplied Uri.
/// </summary>
/// <param name="DomainLocation">Optional location of an existent Domain.</param>
/// <returns>Opened root Domain, plus possible error-message.</returns>
public static Tuple <Domain, string> MaterializeDomain(Uri DomainLocation = null)
{
// Load Domain's document package from Uri
Tuple <ISphereModel, string> Result = null;
try
{
Result = LoadFromLocation <ISphereModel>(FileDataType.FileTypeDomain.Name, DomainLocation, DomainsManager.DomainDocumentUri);
}
catch (Exception Problem)
{
Console.WriteLine("Cannot load Domain from '{0}'.", DomainLocation.LocalPath);
AppExec.LogException(Problem);
return(Tuple.Create <Domain, string>(null, Problem.Message));
}
var Content = Result.Item1;
if (Content == null)
{
return(Tuple.Create <Domain, string>(null, Result.Item2));
}
var RootDomain = Content as Domain;
if (RootDomain == null)
{
throw new ExternalAnomaly("Cannot load Domain from the specified location.", DomainLocation);
}
ModelFixes.ApplyModelFixes(RootDomain);
return(Tuple.Create(RootDomain, ""));
}
/// <summary>
/// Instantiates a new CompositionEngine, either for a new Composition or for one existent from supplied as a Uri.
/// </summary>
/// <param name="SourceLocation">Optional location of an existent Composition.</param>
/// <param name="RootDomain">Optional Domain to serve as root/basis of a new Composition.</param>
/// <param name="UseDomainCompositionAsTemplate">Indicates to use the Domain's Composition as Template instead of create an empty new one.</param>
/// <returns>Engine for edit a created/opened Composition plus possible error-message.</returns>
public static Tuple <CompositionEngine, string> Materialize(Uri SourceLocation = null, Domain RootDomain = null, bool UseDomainCompositionAsTemplate = false)
{
Tuple <CompositionEngine, string> Result = null;
var Engine = CompositionEngine.ActiveCompositionEngine;
Composition TargetComposition = null;
// IF LOADING FROM COMPOSITION FILE
if (SourceLocation != null)
{
/* Better ignore...
* if (RootDomain != null)
* throw new UsageAnomaly("Cannot specify root Domain for an already existent Composition."); */
try
{
// Load Composition's document package from Uri
var LoadResult = LoadFromLocation <ISphereModel>(FileDataType.FileTypeComposition.Name, SourceLocation, CompositionDocumentUri);
var Content = LoadResult.Item1;
if (Content == null)
{
return(Tuple.Create <CompositionEngine, string>(null, LoadResult.Item2));
}
TargetComposition = Content as Composition;
if (TargetComposition == null)
{
throw new ExternalAnomaly("Cannot load Composition from the specified location.", SourceLocation);
}
Engine.TargetComposition = TargetComposition;
Engine.Location = SourceLocation;
// IMPORTANT: This Engine will overwrite its Global-ID with that of the loaded Compositon.
Engine.GlobalId = TargetComposition.GlobalId;
TargetComposition.CompositionDefinitor.SetOwnerComposition(TargetComposition); // Reattach of owner Composition (which is non-serializable)
ModelFixes.ApplyModelFixes(TargetComposition.CompositionDefinitor);
TargetComposition.Initialize();
Result = Tuple.Create(Engine, "");
}
catch (Exception Problem)
{
Console.WriteLine("Cannot load Composition from '{0}'.\nProblem: {1}", SourceLocation.LocalPath, Problem);
AppExec.LogException(Problem);
Engine = null;
Result = Tuple.Create <CompositionEngine, string>(null, Problem.Message);
}
}
else
{
string DocName = Engine.Manager.DocumentsPrefix + Engine.Manager.GetNewDocumentNumber().ToString();
// IF LOADING FROM COMPOSITION AS TEMPLATE IN DOMAIN FILE
if (RootDomain != null && RootDomain.OwnerComposition != null && UseDomainCompositionAsTemplate)
{
try
{
TargetComposition = RootDomain.OwnerComposition;
TargetComposition.GlobalId = Guid.NewGuid();
/* Cancelled
* TargetComposition.Name = DocName;
* TargetComposition.TechName = DocName.TextToIdentifier();
* TargetComposition.Summary = ""; */
TargetComposition.Version = new VersionCard();
Engine.GlobalId = TargetComposition.GlobalId;
Engine.TargetComposition = TargetComposition;
Engine.Location = null;
TargetComposition.Initialize();
Result = Tuple.Create(Engine, "");
}
catch (Exception Problem)
{
Console.WriteLine("Cannot load Composition from '{0}'.\nProblem: {1}", SourceLocation.LocalPath, Problem);
AppExec.LogException(Problem);
Engine = null;
Result = Tuple.Create <CompositionEngine, string>(null, Problem.Message);
}
}
else // CREATING NEW EMPTY COMPOSITION
{
// IMPORTANT: The new Compositon will initialize its Global-ID with that of the Engine.
TargetComposition = new Composition(Engine, RootDomain.NullDefault(Domain.Create(Engine)), DocName, DocName.TextToIdentifier());
TargetComposition.CompositionDefinitor.SetOwnerComposition(TargetComposition); // Initial attach of owner Composition (which is non-serializable)
TargetComposition.Initialize();
Engine.TargetComposition = TargetComposition;
//- TargetComposition.RootView = TargetComposition.OpenCompositeView(TargetComposition.CompositionDefinitor);
Result = Tuple.Create(Engine, "");
}
}
return(Result);
}
