private void WriteGroup(OptionGroup group, int nameColumnWidth)
{
writer.Write(group.Title);
writer.WriteLine(":");
foreach (OptionHelp entry in group)
{
string helpName = entry.Name;
string helpText = entry.HelpText;
int padding = nameColumnWidth - helpName.Length;
writer.Write(Settings.IndentChars);
writer.Write(helpName);
// Break on long option names.
if (padding < 0)
{
writer.WriteLine();
padding = nameColumnWidth + Settings.IndentChars.Length;
}
int totalWidth = Settings.IndentChars.Length + nameColumnWidth + 1 + helpText.Length;
if (totalWidth <= Settings.MaxLineLength)
{
writer.Write(new string(' ', padding + 1));
writer.WriteLine(helpText);
}
else
{
writer.Write(new string(' ', padding));
WriteTextBlock(helpText, nameColumnWidth);
}
}
}
protected override void SetupHandler()
{
OptionGroup toplevelGroup = Handler.AddGroup(TOP_LEVEL);
//the toplevel group will show neither in Table view nor in dialog view explicitely
//it's children will be shown one level above
((IOptionItem)toplevelGroup).Attributes[TableEditorFactory.RenderingHintsAttribute] = TableEditorFactory.RenderingHints.Invisible;
((IOptionItem)toplevelGroup).Attributes[DefaultEditorFactory.RenderingHintsAttribute] = DefaultEditorFactory.RenderingHints.Invisible;
OptionGroup spcg = toplevelGroup.AddGroup(SourcePortConstraints);
spcg.Add(PortConstraintStr, PortConstraintType.Any).Attributes[OptionItem.SupportNullValueAttribute] = false;
spcg.AddBool(StrongPortConstraint, false);
OptionGroup tpcg = toplevelGroup.AddGroup(TargetPortConstraints);
tpcg.Add(PortConstraintStr, PortConstraintType.Any).Attributes[OptionItem.SupportNullValueAttribute] = false;
tpcg.AddBool(StrongPortConstraint, false);
CollectionOptionItem <string> scopeItem = toplevelGroup.AddList(Scope, scopes, ScopeAllEdges);
var clearItem = toplevelGroup.AddBool(ClearAllConstraints, false);
ConstraintManager cm = new ConstraintManager(Handler);
cm.SetEnabledOnValueEquals(clearItem, false, spcg);
cm.SetEnabledOnValueEquals(clearItem, false, scopeItem);
cm.SetEnabledOnValueEquals(clearItem, false, tpcg);
}
private static Option2 <T> CreateCommonOption <T>(OptionGroup group, string name, T defaultValue, params OptionStorageLocation2[] storageLocations)
{
var option = new Option2 <T>("CodeStyleOptions", group, name, defaultValue, storageLocations);
s_allOptionsBuilder.Add(option);
return(option);
}
///<inheritdoc/>
protected override void SetupHandler()
{
BalloonLayout balloonLayout = new BalloonLayout();
OptionGroup generalGroup = Handler.AddGroup(GENERAL);
generalGroup.AddList(ROOT_NODE_POLICY, enumRoot.Keys, DIRECTED_ROOT);
IOptionItem allowNonTreeItem = generalGroup.AddBool(ALLOW_NON_TREE_EDGES, true);
IOptionItem nonTreeStyleItem = generalGroup.AddList(ROUTING_STYLE_FOR_NON_TREE_EDGES, enumRoute, ROUTE_ORTHOGONAL);
ConstraintManager cm = new ConstraintManager(Handler);
cm.SetEnabledOnValueEquals(allowNonTreeItem, true, nonTreeStyleItem);
IOptionItem ebs = generalGroup.AddDouble(EDGE_BUNDLING_STRENGTH, 0.99, 0, 1);
cm.SetEnabledOnValueEquals(nonTreeStyleItem, ROUTE_BUNDLED, ebs);
generalGroup.AddBool(ACT_ON_SELECTION_ONLY, false);
generalGroup.AddInt(PREFERRED_CHILD_WEDGE, balloonLayout.PreferredChildWedge, 1, 359);
generalGroup.AddInt(PREFERRED_ROOT_WEDGE, balloonLayout.PreferredRootWedge, 1, 360);
generalGroup.AddInt(MINIMAL_EDGE_LENGTH, balloonLayout.MinimumEdgeLength, 10, int.MaxValue);
generalGroup.AddDouble(COMPACTNESS_FACTOR, balloonLayout.CompactnessFactor, 0.1, 0.9);
generalGroup.AddBool(ALLOW_OVERLAPS, balloonLayout.AllowOverlaps);
generalGroup.AddBool(BALLOON_FROM_SKETCH, balloonLayout.FromSketchMode);
generalGroup.AddBool(PLACE_CHILDREN_INTERLEAVED, balloonLayout.InterleavedMode == InterleavedMode.AllNodes);
generalGroup.AddBool(STRAIGHTEN_CHAINS, balloonLayout.ChainStraighteningMode);
OptionGroup labelingGroup = Handler.AddGroup(LABELING);
labelingGroup.AddBool(INTEGRATED_EDGE_LABELING, true);
labelingGroup.AddList(NODE_LABELING_STYLE, nodeLabelingPolicies, nodeLabelingPolicies[3]);
}
private OptionGroup SetupOptionGroup(OptionGroup optionGroup)
{
optionGroup.Name = uxNameOptionText.Text;
optionGroup.Type = GetOptionGroupType();
optionGroup.DisplayText = uxDisplayNameText.Text;
return(optionGroup);
}
///<inheritdoc/>
protected override void SetupHandler()
{
OptionGroup scopeGroup = Handler.AddGroup(SCOPE);
scopeGroup.AddBool(PLACE_NODE_LABELS, true);
scopeGroup.AddBool(PLACE_EDGE_LABELS, true);
scopeGroup.AddBool(CONSIDER_SELECTED_FEATURES_ONLY, false);
OptionGroup qualityGroup = Handler.AddGroup(QUALITY);
qualityGroup.AddBool(USE_OPTIMIZATION, false);
qualityGroup.AddOptionItem(new OptionItem(OPTIMIZATION_STRATEGY)
{
Value = OptimizationStrategy.Balanced, Type = typeof(OptimizationStrategy)
});
qualityGroup.AddBool(ALLOW_NODE_OVERLAPS, false);
qualityGroup.AddBool(ALLOW_EDGE_OVERLAPS, true);
qualityGroup.AddBool(USE_POSTPROCESSING, false);
var edgeLabelGroup = Handler.AddGroup(MODEL);
var labelModelItem = edgeLabelGroup.AddList(EDGE_LABEL_MODEL, edgeLabelModel, BEST);
var autoRotationItem = edgeLabelGroup.AddBool(AUTO_ROTATE, true);
ConstraintManager cm = new ConstraintManager(Handler);
cm.SetEnabledOnCondition(cm.CreateValueIsOneOfCondition(labelModelItem, CENTER_SLIDER, SIDE_SLIDER), autoRotationItem);
}
public async Task ShouldUpdateSuccessfully()
{
var itemGroup = new ItemGroup().Of(_token.TenantId);
var optionGroup1 = new OptionGroup().To(itemGroup);
var optionGroup2 = new OptionGroup().To(itemGroup);
var option = new Option().To(optionGroup1);
_server.Database.ItemGroups.Add(itemGroup);
_server.Database.OptionGroups.AddRange(optionGroup1, optionGroup2);
_server.Database.Options.Add(option);
await _server.Database.SaveChangesAsync();
var path = $"/options/{option.Id}";
var jsonRequest = new SaveOptionJson().Build(groupId: optionGroup2.Id);
var response = await _client.PutJsonAsync(path, jsonRequest);
var jsonResponse = await _client.ReadJsonAsync <OptionJson>(response);
await _server.Database.Entry(option).ReloadAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(_token.TenantId, option.TenantId);
Assert.Equal(jsonRequest.GroupId, option.OptionGroupId);
Assert.Equal(jsonRequest.Name, option.Name);
Assert.Equal(jsonRequest.Description, option.Description);
Assert.Equal(jsonRequest.Price, option.Price);
Assert.Equal(jsonRequest.IsAvailable, option.IsAvailable);
Assert.Equal(option.Id, jsonResponse.Id);
Assert.Equal(option.OptionGroupId, optionGroup2.Id);
Assert.Equal(option.Name, jsonResponse.Name);
Assert.Equal(option.Description, jsonResponse.Description);
Assert.Equal(option.Price, jsonResponse.Price);
Assert.Equal(option.IsAvailable, jsonResponse.Available);
}
///<inheritdoc/>
protected override void ConfigureLayout()
{
CreateOrganic();
OptionGroup visualGroup = Handler.GetGroupByName(VISUAL);
OptionGroup algorithmGroup = Handler.GetGroupByName(ALGORITHM);
organic.PreferredEdgeLength = (int)visualGroup[PREFERRED_EDGE_LENGTH].Value;
bool considerNodeLabels = (bool)visualGroup[CONSIDER_NODE_LABELS].Value;
organic.ConsiderNodeLabels = considerNodeLabels;
organic.NodeOverlapsAllowed = (bool)visualGroup[ALLOW_NODE_OVERLAPS].Value && !considerNodeLabels;
organic.MinimumNodeDistance = (double)visualGroup[MINIMAL_NODE_DISTANCE].Value;
string scopeChoice = (string)visualGroup[SCOPE].Value;
organic.Scope = scopes[scopeChoice];
organic.CompactnessFactor = (double)visualGroup[COMPACTNESS].Value;
//Doesn't really make sense to ignore node sizes (for certain configurations, this setting
//doesn't have an effect anyway)
organic.ConsiderNodeSizes = true;
organic.ClusterNodes = (bool)visualGroup[USE_AUTO_CLUSTERING].Value;
organic.ClusteringQuality = (double)visualGroup[AUTO_CLUSTERING_QUALITY].Value;
organic.NodeEdgeOverlapAvoided = (bool)visualGroup[AVOID_NODE_EDGE_OVERLAPS].Value;
organic.Deterministic = (bool)algorithmGroup[ACTIVATE_DETERMINISTIC_MODE].Value;
organic.MaximumDuration = 1000 * ((int)algorithmGroup[MAXIMAL_DURATION].Value);
organic.QualityTimeRatio = (double)algorithmGroup[QUALITY_TIME_RATIO].Value;
organic.MultiThreadingAllowed = (bool)algorithmGroup[ALLOW_MULTI_THREADING].Value;
((ComponentLayout)organic.ComponentLayout).Style = ComponentArrangementStyles.MultiRows;
ConfigureOutputRestrictions();
LayoutAlgorithm = organic;
}
void InitialChat()
{
option = new OptionGroup();
option.AddEvent(view.left.userEvent);
option.AddEvent(view.right.userEvent);
option.AddEvent(view.center.userEvent);
option.SelectChanged = SelectChanged;
option.Selecet = view.right.userEvent;
//input = view.input.userEvent as TextInput;
view.input.OnSubmit = OnSubmit;
container = view.chatbox.composite as UIContainer;
//other = new UILinker<ChatItem, ChatData>(container,view.other);
other = new UILinker <ChatItem, ChatData>(container, view.other);
other.LayoutCallback = GetContentSize;
other.ItemUpdate = ItemUpdate;
self = new UILinker <ChatItem, ChatData>(container, view.self);
self.LayoutCallback = GetContentSize;
self.ItemUpdate = ItemUpdate;
tip = new UILinker <TipItem, TipData>(container, view.tip);
//tip.ItemUpdate = TipItemUpdate;
view.send.userEvent.Click = (o, e) => { OnSubmit(view.input); };
view.ItemText.activeSelf = false;
var size = view.ItemText.SizeDelta;
view.ItemText.GetGenerationSettings(ref size, ref settings);
}
///<inheritdoc/>
protected override void SetupHandler()
{
createRouter();
OptionGroup layoutGroup = Handler.AddGroup(GROUP_LAYOUT);
ConstraintManager cm = new ConstraintManager(Handler);
//Layout options
layoutGroup.AddList(SCOPE, new[] { ALL, SUBSET_BUS, SUBSET, PARTIAL }, ALL);
layoutGroup.AddList(BUSES, new[] { SINGLE, LABEL, TAG, CUSTOM }, SINGLE);
IOptionItem gridEnabledItem = layoutGroup.AddBool(GRID_ENABLED, router.GridRouting);
IOptionItem gridSpacingItem = layoutGroup.AddInt(GRID_SPACING, router.GridSpacing, 1, int.MaxValue);
layoutGroup.AddInt(MIN_DISTANCE_TO_NODES, router.MinimumDistanceToNode, 1, int.MaxValue);
layoutGroup.AddInt(MIN_DISTANCE_TO_EDGES, router.MinimumDistanceToEdge, 1, int.MaxValue);
cm.SetEnabledOnValueEquals(gridEnabledItem, true, gridSpacingItem);
//Selection options
OptionGroup selectionGroup = Handler.AddGroup(GROUP_SELECTION);
selectionGroup.AddInt(PREFERRED_BACKBONE_COUNT, router.PreferredBackboneSegmentCount, 1, int.MaxValue);
selectionGroup.AddDouble(MINIMUM_BACKBONE_LENGTH, router.MinimumBackboneSegmentLength, 1, double.MaxValue);
//Routing options
OptionGroup routingGroup = Handler.AddGroup(GROUP_ROUTING);
routingGroup.AddDouble(CROSSING_COST, router.CrossingCost, 0, double.MaxValue);
routingGroup.AddBool(CROSSING_REROUTING, router.Rerouting);
routingGroup.AddInt(MINIMUM_CONNECTIONS_COUNT, router.MinimumBusConnectionsCount, 0, int.MaxValue);
}
private static DiceOptions MergeOptions(OptionGroup options)
{
var result = new DiceOptions();
if (options == null)
{
return(result);
}
foreach (var option in options.Options)
{
if (option is FilterOption filter)
{
result.Filter = filter;
}
if (option is RankingOption ranking)
{
result.Ranking = ranking;
}
if (option is AggregateOption aggregate)
{
result.Aggregation = aggregate.Type;
}
if (option is ExplodingOption)
{
result.Exploding = true;
}
}
return(result);
}
public async Task ShouldRespond422IfGroupHasOptions()
{
var itemGroup = new ItemGroup().Of(_token.TenantId);
var optionGroup = new OptionGroup().To(itemGroup);
var option = new Option().To(optionGroup);
_server.Database.ItemGroups.Add(itemGroup);
_server.Database.OptionGroups.Add(optionGroup);
_server.Database.Options.Add(option);
await _server.Database.SaveChangesAsync();
var path = $"/option-groups/{optionGroup.Id}";
var response = await _client.DeleteAsync(path);
var jsonResponse = await _client.ReadJsonAsync <UnprocessableEntityError>(response);
var hasBeenDeleted = !await _server.Database.OptionGroups
.WhereKey(_token.TenantId, optionGroup.Id)
.AnyAsync();
Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode);
Assert.Equal("OPTION_GROUP_HAS_OPTIONS", jsonResponse.Error);
Assert.False(hasBeenDeleted);
}
private void ApplyOptions(OrthogonalLayout layout)
{
OptionGroup topLevelGroup = Handler.GetGroupByName(TOP_LEVEL);
IOptionItem styleItem = topLevelGroup.GetItemByName(ORTHOGONAL_LAYOUT_STYLE);
layout.LayoutStyle = styles[(string)styleItem.Value];
}
private static PerLanguageOption <T> CreateOption <T>(OptionGroup group, string name, T defaultValue, params OptionStorageLocation[] storageLocations)
{
var option = new PerLanguageOption <T>(nameof(CodeStyleOptions), group, name, defaultValue, storageLocations);
s_allOptionsBuilder.Add(option);
return(option);
}
private static Option2 <T> CreateOption <T>(OptionGroup group, string name, T defaultValue, params OptionStorageLocation2[] storageLocations)
{
var option = new Option2 <T>(nameof(FormattingOptions), group, name, defaultValue, storageLocations);
s_allOptionsBuilder.Add(option);
return(option);
}
///<inheritdoc/>
protected override void SetupHandler()
{
ConstraintManager cm = new ConstraintManager(Handler);
OptionGroup toplevelGroup = Handler.AddGroup(TOP_LEVEL);
//the toplevel group will show neither in Table view nor in dialog view explicitely
//it's children will be shown one level above
toplevelGroup.SetAttribute(TableEditorFactory.RENDERING_HINTS_ATTRIBUTE,
(int)TableEditorFactory.RenderingHints.Invisible);
toplevelGroup.SetAttribute(DefaultEditorFactory.RENDERING_HINTS_ATTRIBUTE,
(int)DefaultEditorFactory.RenderingHints.Invisible);
OptionGroup generalGroup = toplevelGroup.AddGroup(GENERAL);
OptionItem operationItem = generalGroup.AddList(OPERATION, operationEnum.Keys, SCALE);
generalGroup.AddBool(ACT_ON_SELECTION_ONLY, false);
OptionGroup rotateGroup = toplevelGroup.AddGroup(ROTATE);
cm.SetEnabledOnValueEquals(operationItem, ROTATE, rotateGroup);
rotateGroup.AddInt(ROTATION_ANGLE, (int)transformer.RotationAngle, -360, 360);
rotateGroup.AddBool(APPLY_BEST_FIT_ROTATION, applyBestFitRotation);
OptionGroup scaleGroup = toplevelGroup.AddGroup(SCALE);
cm.SetEnabledOnValueEquals(operationItem, SCALE, scaleGroup);
scaleGroup.AddDouble(SCALE_FACTOR, transformer.ScaleFactorX, 0.1, 10.0);
scaleGroup.AddBool(SCALE_NODE_SIZE, transformer.ScaleNodeSize);
OptionGroup translateGroup = toplevelGroup.AddGroup(TRANSLATE);
cm.SetEnabledOnValueEquals(operationItem, TRANSLATE, translateGroup);
translateGroup.AddDouble(TRANSLATE_X, transformer.TranslateX);
translateGroup.AddDouble(TRANSLATE_Y, transformer.TranslateY);
}
/// <summary>
/// Creates a class type option description
/// </summary>
/// <param name="group"> a reference to the option group. </param>
/// <param name="name"> the name of the option. </param>
/// <param name="shortDescription"> a short description of the option. </param>
/// <param name="flag"> a short string that can be used in the command line. </param>
/// <param name="usage"> a string that explains the usage of the option. </param>
/// <exception cref="OptionException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ClassOption(org.maltparser.core.options.OptionGroup group, String name, String shortDescription, String flag, String usage) throws org.maltparser.core.exception.MaltChainedException
public ClassOption(OptionGroup group, string name, string shortDescription, string flag, string usage) : base(group, name, shortDescription, flag, usage)
{
legalValues = Collections.synchronizedSortedSet(new SortedSet <string>());
legalValueDesc = Collections.synchronizedMap(new Dictionary <string, string>());
legalValueClass = Collections.synchronizedMap(new Dictionary <string, Type>());
classLegalValues = Collections.synchronizedMap(new Dictionary <Type, string>());
}
protected override void SetupHandler()
{
OptionGroup toplevelGroup = Handler.AddGroup(TOP_LEVEL);
//the toplevel group will show neither in Table view nor in dialog view explicitely
//it's children will be shown one level above
toplevelGroup.SetAttribute(TableEditorFactory.RENDERING_HINTS_ATTRIBUTE,
(int)TableEditorFactory.RenderingHints.Invisible);
toplevelGroup.SetAttribute(DefaultEditorFactory.RENDERING_HINTS_ATTRIBUTE,
(int)DefaultEditorFactory.RenderingHints.Invisible);
OptionGroup spcg = toplevelGroup.AddGroup(SourcePortConstraints);
spcg.AddGeneric(PortConstraintStr, PortConstraintType.Any).SetAttribute(OptionItem.SUPPORT_NULL_VALUE_ATTRIBUTE,
false);
spcg.AddBool(StrongPortConstraint, false);
OptionGroup tpcg = toplevelGroup.AddGroup(TargetPortConstraints);
tpcg.AddGeneric(PortConstraintStr, PortConstraintType.Any).SetAttribute(OptionItem.SUPPORT_NULL_VALUE_ATTRIBUTE,
false);
tpcg.AddBool(StrongPortConstraint, false);
CollectionOptionItem <string> scopeItem = toplevelGroup.AddList(Scope, scopes, ScopeAllEdges);
BoolOptionItem clearItem = toplevelGroup.AddBool(ClearAllConstraints, false);
ConstraintManager cm = new ConstraintManager(Handler);
cm.SetEnabledOnValueEquals(clearItem, false, spcg);
cm.SetEnabledOnValueEquals(clearItem, false, scopeItem);
cm.SetEnabledOnValueEquals(clearItem, false, tpcg);
}
private bool DrawMultiSelectorEditBegin(OptionGroup group)
{
var groupName = group.GroupName;
if (ImGuiCustom.BeginFramedGroupEdit(ref groupName) &&
groupName != group.GroupName &&
!Meta !.Groups.ContainsKey(groupName))
{
var oldConf = Mod !.Settings[group.GroupName];
Meta.Groups.Remove(group.GroupName);
Mod.FixSpecificSetting(group.GroupName);
if (groupName.Length > 0)
{
Meta.Groups[groupName] = new OptionGroup()
{
GroupName = groupName,
SelectionType = SelectType.Multi,
Options = group.Options,
};
Mod.Settings[groupName] = oldConf;
}
return(true);
}
return(false);
}
///<inheritdoc/>
protected override void SetupHandler()
{
createOrganic();
OptionGroup visualGroup = Handler.AddGroup(VISUAL);
visualGroup.AddList(SCOPE, scopeEnum.Keys, ALL);
visualGroup.AddList(INITIAL_PLACEMENT, initialPlacementEnum.Keys, AS_IS);
visualGroup.AddDouble(PREFERRED_EDGE_LENGTH, organic.PreferredEdgeLength, 0.0, double.MaxValue);
visualGroup.AddBool(OBEY_NODE_SIZES, organic.ConsiderNodeSizes);
visualGroup.AddInt(ATTRACTION, organic.Attraction, 0, 2);
visualGroup.AddInt(REPULSION, organic.Repulsion, 0, 2);
visualGroup.AddDouble(GRAVITY_FACTOR, organic.GravityFactor, -0.2, 2);
visualGroup.AddBool(ACTIVATE_TREE_BEAUTIFIER, organic.ActivateTreeBeautifier);
OptionGroup algoGroup = Handler.AddGroup(ALGORITHM);
algoGroup.AddDouble(ITERATION_FACTOR, organic.IterationFactor);
algoGroup.AddInt(MAXIMAL_DURATION, (int)(organic.MaximumDuration / 1000));
algoGroup.AddBool(ACTIVATE_DETERMINISTIC_MODE, organic.Deterministic);
algoGroup.AddBool(ACTIVATE_MULTI_THREADING, organic.MultiThreadingAllowed);
OptionGroup groupingGroup = Handler.AddGroup(GROUPING);
groupingGroup.AddList(GROUP_LAYOUT_POLICY, groupPolicyEnum.Keys, LAYOUT_GROUPS);
groupingGroup.AddDouble(GROUP_NODE_COMPACTNESS, organic.GroupNodeCompactness, 0, 1);
}
public async Task <ActionResult <OptionGroup> > PostOptionGroup(OptionGroup optionGroup)
{
_dbContext.OptionGroup.Add(optionGroup);
await _dbContext.SaveChangesAsync();
return(CreatedAtAction("GetOptionGroup", new { key = optionGroup.OptionGroupKey }, optionGroup));
}
///<inheritdoc/>
protected override void ConfigureLayout()
{
createOrganic();
OptionGroup visualGroup = (OptionGroup)Handler.GetGroupByName(VISUAL);
organic.PreferredEdgeLength = (int)visualGroup[PREFERRED_EDGE_LENGTH].Value;
string initialPlacementChoice = (string)visualGroup[INITIAL_PLACEMENT].Value;
organic.InitialPlacement = initialPlacementEnum[initialPlacementChoice];
string scopeChoice = (string)visualGroup[SCOPE].Value;
organic.Scope = scopeEnum[scopeChoice];
organic.GravityFactor = (double)visualGroup[GRAVITY_FACTOR].Value;
organic.ConsiderNodeSizes = (bool)visualGroup[OBEY_NODE_SIZES].Value;
organic.ActivateTreeBeautifier = (bool)visualGroup[ACTIVATE_TREE_BEAUTIFIER].Value;
organic.Attraction = (int)visualGroup[ATTRACTION].Value;
organic.Repulsion = 2 - (int)visualGroup[REPULSION].Value;
OptionGroup algoGroup = (OptionGroup)Handler.GetGroupByName(ALGORITHM);
organic.MaximumDuration = 1000 * (int)algoGroup[MAXIMAL_DURATION].Value;
organic.IterationFactor = (double)algoGroup[ITERATION_FACTOR].Value;
organic.Deterministic = (bool)algoGroup[ACTIVATE_DETERMINISTIC_MODE].Value;
if (ContainsGroupNodes())
{
string groupPolicyChoice = (string)Handler.GetValue(GROUPING, GROUP_LAYOUT_POLICY);
organic.GroupNodePolicy = groupPolicyEnum[groupPolicyChoice];
organic.GroupNodeCompactness = (double)Handler.GetValue(GROUPING, GROUP_NODE_COMPACTNESS);
}
organic.MultiThreadingAllowed = (bool)algoGroup[ACTIVATE_MULTI_THREADING].Value;
LayoutAlgorithm = organic;
}
public async Task <IActionResult> PutOptionGroup(Guid key, OptionGroup optionGroup)
{
if (key != optionGroup.OptionGroupKey)
{
return(BadRequest());
}
_dbContext.Entry(optionGroup).State = EntityState.Modified;
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OptionGroupExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
static void Main(string[] args)
{
// create Options object
Options options = new Options();
// add t option
options.AddOption("t", false, "display current time");
options.AddOption("h", false, "Display help options");
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.Parse(options, args);
options.AddOption("h", "help", false, "Print this usage information");
options.AddOption("v", "verbose", false, "Print out VERBOSE information");
OptionGroup optionGroup = new OptionGroup();
optionGroup.AddOption(new OptionBuilder("f").HasArg(true).ArgName("filename").Build());
optionGroup.AddOption(new OptionBuilder("m").HasArg(true).ArgName("email").Build());
options.AddOptionGroup(optionGroup);
if (cmd.HasOption("h"))
{
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("x", options, true);
return;
}
if (cmd.HasOption("t"))
{
Console.WriteLine(System.DateTime.Now);
}
}
///<inheritdoc/>
protected override void ConfigureLayout()
{
OptionGroup toplevelGroup = (OptionGroup)Handler.GetGroupByName(TOP_LEVEL);
OptionGroup generalGroup = (OptionGroup)toplevelGroup.GetGroupByName(GENERAL);
string operationChoice = (string)generalGroup[OPERATION].Value;
transformer.Operation = operationEnum[operationChoice];
transformer.SubgraphLayoutEnabled = (bool)generalGroup[ACT_ON_SELECTION_ONLY].Value;
transformer.RotationAngle = (int)toplevelGroup.GetValue(ROTATE, ROTATION_ANGLE);
if ((bool)toplevelGroup.GetValue(ROTATE, APPLY_BEST_FIT_ROTATION) &&
((string)toplevelGroup.GetValue(GENERAL, OPERATION)).Equals(ROTATE))
{
CanvasControl cv = Context.Lookup <CanvasControl>();
if (cv != null)
{
var size = cv.InnerSize;
applyBestFitRotation = true;
transformer.RotationAngle =
GraphTransformer.FindBestFitRotationAngle(CurrentLayoutGraph, size.Width, size.Height);
}
}
else
{
applyBestFitRotation = false;
}
transformer.ScaleFactor = (double)toplevelGroup.GetValue(SCALE, SCALE_FACTOR);
transformer.ScaleNodeSize = (bool)toplevelGroup.GetValue(SCALE, SCALE_NODE_SIZE);
transformer.TranslateX = (double)toplevelGroup.GetValue(TRANSLATE, TRANSLATE_X);
transformer.TranslateY = (double)toplevelGroup.GetValue(TRANSLATE, TRANSLATE_Y);
LayoutAlgorithm = transformer;
}
/// <summary>
/// sets the global layout options.
/// </summary>
/// <param name="orthogonal"></param>
private void SetGlobalOptions(OrthogonalLayout orthogonal)
{
OptionGroup layoutGroup = Handler.GetGroupByName(LAYOUT);
OptionGroup edgeGroup = Handler.GetGroupByName(EDGES);
orthogonal.LayoutStyle = styles[(string)layoutGroup[STYLE].Value];
if ((bool)edgeGroup[DRAW_SELECTED_EDGES_UPWARDS].Value)
{
var ol = (OrientationLayout)orthogonal.OrientationLayout;
string orientationChoice = (string)edgeGroup[ORIENTATION].Value;
ol.Orientation = orientEnum[orientationChoice];
}
orthogonal.GridSpacing = ((int)layoutGroup[GRID].Value);
orthogonal.EdgeLengthReduction = ((bool)layoutGroup[LENGTH_REDUCTION].Value);
orthogonal.OptimizePerceivedBends = ((bool)layoutGroup[PERCEIVED_BENDS_POSTPROCESSING].Value);
orthogonal.CrossingReduction =
(bool)layoutGroup[CROSSING_POSTPROCESSING].Value;
orthogonal.Randomization = (bool)layoutGroup[USE_RANDOMIZATION].Value;
orthogonal.FaceMaximization = (bool)layoutGroup[USE_FACE_MAXIMIZATION].Value;
orthogonal.FromSketchMode = (bool)layoutGroup[USE_EXISTING_DRAWING_AS_SKETCH].Value;
orthogonal.EdgeLayoutDescriptor.MinimumFirstSegmentLength = (double)edgeGroup[MINIMUM_FIRST_SEGMENT_LENGTH].Value;
orthogonal.EdgeLayoutDescriptor.MinimumLastSegmentLength = (double)edgeGroup[MINIMUM_LAST_SEGMENT_LENGTH].Value;
orthogonal.EdgeLayoutDescriptor.MinimumSegmentLength = (double)edgeGroup[MINIMUM_SEGMENT_LENGTH].Value;
}
protected override void SetupHandler()
{
CreateLayout();
OptionGroup generalGroup = Handler.AddGroup(GENERAL);
generalGroup.AddList(CENTER_STRATEGY, centerNodeStrategies.Keys, CENTER_WEIGHTED_CENTRAL);
generalGroup.AddList(LAYERING_STRATEGY, layeringStrategies.Keys, LAYERING_BFS);
generalGroup.AddDouble(MINIMAL_LAYER_DISTANCE, (int)layout.MinimumLayerDistance, 1, 1000);
generalGroup.AddDouble(MINIMAL_NODE_DISTANCE, (int)layout.MinimumNodeToNodeDistance, 0, 300);
generalGroup.AddDouble(MAXIMAL_CHILD_SECTOR_SIZE, (int)layout.MaximumChildSectorAngle, 15, 360);
OptionItem routingStrategyItem = generalGroup.AddList(EDGE_ROUTING_STRATEGY, edgeRoutingStrategies, EDGE_ARC);
int smoothness =
(int)
Math.Min(MAXIMUM_SMOOTHNESS,
(1 + MAXIMUM_SMOOTHNESS * SMOOTHNESS_ANGLE_FACTOR - layout.MinimumBendAngle) / SMOOTHNESS_ANGLE_FACTOR);
IOptionItem smoothnessItem = generalGroup.AddInt(EDGE_SMOOTHNESS, smoothness, MINIMUM_SMOOTHNESS, MAXIMUM_SMOOTHNESS);
ConstraintManager cm = new ConstraintManager(Handler);
cm.SetEnabledOnValueEquals(routingStrategyItem, EDGE_ARC, smoothnessItem);
var bundlingStrength = generalGroup.AddDouble(EDGE_BUNDLING_STRENGTH, 0.99, 0, 1);
cm.SetEnabledOnValueEquals(routingStrategyItem, EDGE_BUNDLES, bundlingStrength);
generalGroup.AddBool(CONSIDER_NODE_LABELS, layout.ConsiderNodeLabels);
}
private bool DrawSingleSelectorEditGroup(OptionGroup group, ref bool selectionChanged)
{
var groupName = group.GroupName;
if (ImGui.InputText($"##{groupName}_add", ref groupName, 64, ImGuiInputTextFlags.EnterReturnsTrue) &&
!Meta !.Groups.ContainsKey(groupName))
{
var oldConf = Mod !.Settings[group.GroupName];
if (groupName != group.GroupName)
{
Meta.Groups.Remove(group.GroupName);
selectionChanged |= Mod.FixSpecificSetting(group.GroupName);
}
if (groupName.Length > 0)
{
Meta.Groups.Add(groupName, new OptionGroup()
{
GroupName = groupName,
Options = group.Options,
SelectionType = SelectType.Single,
});
Mod.Settings[groupName] = oldConf;
}
return(true);
}
return(false);
}
public async Task ShouldPublishEventAfterUpdateSuccessfully()
{
var itemGroup = new ItemGroup().Of(_token.TenantId);
var optionGroup1 = new OptionGroup().To(itemGroup);
var optionGroup2 = new OptionGroup().To(itemGroup);
var option = new Option().To(optionGroup1);
_server.Database.ItemGroups.Add(itemGroup);
_server.Database.OptionGroups.AddRange(optionGroup1, optionGroup2);
_server.Database.Options.Add(option);
await _server.Database.SaveChangesAsync();
var path = $"options/{option.Id}";
var jsonRequest = new SaveOptionJson().Build(groupId: optionGroup2.Id);
var response = await _client.PutJsonAsync(path, jsonRequest);
var publishedEvent = _server.EventBus.PublishedEvents
.Single(@event => @event.Name == "menu.option.updated");
var payload = (OptionPayload)publishedEvent.Payload;
await _server.Database.Entry(option).ReloadAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(payload.Id, option.Id);
Assert.Equal(payload.TenantId, option.TenantId);
Assert.Equal(payload.Name, option.Name);
Assert.Equal(payload.Description, option.Description);
Assert.Equal(payload.Price, option.Price);
Assert.Equal(payload.IsAvailable, option.IsAvailable);
}
///<inheritdoc/>
protected override void ConfigureLayout()
{
OptionGroup layoutGroup = (OptionGroup)Handler.GetGroupByName(LAYOUT_OPTIONS);
router.MinimumDistance = (int)layoutGroup[MINIMAL_NODE_DISTANCE].Value;
router.KeepExistingBends = (bool)layoutGroup[USE_BENDS].Value;
router.RouteAllEdges = (bool)layoutGroup[ROUTE_ONLY_NECESSARY].Value;
SequentialLayout sl = new SequentialLayout();
if ((bool)layoutGroup[ALLOW_MOVING_NODES].Value)
{
//if we are allowed to move nodes, we can improve the routing results by temporarily enlarging nodes and removing overlaps
//(this strategy ensures that there is enough space for the edges)
CompositeLayoutStage cls = new CompositeLayoutStage();
cls.AppendStage(router.CreateNodeEnlargementStage());
cls.AppendStage(new RemoveOverlapsStage(0));
sl.AppendLayout(cls);
}
if (router.KeepExistingBends)
{
//we want to keep the original bends
BendConverter bendConverter = new BendConverter();
bendConverter.AffectedEdgesDpKey = OrganicEdgeRouter.AffectedEdgesDpKey;
bendConverter.AdoptAffectedEdges = (bool)layoutGroup[SELECTION_ONLY].Value;
bendConverter.CoreLayout = router;
sl.AppendLayout(bendConverter);
}
else
{
sl.AppendLayout(router);
}
LayoutAlgorithm = new HideGroupsStage(sl);
}
public static Options CreateFromType(Type type)
{
if (type == null)
throw new ArgumentNullException("type");
//if (!Attribute.IsDefined(type, typeof(OptionsAttribute)))
// throw new ArgumentException("The type '" + type + "' is not marked as options");
MemberInfo[] members = type.FindMembers(MemberTypes.Field | MemberTypes.Property,
BindingFlags.Public | BindingFlags.Instance,
FilterMember, null);
var groups = new Dictionary<string, OptionGroup>();
var requiredGroups = new List<string>();
Attribute[] groupsAttrs = Attribute.GetCustomAttributes(type, typeof(OptionGroupAttribute));
foreach (OptionGroupAttribute groupAttr in groupsAttrs) {
OptionGroup group;
if (!groups.TryGetValue(groupAttr.Name, out @group)) {
@group = new OptionGroup {IsRequired = groupAttr.IsRequired};
groups[groupAttr.Name] = @group;
if (groupAttr.IsRequired)
requiredGroups.Add(groupAttr.Name);
}
}
var options = new Options();
foreach (MemberInfo member in members) {
Option option = CreateOptionFromMember(member, groups);
if (option != null)
options.AddOption(option);
}
foreach(var entry in groups) {
var group = entry.Value;
options.AddOptionGroup(group);
}
return options;
}
public Options AddOptionGroup(OptionGroup group)
{
if (group.IsRequired) {
foreach (var option in group.Options) {
requiredOpts.Add(option.Key());
}
}
foreach(var opt in group.Options) {
var option = (Option) opt;
// an Option cannot be required if it is in an
// OptionGroup, either the group is required or
// nothing is required
option.IsRequired = false;
AddOption(option);
optionGroups[option.Key()] = group;
}
return this;
}
/// <summary>
/// Creates a option group based on the given info.
/// </summary>
/// <param name="p_xelGroup">The script file node corresponding to the group to add.</param>
/// <returns>The added group.</returns>
protected override OptionGroup ParseGroup(XElement p_xelGroup)
{
string strName = p_xelGroup.Attribute("name").Value;
OptionGroupType gtpType = (OptionGroupType)Enum.Parse(typeof(OptionGroupType), p_xelGroup.Attribute("type").Value);
XElement xelOptions = p_xelGroup.Element("plugins");
SortOrder sodOptionOrder = ParseSortOrder(xelOptions.Attribute("order").Value);
OptionGroup pgpGroup = new OptionGroup(strName, gtpType, sodOptionOrder);
foreach (XElement xelOption in xelOptions.Elements())
pgpGroup.Options.Add(ParseOption(xelOption));
return pgpGroup;
}
/// <summary>
/// Adds a new <see cref="Option"/> to the script.
/// </summary>
/// <param name="p_ogpGroup">The step to which to add the <see cref="Option"/>.</param>
protected void AddOption(OptionGroup p_ogpParent)
{
if (p_ogpParent == null)
return;
string strOptionName = null;
for (Int32 i = 1; i < Int32.MaxValue; i++)
{
strOptionName = String.Format("New Option {0}", i);
if (!p_ogpParent.Options.Contains(x => strOptionName.Equals(x.Name)))
break;
strOptionName = null;
}
if (strOptionName == null)
throw new Exception("Unable to new new Option: too many options exist.");
p_ogpParent.Options.Add(new Option(strOptionName, null, null, null));
}
/// <summary>
/// Deletes the given <see cref="OptionGroup"/> from the script.
/// </summary>
/// <param name="p_ogpGroup">The <see cref="OptionGroup"/> to delete.</param>
protected void DeleteOptionGroup(OptionGroup p_ogpGroup)
{
if (p_ogpGroup == null)
return;
foreach (InstallStep ispStep in Script.InstallSteps)
if (ispStep.OptionGroups.Remove(p_ogpGroup))
return;
}
public OptionProfileCreator(OptionGroup options)
{
Options = options;
}
/// <summary>
/// Adds a group to the list of plugins.
/// </summary>
/// <param name="p_ogpGroup">The plugin group to add.</param>
/// <returns>The new <see cref="ListViewGroup"/> representing the group.</returns>
private ListViewGroup AddGroup(OptionGroup p_ogpGroup)
{
ListViewGroup lvgGroup = null;
foreach (ListViewGroup lvgExistingGroup in lvwPlugins.Groups)
if (lvgExistingGroup.Name.Equals(p_ogpGroup.Name))
{
lvgGroup = lvgExistingGroup;
break;
}
if (lvgGroup == null)
{
lvgGroup = new ListViewGroup();
lvwPlugins.Groups.Add(lvgGroup);
}
lvgGroup.Name = p_ogpGroup.Name;
lvgGroup.Tag = p_ogpGroup.Type;
switch (p_ogpGroup.Type)
{
case OptionGroupType.SelectAll:
lvgGroup.Header = p_ogpGroup.Name + " (All Required)";
break;
case OptionGroupType.SelectAtLeastOne:
lvgGroup.Header = p_ogpGroup.Name + " (One Required)";
break;
case OptionGroupType.SelectAtMostOne:
lvgGroup.Header = p_ogpGroup.Name + " (Select Only One)";
break;
case OptionGroupType.SelectExactlyOne:
lvgGroup.Header = p_ogpGroup.Name + " (Select One)";
break;
case OptionGroupType.SelectAny:
lvgGroup.Header = p_ogpGroup.Name;
break;
}
return lvgGroup;
}
public KeyboardProfile(OptionGroup options)
: base(options)
{
}
public OptionGroupVM(OptionGroup p_opgGroup)
{
OptionGroup = p_opgGroup;
Reset();
}
protected void FormatOptionGroup(XmlScriptTreeNode p_stnNode, OptionGroup p_opgGroup)
{
p_stnNode.Text = String.Format("Option Group: {0}", p_opgGroup.Name);
}
/// <summary>
/// The editor to use to edit an <see cref="OptionGroup"/>.
/// </summary>
/// <param name="p_opgGroup">The <see cref="OptionGroup"/> to edit.</param>
/// <param name="p_lstModFiles">The list of files in the mod to which the <see cref="XmlScript"/>
/// being edited belongs.</param>
/// <returns>The editor to use to edit an <see cref="OptionGroup"/>. <c>null</c> is returned if the
/// current <see cref="XmlScript"/> does not support editing <see cref="OptionGroup"/>s.</returns>
public virtual NodeEditor GetOptionGroupEditor(OptionGroup p_opgGroup, IList<VirtualFileSystemItem> p_lstModFiles)
{
OptionGroupEditorVM vmlGroupEditor = new OptionGroupEditorVM(p_opgGroup, OptionGroupProperties.Name | OptionGroupProperties.Type);
return new OptionGroupEditor(vmlGroupEditor);
}
public OptionGroupEditorVM(OptionGroup p_opgGroup, OptionGroupProperties p_ogpEditableProperties)
{
OptionGroup = p_opgGroup;
NameVisible = (p_ogpEditableProperties & OptionGroupProperties.Name) > 0;
TypeVisible = (p_ogpEditableProperties & OptionGroupProperties.Type) > 0;
OptionSortOrderVisible = (p_ogpEditableProperties & OptionGroupProperties.OptionSortOrder) > 0;
OptionGroupTypes = Enum.GetValues(typeof(OptionGroupType));
SortOrders = Enum.GetValues(typeof(SortOrder));
Errors = new ErrorContainer();
}
protected void HandleOptionGroupPropertyChange(XmlScriptTreeNode p_stnNode, OptionGroup p_opgGroup, string p_strPropertyName)
{
if (p_strPropertyName.Equals(ObjectHelper.GetPropertyName<OptionGroup>(x => x.Options)))
{
SelectedNode = p_stnNode;
AddOptions((XmlScriptTreeNode<OptionGroup>)p_stnNode);
}
}
private static Option CreateOptionFromMember(MemberInfo member, IDictionary<string, OptionGroup> groups)
{
var attribute = (OptionAttribute) Attribute.GetCustomAttribute(member, typeof(OptionAttribute));
string optionName = null;
string optionLongName = null;
if (attribute != null) {
optionLongName = attribute.LongName;
optionName = attribute.Name;
}
if (String.IsNullOrEmpty(optionName))
optionName = member.Name[0].ToString(CultureInfo.InvariantCulture);
if (String.IsNullOrEmpty(optionLongName))
optionLongName = member.Name;
var desc = attribute != null ? attribute.Description : null;
var option = new Option(optionName, desc) {
LongName = optionLongName,
ArgumentCount = attribute != null ? attribute.ArgumentCount : 0,
IsRequired = attribute != null && attribute.IsRequired,
ArgumentName = attribute != null ? attribute.ArgumentName : "arg",
ValueSeparator = attribute != null ? attribute.ValueSeparator : ' ',
HasOptionalArgument = attribute != null && attribute.HasOptionalArgument
};
var groupAttr = (OptionGroupAttribute)Attribute.GetCustomAttribute(member, typeof(OptionGroupAttribute));
if (groupAttr != null) {
OptionGroup group;
if (!groups.TryGetValue(groupAttr.Name, out group)) {
group = new OptionGroup();
groups[groupAttr.Name] = group;
}
group.AddOption(option);
return null;
}
return option;
}
/// <summary>
/// Unparses the given <see cref="OptionGroup"/>.
/// </summary>
/// <remarks>
/// This method can be overidden to provide game-specific or newer-version unparsing.
/// </remarks>
/// <param name="p_ogpGroup">The <see cref="OptionGroup"/> for which to generate XML.</param>
/// <returns>The XML representation of the given <see cref="OptionGroup"/>.</returns>
protected override XElement UnparseOptionGroup(OptionGroup p_ogpGroup)
{
XElement xelGroup = base.UnparseOptionGroup(p_ogpGroup);
XElement xelOptions = xelGroup.Element("plugins");
xelOptions.Add(new XAttribute("order", UnparseSortOrder(p_ogpGroup.OptionSortOrder)));
return xelGroup;
}
/// <summary>
/// Creates a option group based on the given info.
/// </summary>
/// <param name="p_xelGroup">The script file node corresponding to the group to add.</param>
/// <returns>The added group.</returns>
protected virtual OptionGroup ParseGroup(XElement p_xelGroup)
{
string strName = p_xelGroup.Attribute("name").Value;
OptionGroupType gtpType = (OptionGroupType)Enum.Parse(typeof(OptionGroupType), p_xelGroup.Attribute("type").Value);
XElement xelOptions = p_xelGroup.Element("plugins");
OptionGroup pgpGroup = new OptionGroup(strName, gtpType, SortOrder.Ascending);
foreach (XElement xelOption in xelOptions.Elements())
pgpGroup.Options.Add(ParseOption(xelOption));
return pgpGroup;
}
/// <summary>
/// Unparses the given <see cref="OptionGroup"/>.
/// </summary>
/// <remarks>
/// This method can be overidden to provide game-specific or newer-version unparsing.
/// </remarks>
/// <param name="p_ogpGroup">The <see cref="OptionGroup"/> for which to generate XML.</param>
/// <returns>The XML representation of the given <see cref="OptionGroup"/>.</returns>
protected virtual XElement UnparseOptionGroup(OptionGroup p_ogpGroup)
{
XElement xelGroup = new XElement("group",
new XAttribute("name", p_ogpGroup.Name),
new XAttribute("type", UnparseOptionGroupType(p_ogpGroup.Type)));
XElement xelOptions = new XElement("plugins");
xelGroup.Add(xelOptions);
foreach (Option optOption in p_ogpGroup.Options)
xelOptions.Add(UnparseOption(optOption));
return xelGroup;
}
