/// <summary>
/// Creates the marker definition.
/// </summary>
/// <param name="typeDefinition">The type definition.</param>
/// <param name="context">The context.</param>
/// <returns></returns>
private MarkerDefinition CreateMarkerDefinition(TypeDef typeDefinition, WeavingContext context)
{
var priorityAttributes = typeDefinition.CustomAttributes.Where(a => a.AttributeType.SafeEquivalent(context.PriorityAttributeType)).ToList();
if (priorityAttributes.Count > 1)
{
Logging.WriteWarning("Advice {0} has more than one priority. Using the first found", typeDefinition.FullName);
}
#if uneedednow
int priority = 0;
if (priorityAttributes.Count > 0)
{
var priorityAttribute = priorityAttributes[0];
priority = (int)priorityAttribute.ConstructorArguments[0].Value;
Logging.WriteDebug("Advice {0} has priority {1}", typeDefinition.FullName, priority);
}
#endif
var abstractTarget = typeDefinition.CustomAttributes.Any(a => a.AttributeType.SafeEquivalent(context.AbstractTargetAttributeType));
if (abstractTarget)
{
Logging.WriteDebug("Advice {0} abstracts target", typeDefinition.FullName);
}
var markerDefinition = new MarkerDefinition(typeDefinition, abstractTarget);
return(markerDefinition);
}
/// <summary>
/// Creates the marker definition.
/// </summary>
/// <param name="typeDefinition">The type definition.</param>
/// <param name="types">The types.</param>
/// <returns></returns>
private static MarkerDefinition CreateMarkerDefinition(TypeDefinition typeDefinition, Types types)
{
var priorityAttributes = typeDefinition.CustomAttributes.Where(a => a.AttributeType.SafeEquivalent(types.PriorityAttributeType)).ToList();
if (priorityAttributes.Count > 1)
{
Logger.WriteWarning("Advice {0} has more than one priority. Using the first found", typeDefinition.FullName);
}
int priority = 0;
if (priorityAttributes.Count > 0)
{
var b = priorityAttributes[0].GetBlob();
priority = (b[5] << 24) | (b[4] << 16) | (b[3] << 8) | b[2];
Logger.WriteDebug("Advice {0} has priority {1}", typeDefinition.FullName, priority);
}
var abstractTarget = typeDefinition.CustomAttributes.Any(a => a.AttributeType.SafeEquivalent(types.AbstractTargetAttributeType));
if (abstractTarget)
{
Logger.WriteDebug("Advice {0} abstracts target", typeDefinition.FullName, priority);
}
var markerDefinition = new MarkerDefinition {
Type = typeDefinition, Priority = priority, AbstractTarget = abstractTarget
};
return(markerDefinition);
}
public void ParseMarker_CreatesProperMarker(string inputType, Type expectedType)
{
var guid = Guid.NewGuid();
var display = new SensoryDisplay();
display.Smell.ResetTo(4, 8);
var jsonDisplay = JObject.Parse(JsonConvert.SerializeObject(display));
var data = new JObject
{
{ "display", jsonDisplay },
{ "duration", 11 },
{ "decayRate", 0.95 },
{ "type", inputType }
};
//Act
var marker = MarkerDefinition.ParseMarker(data, guid);
//Assert
Assert.NotNull(marker);
Assert.Equal(guid, (marker as ITransferable).Owner);
Assert.Equal(expectedType, marker.GetType());
Assert.Equal(8, marker.Display.Smell.Strength);
}
public MarkerAssignmentCommand(CompositionEngine TargetEngine, MarkerDefinition MarkerDef)
: base("Assign Marker: " + MarkerDef.Name)
{
this.ContextEngine = TargetEngine;
this.MarkerDef = MarkerDef;
this.Initialize();
}
CreateMarker(EntityEditEngine Engine, MarkerDefinition Definitor, View TargetView, VisualRepresentation TargetRepresentator = null)
{
General.ContractRequiresNotNull(Engine, Definitor, TargetView);
Engine.StartCommandVariation("Create Marker");
var NewMarker = CreateMarkerAssignment(Engine, Definitor);
if (NewMarker != null)
{
var RedisplayView = false;
if (!TargetView.ShowMarkers)
/* if (Display.DialogMessage("Attention", "View is not currently showing Markers.\nDo you want to show them?",
* EMessageType.Question, MessageBoxButton.YesNo, MessageBoxResult.Yes) == MessageBoxResult.Yes) */
{
TargetView.ShowMarkers = true;
RedisplayView = true;
}
if (TargetRepresentator == null)
{
foreach (var Representator in TargetView.SelectedRepresentations)
{
Representator.RepresentedIdea.Markings.Add(NewMarker);
if (!RedisplayView)
{
Representator.Render();
}
}
}
else
{
TargetRepresentator.RepresentedIdea.Markings.Add(NewMarker);
if (!RedisplayView)
{
TargetRepresentator.Render();
}
}
if (RedisplayView)
{
TargetView.ShowAll();
}
}
if (TargetRepresentator != null)
{
TargetRepresentator.RepresentedIdea.UpdateVersion();
}
Engine.CompleteCommandVariation();
return(OperationResult.Success(NewMarker));
}
/// <summary>
/// Determines whether the specified <see cref="ReflectionNode"/> allows the given <see cref="MarkerDefinition"/>.
/// </summary>
/// <param name="markerDefinition">The marker definition.</param>
/// <param name="node">The node.</param>
/// <param name="context">The context.</param>
/// <returns>
/// <c>true</c> if [is included by node] [the specified node]; otherwise, <c>false</c>.
/// </returns>
private bool IsIncludedByNode(MarkerDefinition markerDefinition, ReflectionNode node, WeavingContext context)
{
var adviceSelector = GetAdviceSelector(node, context);
var isIncluded = adviceSelector.Select(markerDefinition.Type);
if (!isIncluded)
{
Logging.WriteDebug("Method '{0}' excluded advice '{1}'", node.Method.FullName, markerDefinition.Type.FullName);
}
return(isIncluded);
}
public WorldObject Create(CreateAction action)
{
if (!CanCreate(action))
{
return(null);
}
switch ((CreationIndex)action.ActionIndex)
{
case CreationIndex.MARKER:
return(MarkerDefinition.ParseMarker(action.Data, Id));
default:
return(null);
}
}
public static MarkerDefinition MarkerDefinitionClone(Domain OwnerEntity, IList <MarkerDefinition> EditedList, MarkerDefinition MarkerDef)
{
var Result = new MarkerDefinition();
Result.PopulateFrom(MarkerDef, 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 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 void ParseMarkerDefinition_UsesInputData()
{
var display = new SensoryDisplay();
display.Auditory.ResetTo(3, 7);
var jsonDisplay = JObject.Parse(JsonConvert.SerializeObject(display));
var data = new JObject
{
{ "display", jsonDisplay },
{ "duration", 11 },
{ "decayRate", 0.95 }
};
//Act
var definition = MarkerDefinition.ParseDefinition(data);
//Assert
Assert.NotNull(definition);
Assert.Equal(7, definition.Display.Auditory.Strength);
Assert.Equal(11, definition.Duration);
Assert.Equal(0.95, definition.DecayRate);
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------------
public static MarkerAssignment CreateMarkerAssignment(EntityEditEngine Engine, MarkerDefinition Definitor)
{
var Result = new MarkerAssignment(Engine, Definitor);
var EditOnCreationConfigured = AppExec.GetConfiguration <bool>("IdeaEditing", "MarkerEditing.EditOnCreation", false);
var EditOnCreationExplicit = (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl));
if (EditOnCreationConfigured || EditOnCreationExplicit)
{
if (!EditMarkerAssignmentDescriptor(Engine, Result))
{
return(null);
}
}
return(Result);
}
/// <summary>
/// Constructor
/// </summary>
public MarkerAssignment(EntityEditEngine Engine, MarkerDefinition Definitor, SimplePresentationElement Descriptor = null)
{
this.Definitor = Definitor;
this.Descriptor = Descriptor;
}
public static bool MarkerDefinitionDelete(Domain OwnerEntity, IList <MarkerDefinition> EditedList, MarkerDefinition MarkerDef)
{
var Result = Display.DialogMessage("Confirmation", "Are you sure you want to Delete the '" + MarkerDef.Name + "' Marker Definition?",
EMessageType.Question, System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxResult.No);
return(Result == MessageBoxResult.Yes);
}
public static bool MarkerDefinitionEdit(Domain OwnerEntity, IList <MarkerDefinition> EditedList, MarkerDefinition MarkerDef)
{
/*- if (!ProductDirector.ConfirmImmediateApply("Marker Definition", "DomainEdit.MarkerDefinition", "ApplyDialogChangesDirectly"))
* return false; */
var InstanceController = EntityInstanceController.AssignInstanceController(MarkerDef);
InstanceController.StartEdit();
/* POSTPONED: Ability to edit and reorganize Markers via its Cluster-Key.
* var Expositor = new EntityPropertyExpositor(MarkerDefinition.__ClusterKey.TechName);
* Expositor.LabelMinWidth = 90; */
var EditPanel = Display.CreateEditPanel(MarkerDef, null, true, null, null, true, false, true /*, Expositor*/);
return(InstanceController.Edit(EditPanel, "Edit Marker Definition - " + MarkerDef.ToString()).IsTrue());
}
