public static RelationshipDefinition RelationshipDefinitionCreate(Domain OwnerEntity, IList <RelationshipDefinition> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_FREE, "create Relationship Definitions"))
{
return(null);
}
var ItemsCount = OwnerEntity.ConceptDefinitions.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 = "RelationshipDef" + NewNumber.ToString();
var Definitor = new RelationshipDefinition(OwnerEntity, Domain.GenericRelationshipDefinition,
NewName, NewName.TextToIdentifier(), Shapes.Ellipse);
if (RelationshipDefinitionEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
public void CommandAbout_Executed(object sender, ExecutedRoutedEventArgs args)
{
string CommandName = ((RoutedCommand)args.Command).Name;
//T AppExec.LogMessage("The '" + CommandName + "' command has been invoked");
ProductDirector.ShowAbout();
}
public Product ReadProduct(ProductType productType)
{
ProductDirector productDirector = new ProductDirector();
IBuildProduct buildProduct = new BuildProduct(productType);
productDirector.Construct(buildProduct);
Product product = buildProduct.GetProduct();
return(product);
}
private void DetailsToolPanel_AddClicked(object arg1, RoutedEventArgs arg2)
{
/*- if (!ProductDirector.ConfirmImmediateApply("IdeaEditing.DetailAdd", "ApplyDialogChangesDirectly"))
* return; */
var DetailOptions = new List <IRecognizableElement>();
DetailOptions.Add(new SimplePresentationElement(AttachmentDetailDesignator.KindTitle, AttachmentDetailDesignator.KindName, AttachmentDetailDesignator.KindSummary, AttachmentDetailDesignator.KindPictogram));
DetailOptions.Add(new SimplePresentationElement(LinkDetailDesignator.KindTitle, LinkDetailDesignator.KindName, LinkDetailDesignator.KindSummary, LinkDetailDesignator.KindPictogram));
if (ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_LITE, "designate Table detail", false))
{
DetailOptions.Add(new SimplePresentationElement(TableDetailDesignator.KindTitle, TableDetailDesignator.KindName, TableDetailDesignator.KindSummary, TableDetailDesignator.KindPictogram));
}
var DetailToCreate = Display.DialogMultiOption("Designation of Detail", "Select the type of detail to be designated...", "",
null, true, TableDetailDesignator.KindName, DetailOptions.ToArray());
if (DetailToCreate == null)
{
return;
}
var SelectedDetailOption = DetailOptions.FirstOrDefault(det => det.TechName == DetailToCreate);
var DesignationName = SelectedDetailOption.Name + " - Detail Definition " + (this.DetailsSource.Count + 1).ToString();
DetailDefinitionCard NewEditCard = null;
var Owner = Ownership.Create <IdeaDefinition, Idea>(this.SourceDefinitor);
DetailDesignator CreatedDesignation = null;
if (DetailToCreate == TableDetailDesignator.KindName)
{
CreatedDesignation = DomainServices.CreateTableDesignation(this.SourceEngine, Owner, DesignationName);
}
else
if (DetailToCreate == AttachmentDetailDesignator.KindName)
{
CreatedDesignation = DomainServices.CreateAttachmentDesignation(Owner, DesignationName);
}
else
if (DetailToCreate == LinkDetailDesignator.KindName)
{
CreatedDesignation = DomainServices.CreateLinkDesignation(Owner, DesignationName);
}
if (CreatedDesignation == null)
{
return;
}
NewEditCard = new DetailDefinitionCard(false, new Assignment <DetailDesignator>(CreatedDesignation, this.DetailsSourceIsGlobal));
this.DetailsSource.Add(NewEditCard);
this.DetailsListBox.SelectedItem = NewEditCard;
}
/// <summary>
/// Constructor
/// </summary>
public MainWindow()
{
InitializeComponent();
this.InitializeUI();
ProductDirector.Initialize(this);
// Redirects catched unhandled exceptions to the application product
Application.Current.DispatcherUnhandledException +=
new System.Windows.Threading.DispatcherUnhandledExceptionEventHandler(ProductDirector.ApplicationUnhandledExceptionHandler);
}
public static void ShowGenerationFilePreview(Idea Source)
{
if (Source == null || Source.EditEngine == null)
{
return;
}
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_PROFESSIONAL, "Generate Files", false, new DateTime(2013, 6, 22)))
{
return;
}
try
{
EntityEditEngine.ActiveEntityEditor.ReadTechNamesAsProgramIdentifiers =
Source.OwnerComposition.CompositeContentDomain.GenerationConfiguration.UseTechNamesAsProgramIdentifiers;;
var Language = Source.IdeaDefinitor.OwnerDomain.ExternalLanguages.FirstOrDefault()
.NullDefault(Source.IdeaDefinitor.OwnerDomain.CurrentExternalLanguage);
if (Source.IdeaDefinitor.OwnerDomain.ExternalLanguages.Count > 1)
{
var LangTechName = Display.DialogMultiOption("Language selection", "Select the Language used to generate the preview", null, null, true,
Source.IdeaDefinitor.OwnerDomain.CurrentExternalLanguage.TechName,
Source.IdeaDefinitor.OwnerDomain.ExternalLanguages.ToArray());
if (LangTechName.IsAbsent())
{
return;
}
Language = Source.IdeaDefinitor.OwnerDomain.ExternalLanguages.First(lang => lang.TechName == LangTechName);
Source.IdeaDefinitor.OwnerDomain.CurrentExternalLanguage = Language;
}
var Preview = FileGenerator.GenerateFilePreview(Source, Language);
DialogOptionsWindow GenDialog = null;
var Previewer = new FileGenerationPreviewer(Preview.FileName, Preview.GeneratedText);
Display.OpenContentDialogWindow(ref GenDialog, "Generate from: " + Source.Name,
Previewer, 600, 700);
}
catch (Exception Problem)
{
Display.DialogMessage("Error!", "Cannot generate preview from the supplied Template and source object.\n\nProblem: " +
Problem.Message, EMessageType.Warning);
return;
}
finally
{
EntityEditEngine.ActiveEntityEditor.ReadTechNamesAsProgramIdentifiers = false;
}
}
public static void GenerateGlobalFiles(Composition Source)
{
if (Source == null || Source.EditEngine == null)
{
return;
}
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_PROFESSIONAL, "Generate Files", false, new DateTime(2013, 6, 22)))
{
return;
}
if (!GenerationManager.ConfigureAndStartGeneration(Source.OwnerComposition))
{
return;
}
var Title = "File Generation from " + Source.Name;
var Generator = new FileGenerator(Source.OwnerComposition, Source.OwnerComposition.CompositeContentDomain.CurrentExternalLanguage,
Source.IdeaDefinitor.OwnerDomain.GenerationConfiguration);
EntityEditEngine.ActiveEntityEditor.ReadTechNamesAsProgramIdentifiers =
Source.CompositeContentDomain.GenerationConfiguration.UseTechNamesAsProgramIdentifiers;;
var Started = ProgressiveThreadedExecutor <int> .Execute(Title, Generator.Generate,
(opresult) =>
{
EntityEditEngine.ActiveEntityEditor.ReadTechNamesAsProgramIdentifiers = false;
if (!opresult.WasSuccessful)
{
Display.DialogMessage("Generation not completed!", opresult.Message, EMessageType.Warning);
return;
}
if (opresult.Message != null)
{
Console.WriteLine(opresult.Message);
}
Display.DialogMessage("Generation completed", opresult.Message.AbsentDefault("File Generation successfully executed."));
});
if (!Started)
{
EntityEditEngine.ActiveEntityEditor.ReadTechNamesAsProgramIdentifiers = false;
}
}
/// <summary>
/// Window loaded event handler.
/// </summary>
private void Window_Loaded(object sender, RoutedEventArgs e)
{
AppExec.SetSourceOfDispatcherForUI(this.WinHeader);
// Finish visual adjustments
this.Width = this.Width.EnforceMaximum(SystemParameters.WorkArea.Width);
this.Height = this.Height.EnforceMaximum(SystemParameters.WorkArea.Height);
if (this.Left < 0)
{
this.Left = 0;
}
if (this.Top < 0)
{
this.Top = 0;
}
var InitialPaletteSupraContainerHeight = this.WinHeader.PaletteSupraContainer.ActualHeight;
var Delta = double.NaN;
this.WinHeader.PaletteSupraContainer.AtCanCollapseChanged =
((CanCollapse) =>
{
Delta = Delta.NaNDefault(97.0); // Previous = 75
var Offset = (Delta * (CanCollapse ? -1 : 1));
this.WorkingAreaBorder.Margin = new Thickness(this.WorkingAreaBorder.Margin.Left,
this.WorkingAreaBorder.Margin.Top + Offset,
this.WorkingAreaBorder.Margin.Right,
this.WorkingAreaBorder.Margin.Bottom);
var Engine = ProductDirector.WorkspaceDirector.ActiveDocumentEngine as CompositionEngine;
if (Engine == null || Engine.CurrentView == null)
{
return;
}
// Adjust visualization to not "jump"
Engine.CurrentView.Pan(double.NaN, Offset, false);
});
// Starts the application product
ProductDirector.Start();
}
public static TableDefinition TableDefinitionCreate(Domain OwnerEntity, IList <TableDefinition> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_PROFESSIONAL, "create Table-Structure Definitions"))
{
return(null);
}
int NewNumber = EditedList.Count + 1;
string NewName = "TableDef" + NewNumber.ToString();
var Definitor = new TableDefinition(OwnerEntity, NewName, NewName.TextToIdentifier());
if (TableDefinitionEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
public static MarkerDefinition MarkerDefinitionCreate(Domain OwnerEntity, IList <MarkerDefinition> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_LITE, "create Marker Definitions"))
{
return(null);
}
int NewNumber = EditedList.Count + 1;
string NewName = "MarkerDef" + NewNumber.ToString();
var Definitor = new MarkerDefinition(NewName, NewName.TextToIdentifier(), "", Display.GetAppImage("rosette.png"));
if (MarkerDefinitionEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
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);
}
public static ExternalLanguageDeclaration ExternalLanguageCreate(Domain OwnerEntity, IList <ExternalLanguageDeclaration> EditedList)
{
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_PROFESSIONAL, "create External Languages declarations"))
{
return(null);
}
int NewNumber = EditedList.Count + 1;
string NewName = "ExternalLanguage" + NewNumber.ToString();
var Definitor = new ExternalLanguageDeclaration(NewName, NewName.TextToIdentifier());
if (ExternalLanguageEdit(OwnerEntity, EditedList, Definitor))
{
return(Definitor);
}
return(null);
}
/// <summary>
/// Saves the Document into the underlying package, optionally with a new Uri.
/// If the underlying package does not exists, then it is created with the supplied Uri.
/// If the document is not already stored, then the Uri must be supplied.
/// Returns an error message if problems were detected.
/// </summary>
/// <param name="DocumentLocation">New location for the Composition, Optional if the document is already stored.</param>
/// <param name="UpdateLocation">Indicates to update the Composition location.</param>
/// <param name="ResetExistenceStatus">Indicates to reset the existence status to Not-Modified.</param>
/// <param name="RegisterAsRecentDoc">Indicates to register the document in the recent-documents list.</param>
/// <returns>Possible problem error message.</returns>
public string Store(Uri DocumentLocation = null, bool UpdateLocation = true, bool ResetExistenceStatus = true, bool RegisterAsRecentDoc = true)
{
var MaxQuota = AppExec.CurrentLicenseEdition.TechName.SelectCorresponding(LicensingConfig.IdeasCreationQuotas);
if (!ProductDirector.ValidateEditionLimit(this.TargetComposition.DeclaredIdeas.Count(), MaxQuota, "save", "Ideas (Concepts + Relationships)"))
{
return("This product edition cannot save a Composition with more than " + MaxQuota.ToString() + " Ideas.");
}
MaxQuota = AppExec.CurrentLicenseEdition.TechName.SelectCorresponding(LicensingConfig.ComposabilityLevelsQuotas);
var CompoLevels = this.TargetComposition.GetCompositeSubLevelsCount();
if (!ProductDirector.ValidateEditionLimit(CompoLevels, MaxQuota, "save", "Composability Depth Levels"))
{
return("This product edition cannot save a Composition with more than " + MaxQuota.ToString() + " composability depth levels.");
}
if (DocumentLocation == null)
{
DocumentLocation = this.Location;
}
else
if (UpdateLocation)
{
this.Location = DocumentLocation;
}
var Snapshot = (this.TargetComposition.ActiveView == null
? null
: this.TargetComposition.ActiveView.ToVisualSnapshot(PART_SNAPSHOT_WIDTH, PART_SNAPSHOT_HEIGHT));
var Result = StoreToLocation <ISphereModel>(this.TargetComposition, Composition.__ClassDefinitor.Name,
this.TargetComposition.Classification.ContentTypeCode, DocumentLocation,
CompositionDocumentUri, RegisterAsRecentDoc, false,
this.TargetComposition, Snapshot);
if (Result.IsAbsent() && ResetExistenceStatus)
{
this.ExistenceStatus = EExistenceStatus.NotModified;
}
return(Result);
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
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));
}
/// <summary>
/// Tries to close the supplied document engine and returns indication of action executed or cancelled by user.
/// </summary>
public bool CloseComposition(CompositionEngine Engine)
{
if (Engine.ExistenceStatus == EExistenceStatus.Modified)
{
var Result = Display.DialogMessage("Confirmation",
"The Composition \"" + Engine.TargetComposition.Name + "\" has been modified.\n" +
(Engine.FullLocation != null ? "\nLocation: " + Engine.FullLocation.LocalPath : "") + "\n\n" +
"Do you want to save changes?",
EMessageType.Question,
System.Windows.MessageBoxButton.YesNoCancel, System.Windows.MessageBoxResult.Yes);
if (Result == System.Windows.MessageBoxResult.Cancel)
{
return(false);
}
if (Result == System.Windows.MessageBoxResult.Yes)
{
if (!CloseRelatedResources(Engine))
{
return(false);
}
var Location = Engine.FullLocation;
if (Location != null)
{
var StoreResult = Engine.Store();
if (!StoreResult.IsAbsent())
{
Display.DialogMessage("Error!", "Cannot save Composition.\n\nProblem: " + StoreResult, EMessageType.Warning);
return(false);
}
}
else
{
Location = Display.DialogGetSaveFile("Save Composition",
FileDataType.FileTypeComposition.Extension,
FileDataType.FileTypeComposition.FilterForSave,
Engine.TargetComposition.TechName);
if (Location == null)
{
return(false);
}
var StoreResult = Engine.Store(Location);
if (!StoreResult.IsAbsent())
{
Display.DialogMessage("Error!", "Cannot save Composition.\n\nProblem: " + StoreResult, EMessageType.Warning);
return(false);
}
}
}
}
Engine.Stop();
// Show the new activated engine
this.WorkspaceDirector.RemoveDocument(Engine.TargetComposition);
// Finally, clears the palettes if no document remains.
Application.Current.MainWindow
.PostCall(win =>
{
if (this.WorkspaceDirector.Documents.Count < 1)
{
ProductDirector.UpdatePalettes(null);
}
}, true);
return(true);
}
public void PresenterControl_MouseMove(object sender, MouseEventArgs e)
{
CurrentMousePosition = e.GetPosition(CurrentView.PresenterControl);
//T Console.WriteLine("At: " + e.GetPosition(null));
var VisObject = GetPointedVisualObject(CurrentMousePosition);
if ((Mouse.LeftButton == MouseButtonState.Pressed || Mouse.RightButton != MouseButtonState.Pressed) &&
this.RunningMouseCommand == this.PanCommand && this.PanCommand != null)
{
this.DoCancelOperation(true, null);
}
if (this.RunningMouseCommand == null)
{
var Manipulator = CurrentView.Manipulator;
if (this.MouseLeftButtonDownOutsideControl != null && this.MouseLeftButtonDownOutsideControl.Value)
{
if (Manipulator.WorkingAdorner != null)
{
Manipulator.WorkingAdorner.CancelledByMouseLeftButtonDownOutsideControl = true;
}
Manipulator.IsManipulating = false;
Manipulator.UnpointObject();
Manipulator.Finish();
this.MouseLeftButtonDownOutsideControl = null;
return;
}
else
if (Manipulator.IsManipulating)
{
Manipulator.Continue();
}
else
if (!Manipulator.PointObject(VisObject))
{
ProductDirector.ShowPointingTo();
ProductDirector.ShowAssistance();
// Cancelled: Too much to explain... ProductDirector.ShowAssistance("To Select: Move pressing [Mouse-Button]. To Pan: Move pressing [Mouse-Alternate-Button]. To Zoom in/out: Roll [Mouse-Wheel]+[Ctrl].");
}
}
else
{
if (!this.RunningMouseCommand.Continue(e, false))
{
this.RunningMouseCommand = null;
}
PreviousMousePosition = CurrentMousePosition;
return;
}
if (!VisObject.IsEqual(PointedObject))
{
PointedObject = VisObject;
/*T Console.WriteLine("Pointing Representator of Idea: [{0}] at [{1}]. Element is at [{2}].",
* (Element == null ? "<NONE>" : Element.OwnerRepresentation.RepresentedIdea.Name),
* CurrentMousePosition,
* (Element == null ? Rect.Empty : Element.Graphic.ContentBounds )); */
}
// When [Dragging] and Selecting-by-Rectangle
if (IsSelectingByRectangle && Mouse.LeftButton == MouseButtonState.Pressed)
{
if (this.SelectByRectangleCommand == null)
{
this.SelectByRectangleCommand = new WorkCommandInteractive <MouseEventArgs>("SelectByRectangle",
(mevargs, definitive) =>
{
var MousePos = mevargs.GetPosition(this.CurrentView.Presenter);
if (mevargs.LeftButton == MouseButtonState.Pressed &&
!this.CurrentView.Manipulator.IsManipulating)
{
//T Console.WriteLine("FinishedSelByRect ONE. Breaked.");
this.CurrentView.SelectByRectangle(MousePos);
return(true);
}
/*T Console.WriteLine("FinishedSelByRect ONE. IsMan={0}, MALB={1}",
* this.CurrentView.Manipulator.IsManipulating, mevargs.LeftButton); */
if (!this.CurrentView.Manipulator.IsManipulating)
{
this.CurrentView.FinishSelectByRectangle(true, MousePos);
}
return(false);
},
(normal, mevargs) =>
{
//T Console.WriteLine("FinishedSelByRect TWO. ");
this.CurrentView.FinishSelectByRectangle(false);
});
}
this.RunningMouseCommand = this.SelectByRectangleCommand; // To avoid Pointing of elements
}
else
if (this.RunningMouseCommand == this.SelectByRectangleCommand && this.SelectByRectangleCommand != null)
{
this.DoCancelOperation(true, null);
}
// When [Dragging]
// then Update cursor depending on pointed target
// When ([Dragging] and [Going out of view scope]) or [Mouse Right-Button down]
// then [Pan]
if (Mouse.RightButton == MouseButtonState.Pressed)
{
if (this.RunningMouseCommand == null)
{
if (this.PanCommand == null)
{
this.PanCommand = new WorkCommandInteractive <MouseEventArgs>("Pan",
(mevargs, definitive) => { this.CurrentView.Pan(); return(true); },
(normal, mevargs) => { this.CurrentView.PreviousPanPosition = default(Point); });
}
this.RunningMouseCommand = this.PanCommand; // To avoid Pointing of elements
}
}
else
if (this.RunningMouseCommand == this.PanCommand && this.PanCommand != null)
{
this.DoCancelOperation(true, null);
}
PreviousMousePosition = CurrentMousePosition;
}
/// <summary>
/// Manages unhandled exceptions
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Current_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
{
ProductDirector.ApplicationUnhandledExceptionHandler(sender, e);
}
/// <summary>
/// Window closed event handler.
/// </summary>
private void Window_Closed(object sender, EventArgs e)
{
ProductDirector.Terminate();
}
//------------------------------------------------------------------------------------------------------------------------
public override Visual DeterminePointedVisual(Point Position)
{
PreviousPosition = CurrentPosition;
CurrentPosition = Position;
if (CurrentPosition == PreviousPosition || IsManipulating)
{
return(CurrentPointedVisual);
}
var NewPointed = GetPointedVisual(Position);
IsManipulatingHeading = !NewPointed.IsOneOf(FrmPointingDetailsPanel, IndDetailsBottom, IndDetailsBottomLeft, IndDetailsBottomRight, IndDetailsLeft, IndDetailsRight);
if (NewPointed != CurrentPointedVisual)
{
CurrentPointedVisual = NewPointed;
bool IsPointingToIndicator = true;
if (NewPointed.IsOneOf(IndHeadingTop, IndHeadingBottom, IndDetailsBottom))
{
ResizingDirection = (NewPointed == IndHeadingTop ? EManipulationDirection.Top : EManipulationDirection.Bottom);
TentativeAction = ESymbolManipulationAction.Resize;
Cursor = Cursors.SizeNS;
}
else if (NewPointed.IsOneOf(IndHeadingLeft, IndHeadingRight, IndDetailsLeft, IndDetailsRight))
{
ResizingDirection = (NewPointed.IsOneOf(IndHeadingLeft, IndDetailsLeft) ? EManipulationDirection.Left : EManipulationDirection.Right);
TentativeAction = ESymbolManipulationAction.Resize;
Cursor = Cursors.SizeWE;
}
else if (NewPointed.IsOneOf(IndHeadingTopLeft, IndHeadingBottomRight, IndDetailsBottomRight))
{
ResizingDirection = (NewPointed == IndHeadingTopLeft ? EManipulationDirection.TopLeft : EManipulationDirection.BottomRight);
TentativeAction = ESymbolManipulationAction.Resize;
Cursor = Cursors.SizeNWSE;
}
else if (NewPointed.IsOneOf(IndHeadingBottomLeft, IndHeadingTopRight, IndDetailsBottomLeft))
{
ResizingDirection = (NewPointed == IndHeadingTopRight ? EManipulationDirection.TopRight : EManipulationDirection.BottomLeft);
TentativeAction = ESymbolManipulationAction.Resize;
Cursor = Cursors.SizeNESW;
}
else if (NewPointed.IsOneOf(FrmPointingHeadingPanel, FrmPointingDetailsPanel))
{
TentativeAction = ESymbolManipulationAction.Move;
Cursor = Cursors.ScrollAll;
}
else if (NewPointed == FrmEditZone || NewPointed == null)
{
if (ManipulatedSymbol.OwnerRepresentation.IsShortcut)
{
TentativeAction = ESymbolManipulationAction.GoToShortcutTarget;
Cursor = Cursors.UpArrow;
}
else
{
// Do not Edit In-Place if multiselecting...
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl) ||
Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
{
TentativeAction = ESymbolManipulationAction.Move;
Cursor = Cursors.ScrollAll;
}
else
{
TentativeAction = ESymbolManipulationAction.EditInPlace;
Cursor = Cursors.Pen;
}
}
}
else if (NewPointed.IsIn(FrmMarkingZones.Keys))
{
LastPointedMarkerAssignment = FrmMarkingZones[NewPointed];
TentativeAction = ESymbolManipulationAction.MarkerEdit;
Cursor = Cursors.Pen;
}
else if (NewPointed.IsIn(FrmDetailContentAssignZones.Keys))
{
LastPointedDetailDesignator = FrmDetailContentAssignZones[NewPointed];
TentativeAction = ESymbolManipulationAction.IndividualDetailChange;
Cursor = Cursors.Hand;
}
else if (NewPointed.IsIn(FrmDetailContentEditZones.Keys))
{
LastPointedDetailDesignator = FrmDetailContentEditZones[NewPointed];
TentativeAction = ESymbolManipulationAction.IndividualDetailAccess;
Cursor = Cursors.Pen;
}
else if (NewPointed.IsIn(FrmDetailTitleExpandZones.Keys))
{
LastPointedDetailDesignator = FrmDetailTitleExpandZones[NewPointed];
TentativeAction = ESymbolManipulationAction.SwitchIndividualDetail;
Cursor = Cursors.UpArrow;
}
else if (NewPointed.IsIn(FrmDetailTitleDesignateZones.Keys))
{
LastPointedDetailDesignator = FrmDetailTitleDesignateZones[NewPointed];
TentativeAction = ESymbolManipulationAction.IndividualDetailDesignation;
Cursor = Cursors.Arrow;
}
else
{
Cursor = Cursors.Hand;
if (NewPointed == ActSwitchDetails)
{
TentativeAction = ESymbolManipulationAction.ActionSwitchDetails;
}
else if (NewPointed == ActSwitchRelated)
{
TentativeAction = ESymbolManipulationAction.ActionSwitchRelated;
}
else if (NewPointed == ActShowComposite)
{
TentativeAction = ESymbolManipulationAction.ActionShowCompositeAsView;
}
else if (NewPointed == DefaultActionIndicator)
{
TentativeAction = ESymbolManipulationAction.ActionEditProperties;
}
else if (NewPointed == ActSwitchCompositeView)
{
TentativeAction = ESymbolManipulationAction.ActionShowCompositeAsDetail;
}
else if (NewPointed == ActAddDetail)
{
TentativeAction = ESymbolManipulationAction.ActionAddDetail;
}
else
{
IsPointingToIndicator = false;
}
}
if (IsPointingToIndicator)
{
var IndDescription = TentativeAction.GetDescription();
if (TentativeAction == ESymbolManipulationAction.EditInPlace &&
ManipulatedSymbol.OwnerRepresentation is RelationshipVisualRepresentation representation)
{
var RepRel = representation.RepresentedRelationship;
if (!RepRel.RelationshipDefinitor.Value.IsSimple || RepRel.Links.Count <= 1)
{
IndDescription += " Drag to extend the pointed Relationship with a new Link/Connector.";
}
}
ProductDirector.ShowAssistance(IndDescription);
/* Problem: This tooltip stops the adorner working
* var Tip = this.ToolTip as ToolTip;
*
* if (Tip == null || (Tip.Content as string).IsAbsent())
* {
* Tip = (Tip == null ? new ToolTip() : Tip);
* this.ToolTip = Tip;
*
* Tip.Content = IndDescription;
* Tip.IsOpen = true;
* Tip.StaysOpen = false;
* } */
}
else
{
ProductDirector.ShowAssistance();
}
ProductDirector.ShowPointingTo(ManipulatedSymbol);
}
return(NewPointed);
}
//------------------------------------------------------------------------------------------------------------------------
public override Visual DeterminePointedVisual(Point Position)
{
this.PreviousPosition = this.CurrentPosition;
this.CurrentPosition = Position;
if (this.CurrentPosition == this.PreviousPosition || this.IsManipulating)
{
return(this.CurrentPointedVisual);
}
var NewPointed = GetPointedVisual(Position);
if (NewPointed != this.CurrentPointedVisual)
{
this.CurrentPointedVisual = NewPointed;
/* POSTPONED: Displace connecting points
* if (NewPointed.IsOneOf(IndOriginPoint, IndTargetPoint))
* {
* this.TentativeAction = EConnectorManipulationAction.Displace;
* this.Cursor = Cursors.Cross;
* } */
if (NewPointed != null /* && !NewPointed.IsOneOf(IndOriginPoint, IndTargetPoint)*/)
{
if (NewPointed == this.DefaultActionIndicator || NewPointed.IsIn(AlternateActions))
{
this.TentativeAction = this.CurrentManipulationAction;
}
else
if (NewPointed == this.RelinkActionTargetIndicator || NewPointed == this.RelinkActionOriginIndicator)
{
this.TentativeAction = EConnectorManipulationAction.ReLink;
}
if (this.TentativeAction == EConnectorManipulationAction.Displace)
{
this.Cursor = Cursors.ScrollAll;
}
else
if (this.TentativeAction == EConnectorManipulationAction.ReLink)
{
this.Cursor = Cursors.Cross;
}
else
{
this.Cursor = Cursors.Hand;
}
}
var IndDescription = this.TentativeAction.GetDescription();
if (this.TentativeAction == EConnectorManipulationAction.Displace)
{
IndDescription = IndDescription + " Double-click for Edit. " +
"Action icons: [Ctrl]=Straighten line, [Shift]=Delete connector, [Alt]=Cycle variant plugs.";
}
ProductDirector.ShowAssistance(IndDescription);
/* DANGER: This tooltip stops the adorner working
* var Tip = this.ToolTip as ToolTip;
*
* if (Tip == null || (Tip.Content as string).IsAbsent())
* {
* Tip = (Tip == null ? new ToolTip() : Tip);
* Tip.Content = IndDescription;
* Tip.IsOpen = true;
* Tip.StaysOpen = false;
* this.ToolTip = Tip;
* } */
//- }
ProductDirector.ShowPointingTo(this.ManipulatedConnector);
}
return(NewPointed);
}
public static void GenerateHtmlReport(CompositionEngine Engine)
{
if (Engine == null)
{
return;
}
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_STANDARD, "Generate HTML Report", false, new DateTime(2013, 1, 1)))
{
return;
}
if (Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration == null)
{
Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration = new ReportConfiguration();
}
if (!ReportingManager.EditReportConfiguration("HTML", Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration))
{
return;
}
var FilePath = Path.Combine(AppExec.UserDataDirectory, (Engine.TargetComposition.TechName + ".html").TextToUrlIdentifier());
var DialogResponse = Display.DialogGetSaveFile("Select HTML file to create", ".html", "HTML document (*.html)|*.html", FilePath);
if (DialogResponse == null)
{
return;
}
// Enforce url-identifier to avoid file-names with space in between.
var Location = Path.Combine(Path.GetDirectoryName(DialogResponse.LocalPath),
Path.GetFileName(DialogResponse.LocalPath).TextToUrlIdentifier());
var WarnResponse = Display.DialogPersistableMultiOption("Note", "Your HTML Document is generated along with a '" + ReportHtmlGenerator.CONTENT_FOLDER_SUFFIX + "' directory.\n" +
"Please don't forget to manage (copy/move/erase) them together to keep consistency." +
(Location == DialogResponse.LocalPath ? ""
: "\n\nThe file will be saved as '" + Path.GetFileName(Location) + "'."),
null, "Reporting", "InformHTMLContentDir", null,
new SimplePresentationElement("OK", "Ok", "", Display.GetAppImage("accept.png")));
if (WarnResponse == null)
{
return;
}
var Title = "HTML Report of " + Engine.TargetComposition.Name;
var Generator = new ReportHtmlGenerator(Engine.TargetComposition, Location,
Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration);
ProgressiveThreadedExecutor <int> .Execute("Generating " + Title, Generator.Generate,
(opresult) =>
{
if (opresult.WasSuccessful && !File.Exists(Generator.GeneratedTempWorkingDocumentFile))
{
opresult = OperationResult.Failure <int>("Cannot write temporal report file at: " + Generator.GeneratedTempWorkingDocumentFile);
}
if (!opresult.WasSuccessful)
{
Display.DialogMessage("Report not completed!", opresult.Message, EMessageType.Warning);
return;
}
try
{
var TargetFolder = Path.GetDirectoryName(Location);
General.CopyDirectory(Generator.GeneratedTempWorkingDocumentDir, TargetFolder);
AppExec.CallExternalProcess(Location);
if (File.Exists(Generator.GeneratedTempWorkingDocumentFile))
{
File.Delete(Generator.GeneratedTempWorkingDocumentFile);
}
if (Directory.Exists(Generator.GeneratedTempWorkingDocumentDir))
{
Directory.Delete(Generator.GeneratedTempWorkingDocumentDir, true);
}
}
catch (Exception Problem)
{
Display.DialogMessage("Attention!", "Cannot show generated Report.\n"
+ (!Generator.GeneratedTempWorkingDocumentFile.IsAbsent() && File.Exists(Generator.GeneratedTempWorkingDocumentFile)
? "It can be still found at: " + Generator.GeneratedTempWorkingDocumentFile : "")
+ "\nProblem: " + Problem.Message);
}
});
}
public static void GeneratePdfXpsReport(CompositionEngine Engine)
{
if (Engine == null)
{
return;
}
if (!ProductDirector.ValidateEditionPermission(AppExec.LIC_EDITION_STANDARD, "Generate PDF/XPS Report"))
{
return;
}
if (Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration == null)
{
Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration = new ReportConfiguration();
}
if (!ReportingManager.EditReportConfiguration("PDF/XPS", Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration))
{
return;
}
var Generator = new ReportStandardGenerator(Engine.TargetComposition, Engine.TargetComposition.CompositeContentDomain.ReportingConfiguration);
var Title = "Report of " + Engine.TargetComposition.Name;
ProgressiveThreadedExecutor <int> .Execute("Generating " + Title, Generator.Generate,
(opresult) =>
{
if (opresult.WasSuccessful && !File.Exists(Generator.GeneratedDocumentTempFilePath))
{
opresult = OperationResult.Failure <int>("Cannot write temporal report file at: " + Generator.GeneratedDocumentTempFilePath);
}
if (!opresult.WasSuccessful)
{
Display.DialogMessage("Report not completed!", opresult.Message, EMessageType.Warning);
return;
}
try
{
var GeneratedDocument = Display.LoadDocumentFromXPS(Generator.GeneratedDocumentTempFilePath);
var Location = new Uri(Generator.GeneratedDocumentTempFilePath, UriKind.Absolute);
var Package = System.IO.Packaging.PackageStore.GetPackage(Location);
DocViewerControl = new PrintPreviewer(GeneratedDocument, Generator.GeneratedDocumentTempFilePath,
Engine.TargetComposition.Name);
Display.OpenContentDialogWindow(ref WinFlowDocViewer, Title, DocViewerControl);
Package.Close(); // Package remains open, so must closed!
//if you don't remove the package from the PackageStore, you won't be able to
//re-open the same file again later (due to System.IO.Packaging's Package store/caching
//rather than because of any file locks)
System.IO.Packaging.PackageStore.RemovePackage(Location);
if (File.Exists(Generator.GeneratedDocumentTempFilePath))
{
File.Delete(Generator.GeneratedDocumentTempFilePath);
}
}
catch (Exception Problem)
{
Display.DialogMessage("Attention!", "Cannot show generated Report.\n"
+ (!Generator.GeneratedDocumentTempFilePath.IsAbsent() && File.Exists(Generator.GeneratedDocumentTempFilePath)
? "It can still be found at: " + Generator.GeneratedDocumentTempFilePath : "")
+ "\nProblem: " + Problem.Message);
}
});
}
//------------------------------------------------------------------------------------------------------------------------
public override Visual DeterminePointedVisual(Point Position)
{
this.PreviousPosition = this.CurrentPosition;
this.CurrentPosition = Position;
if (this.CurrentPosition == this.PreviousPosition || this.IsManipulating)
{
return(this.CurrentPointedVisual);
}
var NewPointed = GetPointedVisual(Position);
if (NewPointed != this.CurrentPointedVisual)
{
this.CurrentPointedVisual = NewPointed;
bool IsPointingToIndicator = true;
if (NewPointed.IsOneOf(IndHeadingTop, IndHeadingBottom))
{
this.ResizingDirection = (NewPointed == IndHeadingTop ? EManipulationDirection.Top : EManipulationDirection.Bottom);
this.TentativeAction = EComplementManipulationAction.Resize;
this.Cursor = Cursors.SizeNS;
}
else
if (NewPointed.IsOneOf(IndHeadingLeft, IndHeadingRight))
{
this.ResizingDirection = (NewPointed == IndHeadingLeft ? EManipulationDirection.Left : EManipulationDirection.Right);
this.TentativeAction = EComplementManipulationAction.Resize;
this.Cursor = Cursors.SizeWE;
}
else
if (NewPointed.IsOneOf(IndHeadingTopLeft, IndHeadingBottomRight))
{
this.ResizingDirection = (NewPointed == IndHeadingTopLeft ? EManipulationDirection.TopLeft : EManipulationDirection.BottomRight);
this.TentativeAction = EComplementManipulationAction.Resize;
this.Cursor = Cursors.SizeNWSE;
}
else
if (NewPointed.IsOneOf(IndHeadingBottomLeft, IndHeadingTopRight))
{
this.ResizingDirection = (NewPointed == IndHeadingTopRight ? EManipulationDirection.TopRight : EManipulationDirection.BottomLeft);
this.TentativeAction = EComplementManipulationAction.Resize;
this.Cursor = Cursors.SizeNESW;
}
else
if (NewPointed == FrmPointingHeadingPanel)
{
this.TentativeAction = EComplementManipulationAction.Move;
this.Cursor = Cursors.ScrollAll;
}
else
if (NewPointed == FrmEditZone || NewPointed == null)
{
this.TentativeAction = EComplementManipulationAction.Edit;
this.Cursor = Cursors.Pen;
}
else
{
this.Cursor = Cursors.Hand;
if (NewPointed == DefaultActionIndicator)
{
this.TentativeAction = EComplementManipulationAction.Edit;
}
else
{
IsPointingToIndicator = false;
}
}
if (IsPointingToIndicator)
{
var IndDescription = this.TentativeAction.GetDescription();
ProductDirector.ShowAssistance(IndDescription);
}
else
{
ProductDirector.ShowAssistance();
}
ProductDirector.ShowPointingTo(this.ManipulatedComplement);
}
return(NewPointed);
}
