public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { // Execute code directly. case "Code": lua.DoString(parameter.GetValue<string>()); break; // Open the .lua file in SS14.Server\Scripts\ case "File": string fileName = Path.Combine("Scripts", parameter.GetValue<string>()); string fileContents = ""; if (scriptCache.ContainsKey(fileName)) { // Console.WriteLine("Getting {0} from ScriptCache", fileName); fileContents = scriptCache[fileName]; } else { if (!File.Exists(fileName)) throw new FileNotFoundException("Unable to find Lua script file!", fileName); fileContents = File.ReadAllText(fileName); scriptCache.Add(fileName, fileContents); } lua.DoString(fileContents); break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "lightoffsetx": _lightOffset.X = parameter.GetValue<float>(); //float.Parse((string)parameter.Parameter, System.Globalization.CultureInfo.InvariantCulture); break; case "lightoffsety": _lightOffset.Y = parameter.GetValue<float>(); //float.Parse((string)parameter.Parameter, System.Globalization.CultureInfo.InvariantCulture); break; case "lightradius": _lightRadius = parameter.GetValue<int>(); //int.Parse((string) parameter.Parameter); break; case "lightColorR": _lightColor.X = parameter.GetValue<int>(); //int.Parse((string) parameter.Parameter); break; case "lightColorG": _lightColor.Y = parameter.GetValue<int>(); //int.Parse((string)parameter.Parameter); break; case "lightColorB": _lightColor.Z = parameter.GetValue<int>(); //int.Parse((string)parameter.Parameter); break; case "mask": _mask = parameter.GetValue<string>(); // parameter.Parameter; break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "OpenSprite": openSprite = parameter.GetValue<string>(); break; case "ClosedSprite": closedSprite = parameter.GetValue<string>(); break; case "OpenOnBump": openonbump = parameter.GetValue<bool>(); break; case "AutoCloseInterval": var autocloseinterval = parameter.GetValue<int>(); if (autocloseinterval == 0) autoclose = false; else { autoclose = true; openLength = autocloseinterval; } break; default: base.SetParameter(parameter); break; } }
/// <summary> /// Set parameters :) /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { var tileSize = IoCManager.Resolve<IMapManager>().TileSize; //base.SetParameter(parameter); switch (parameter.MemberName) { case "SizeX": var width = parameter.GetValue<float>() / tileSize; AABB = new FloatRect(AABB.Left + (AABB.Width - width) / 2f, AABB.Top, width, AABB.Height); break; case "SizeY": var height = parameter.GetValue<float>() / tileSize; AABB = new FloatRect(AABB.Left, AABB.Top + (AABB.Height - height) / 2f, AABB.Width, height); break; case "OffsetX": var x = parameter.GetValue<float>() / tileSize; AABB = new FloatRect(x - AABB.Width / 2f, AABB.Top, AABB.Width, AABB.Height); break; case "OffsetY": var y = parameter.GetValue<float>() / tileSize; AABB = new FloatRect(AABB.Left, y - AABB.Height / 2f, AABB.Width, AABB.Height); break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "DebugColor": DebugColor = ColorUtils.FromHex(parameter.GetValue<string>(), Color.Blue); break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "DebugColor": var color = ColorTranslator.FromHtml(parameter.GetValue<string>()); if (!color.IsEmpty) DebugColor = color; break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "TweakAABB": TweakAABB = parameter.GetValue<Vector4D>(); break; } }
//private void GasEffect() //{ // ITile t = IoCManager.Resolve<IMapManager>().GetFloorAt(Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position); // if (t == null) // return; // Vector2 gasVel = t.GasCell.GasVelocity; // if (gasVel.Abs() > Mass) // Stop tiny wobbles // { // Owner.SendMessage(this, ComponentMessageType.PhysicsMove, // Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position.X + // gasVel.X, // Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position.Y + // gasVel.Y); // } //} public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "Mass": Mass = parameter.GetValue<float>(); break; } }
/// <summary> /// Set parameters :) /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { //base.SetParameter(parameter); switch (parameter.MemberName) { case "icon": var iconName = parameter.GetValue<string>(); SetIcon(iconName); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "wearloc": wearloc = (EquipmentSlot) Enum.Parse(typeof (EquipmentSlot), parameter.GetValue<string>()); break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "playersession": //TODO this shouldnt be a parameter. playerSession = parameter.GetValue<IPlayerSession>(); break; default: base.SetParameter(parameter); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "notWornSprite": SetNotWornSprite(parameter.GetValue<string>()); break; case "carriedSprite": SetCarriedSprite(parameter.GetValue<string>()); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "drawdepth": DrawDepth = (DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue<string>(), true); break; case "sprite": Name = parameter.GetValue<string>(); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "LoadThinkComponent": IThinkComponent c = GetThinkComponent(parameter.GetValue<string>()); if (c == null) break; ThinkComponents.Add(c); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "drawdepth": SetDrawDepth((DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue <string>(), true)); break; case "sprite": baseSprite = parameter.GetValue <string>(); SetSprite(parameter.GetValue <string>()); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "AddEffect": AddEffect(parameter.GetValue <string>(), 10); break; default: base.SetParameter(parameter); break; } }
public void Should_DisplayCountry_When_IdIsPresent() { //Arrange var country = _fixture.Create <CountryModel>(); _countryService.Setup(service => service.Get(It.IsAny <string>())).Returns(Task.FromResult(country)); var countryDetail = RenderComponent <CountryDetail>(ComponentParameter.CreateParameter("Id", 1)); // Act var title = countryDetail.Find("h2"); // Assert title.MarkupMatches($"<h2><span>Country</span>{country.Id}</h2>"); }
public void Renders_Label_ForPropertyWithDisplayAttributeAndAdditionalAttributes() { // Arrange Expression <Func <string> > For = () => _model.First; var parameters = new[] { ComponentParameter.CreateParameter("For", For), ComponentParameter.CreateParameter("class", "c") }; // Act var component = RenderComponent <LabelText <string> >(parameters); // Assert Assert.Equal("<label class=\"c\">my_value</label>", component.Find("label").OuterHtml); // Verify _stringLocalizerMock.Verify(localizer => localizer["Person_First"], Times.Once); }
public void Open_FixMonth_ClickYear_Click3_CheckDate() { var comp = OpenPicker(ComponentParameter.CreateParameter("FixMonth", 1)); comp.FindAll("div.mud-picker-calendar-container > .mud-picker-calendar-header > .mud-picker-calendar-header-switch > .mud-button-month").Count().Should().Be(0); comp.Find("div.mud-picker-datepicker-toolbar > button.mud-button-year").Click(); comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-year-container").Count.Should().Be(1); comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-year-container > div.mud-picker-year") .Where(x => x.TrimmedText().Contains("2022")).First().Click(); comp.FindAll("div.mud-picker-month-container").Count.Should().Be(0); comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-calendar-header").Count.Should().Be(1); comp.FindAll("button.mud-picker-calendar-day") .Where(x => x.TrimmedText().Equals("3")).First().Click(); comp.Instance.Date.Value.Date.Should().Be(new DateTime(2022, 1, 3)); }
public static WebAssemblyComponentMarker SerializeInvocation(Type type, ParameterView parameters, bool prerendered) { var assembly = type.Assembly.GetName().Name; var typeFullName = type.FullName; var(definitions, values) = ComponentParameter.FromParameterView(parameters); // We need to serialize and Base64 encode parameters separately since they can contain arbitrary data that might // cause the HTML comment to be invalid (like if you serialize a string that contains two consecutive dashes "--"). var serializedDefinitions = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(definitions, WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); var serializedValues = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(values, WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); return(prerendered ? WebAssemblyComponentMarker.Prerendered(assembly, typeFullName, serializedDefinitions, serializedValues) : WebAssemblyComponentMarker.NonPrerendered(assembly, typeFullName, serializedDefinitions, serializedValues)); }
public void Should_DisplayUserLogin_When_IdIsPresent() { //Arrange var user = _fixture.Create <UserModel>(); _userService.Setup(service => service.Get(It.IsAny <string>())).Returns(Task.FromResult(user)); var userDetail = RenderComponent <UserDetail>(ComponentParameter.CreateParameter("Id", "test")); // Act var title = userDetail.Find("h2"); // Assert title.MarkupMatches($"<h2><span>User</span> [<b>{user.Login}</b>]</h2>"); }
public void Timeline_Title_ShouldRenderWithTitle() { // Arrange const string expectedTitle = "Test Title"; // Act var timeline = _context.RenderComponent <Timeline>( ComponentParameter.CreateParameter(nameof(Timeline.Title), expectedTitle) ); // Assert var container = timeline.Find("div"); var projectTitle = container.GetElementsByTagName("h1"); projectTitle.Should().HaveCount(1); projectTitle[0].Text().Should().Be(expectedTitle); }
private void PreparePlacement(string templateName) { var prototype = _prototypeManager.Index <EntityPrototype>(templateName); ComponentParameter spriteParam = prototype.GetBaseSpriteParameters().FirstOrDefault(); //Will break if states not ordered correctly. var spriteName = spriteParam == null ? "" : spriteParam.GetValue <string>(); Sprite sprite = ResourceCache.GetSprite(spriteName); CurrentBaseSprite = sprite; CurrentBaseSpriteKey = spriteName; CurrentPrototype = prototype; IsActive = true; }
public async Task NumericFieldUpdateLoopProtectionTest() { var comp = ctx.RenderComponent <MudNumericField <int> >(); // these conversion funcs are nonsense of course, but they are designed this way to // test against an infinite update loop that numericFields and other inputs are now protected against. var numericField = comp.Instance; numericField.Converter.SetFunc = s => s.ToString(); numericField.Converter.GetFunc = s => int.Parse(s); comp.SetParametersAndRender(ComponentParameter.CreateParameter("Value", 1)); numericField.Value.Should().Be(1); numericField.Text.Should().Be("1"); comp.Find("input").Change("3"); numericField.Value.Should().Be(3); numericField.Text.Should().Be("3"); }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "LoadThinkComponent": IThinkComponent c = GetThinkComponent(parameter.GetValue <string>()); if (c == null) { break; } ThinkComponents.Add(c); break; } }
public void CheckBoxTest2() { var comp = Context.RenderComponent <MudCheckBox <bool> >(ComponentParameter.CreateParameter("Checked", true)); //Console.WriteLine(comp.Markup); // select elements needed for the test var box = comp.Instance; var input = comp.Find("input"); // check initial state box.Checked.Should().Be(true); // click and check if it has toggled input.Change(false); box.Checked.Should().Be(false); input.Change(true); box.Checked.Should().Be(true); }
public async Task TextFieldWithNullableTypes() { var comp = ctx.RenderComponent <MudTextField <int?> >(ComponentParameter.CreateParameter("Value", 17)); // print the generated html Console.WriteLine(comp.Markup); var textfield = comp.Instance; await comp.InvokeAsync(() => textfield.Value = null); comp.Find("input").Blur(); comp.FindAll("div.mud-input-error").Count.Should().Be(0); await comp.InvokeAsync(() => textfield.Text = ""); comp.Find("input").Blur(); comp.FindAll("div.mud-input-error").Count.Should().Be(0); }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "MaxHealth": maxHealth = parameter.GetValue <int>(); currentHealth = maxHealth; break; case "CurrentHealth": currentHealth = parameter.GetValue <int>(); break; } }
public async Task TextFieldUpdateLoopProtectionTest() { var comp = Context.RenderComponent <MudTextField <string> >(); // these conversion funcs are nonsense of course, but they are designed this way to // test against an infinite update loop that textfields and other inputs are now protected against. var textfield = comp.Instance; textfield.Converter.SetFunc = s => $"{s}x"; textfield.Converter.GetFunc = s => $"{s}y"; comp.SetParametersAndRender(ComponentParameter.CreateParameter("Value", "A")); textfield.Value.Should().Be("A"); textfield.Text.Should().Be("Ax"); comp.Find("input").Change("B"); textfield.Value.Should().Be("By"); textfield.Text.Should().Be("B"); }
public void Numeric_Formatted() { using var ctx = new TestContext(); double valueToTest = 100.234; string format = "0.00"; var component = ctx.RenderComponent <RadzenNumeric <double> >( ComponentParameter.CreateParameter(nameof(RadzenNumeric <double> .Format), format), ComponentParameter.CreateParameter(nameof(RadzenNumeric <double> .Value), valueToTest) ); component.Render(); Assert.Contains($" value=\"{valueToTest.ToString(format)}\"", component.Markup); }
public IComponentBuilder <TComponent> RenderFragment <T>( Expression <Func <TComponent, RenderFragment <T> > > expression, Action <IComponentBuilder <T> > builderCallback ) where T : class, IComponent { var propertyName = GetPropertyName(expression); var builder = new ComponentBuilder <T>(); builderCallback(builder); _componentParameters.Add( ComponentParameter.CreateParameter( propertyName, builder.ToRenderFragment() ) ); return(this); }
public async Task TextFieldWithNullableTypes() { using var ctx = new Bunit.TestContext(); //ctx.Services.AddSingleton<NavigationManager>(new MockNavigationManager()); var comp = ctx.RenderComponent <MudTextField <int?> >(ComponentParameter.CreateParameter("Value", 17)); // print the generated html Console.WriteLine(comp.Markup); var textfield = comp.Instance; await comp.InvokeAsync(() => textfield.Value = null); comp.Find("input").Blur(); comp.FindAll("div.mud-input-error").Count.Should().Be(0); await comp.InvokeAsync(() => textfield.Text = ""); comp.Find("input").Blur(); comp.FindAll("div.mud-input-error").Count.Should().Be(0); }
private void InitializeHttpCallNewItem(ComponentParameter userIdParameter) { int userId = (int)userIdParameter.Value; MockHttp.Expect(HttpMethod.Get, $"http://localhost/User/GetUser/{userId}") .RespondValues(new UserObject { Id = userId == ThisUser.Id ? ThisUserDatabaseId : userId, UserName = "******" }); MockHttp.Expect(HttpMethod.Get, "http://localhost/StarpointsManager/GetStarpointsType/-1") .RespondValues(new[] { new StarpointsType { Id = 1 } }); if (userId != ThisUser.Id) { MockHttp.Expect(HttpMethod.Get, $"http://localhost/User/GetUserStartechs/{userId}") .RespondValues(new[] { Startechs.Dotnet }); } }
public async Task when_suppressing_item_if_the_pop_up_retrieve_no_the_item_should_not_be_suppressed() { ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => false)); bool hasCallRemoveCallback = false; var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true); var starpointsItem = CreateStarpointsItem(); Authorize(starpointsItem, false); var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem) , ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack)); component.WaitForState(() => component.Nodes?.Length > 0); await component.Instance.CancelItem(); await Task.Delay(30); hasCallRemoveCallback.Should().BeFalse(); }
public async Task when_updating_status_the_update_status_api_method_should_be_called() { ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true)); var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => { }); var starpointsItem = CreateStarpointsItem(); MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK); Authorize(starpointsItem, false); var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem) , ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack)); component.WaitForState(() => component.Nodes?.Length > 0); await component.Instance.CancelItem(); await Task.Delay(30); MockHttp.VerifyNoOutstandingExpectation(); }
public async Task FormValidationTest1() { var validationFunc = new Func <string, bool>(x => x?.StartsWith("Marilyn") == true); var comp = ctx.RenderComponent <FormValidationTest>(ComponentParameter.CreateParameter("validation", validationFunc)); Console.WriteLine(comp.Markup); var form = comp.FindComponent <MudForm>().Instance; var textFieldcomp = comp.FindComponent <MudTextField <string> >(); var textField = textFieldcomp.Instance; // check initial state: form should not be valid, but text field does not display an error initially! form.IsValid.Should().Be(false); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); // this rock star starts with Marilyn textFieldcomp.Find("input").Change("Marilyn Manson"); form.IsValid.Should().Be(true); form.Errors.Length.Should().Be(0); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); // this rock star doesn't start with Marilyn textFieldcomp.Find("input").Change("Kurt Cobain"); form.IsValid.Should().Be(false); form.Errors.Length.Should().Be(1); textField.Error.Should().BeTrue(); textField.ErrorText.Should().Be("Invalid"); // note: this logic is invalid, so it was removed. Validaton funcs are always called // the validation func must validate non-required empty fields as valid. // //// value is not required, so don't call the validation func on empty text //await comp.InvokeAsync(() => textField.Value = ""); //form.IsValid.Should().Be(true); //form.Errors.Length.Should().Be(0); //textField.Error.Should().BeFalse(); //textField.ErrorText.Should().BeNullOrEmpty(); // ok, not a rock star, but a star nonetheless textFieldcomp.Find("input").Change("Marilyn Monroe"); form.IsValid.Should().Be(true); form.Errors.Length.Should().Be(0); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "damageAmount": damageAmount = parameter.GetValue <int>(); break; case "damageType": if (parameter.ParameterType == typeof(string)) { //Try to parse it. Set to Bludgeoning damagetype if parsing fails if (!Enum.TryParse(parameter.GetValue <string>(), true, out damType)) { damType = DamageType.Bludgeoning; } } else if (parameter.ParameterType == typeof(DamageType)) { damType = parameter.GetValue <DamageType>(); } break; case "startActive": active = parameter.GetValue <bool>(); break; case "toggleable": toggleable = parameter.GetValue <bool>(); if (!toggleable) { active = true; } break; case "inactiveSprite": inactiveSprite = parameter.GetValue <string>(); break; case "activeSprite": activeSprite = parameter.GetValue <string>(); break; } }
protected IRenderedComponent <TComnponent> CreateComponent(string userName, string role, string?id) { Factory.ConfigureTestContext(userName, new Claim[] { new Claim("scope", SharedConstants.ADMINSCOPE), new Claim("role", SharedConstants.READERPOLICY), new Claim("role", role), new Claim("sub", Guid.NewGuid().ToString()) }, this); var component = RenderComponent <TComnponent>(ComponentParameter.CreateParameter("Id", id)); component.WaitForState(() => !component.Markup.Contains("Loading..."), TimeSpan.FromMinutes(1)); return(component); }
public async Task TextField_Data_Annotation_Resolve_Name_Of_Field() { var model = new TestDataAnnotationModel(); var comp = Context.RenderComponent <MudTextField <string> >(ComponentParameter.CreateParameter("For", (Expression <Func <string> >)(() => model.Foo1))); await comp.InvokeAsync(() => comp.Instance.Validate()); comp.Instance.Error.Should().BeTrue(); comp.Instance.ValidationErrors.Should().HaveCount(1); comp.Instance.ValidationErrors[0].Should().Be($"The {nameof(TestDataAnnotationModel.Foo1)} field is required."); comp.Instance.GetErrorText().Should().Be($"The {nameof(TestDataAnnotationModel.Foo1)} field is required."); await comp.InvokeAsync(() => { comp.Instance.Value = "Foo"; comp.Instance.Validate(); }); comp.Instance.Error.Should().BeFalse(); comp.Instance.ValidationErrors.Should().HaveCount(0); }
public async Task when_suppressing_item_if_the_pop_up_retrieve_yes_the_item_should_be_suppressed() { ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true)); bool hasCallRemoveCallback = false; var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true); var starpointsItem = CreateStarpointsItem(); MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK); Authorize(starpointsItem, false); var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem) , ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack)); component.WaitForState(() => component.Nodes?.Length > 0); await component.Instance.CancelItem(); await Task.Delay(30); hasCallRemoveCallback.Should().BeTrue(); }
public void CheckBoxTest2() { using var ctx = new Bunit.TestContext(); var comp = ctx.RenderComponent <MudCheckBox <bool> >(new [] { ComponentParameter.CreateParameter("Checked", true), }); // print the generated html Console.WriteLine(comp.Markup); // select elements needed for the test var box = comp.Instance; var input = comp.Find("input"); // check initial state box.Checked.Should().Be(true); // click and check if it has toggled input.Change(false); box.Checked.Should().Be(false); input.Change(true); box.Checked.Should().Be(true); }
public async Task FormValidationTest1() { using var ctx = new Bunit.TestContext(); var validationFunc = new Func <string, Task <bool> >(async x => x?.StartsWith("Marilyn") == true); var comp = ctx.RenderComponent <FormValidationTest>(ComponentParameter.CreateParameter("validation", validationFunc)); Console.WriteLine(comp.Markup); var form = comp.FindComponent <MudForm>().Instance; var textField = comp.FindComponent <MudTextField <string> >().Instance; // check initial state: form should not be valid, but text field does not display an error initially! form.IsValid.Should().Be(false); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); await comp.InvokeAsync(() => textField.Value = "Marilyn Manson"); form.IsValid.Should().Be(true); form.Errors.Length.Should().Be(0); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); // this rock star doesn't start with Marilyn await comp.InvokeAsync(() => textField.Value = "Kurt Cobain"); form.IsValid.Should().Be(false); form.Errors.Length.Should().Be(1); textField.Error.Should().BeTrue(); textField.ErrorText.Should().Be("Invalid"); // value is not required, so don't call the validation func on empty text await comp.InvokeAsync(() => textField.Value = ""); form.IsValid.Should().Be(true); form.Errors.Length.Should().Be(0); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); // ok, not a rock star, but a star nonetheless await comp.InvokeAsync(() => textField.Value = "Marilyn Monroe"); form.IsValid.Should().Be(true); form.Errors.Length.Should().Be(0); textField.Error.Should().BeFalse(); textField.ErrorText.Should().BeNullOrEmpty(); }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "startState": _state = (LightState) Enum.Parse(typeof (LightState), parameter.GetValue<string>(), true); break; case "lightColorR": _colorR = int.Parse(parameter.GetValue<string>()); break; case "lightColorG": _colorG = int.Parse(parameter.GetValue<string>()); break; case "lightColorB": _colorB = int.Parse(parameter.GetValue<string>()); break; } }
/// <summary> /// Set parameters :) /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { //base.SetParameter(parameter); switch (parameter.MemberName) { case "drawdepth": SetDrawDepth((DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue <string>(), true)); break; case "basename": basename = parameter.GetValue <string>(); LoadSprites(); break; case "addsprite": var spriteToAdd = parameter.GetValue <string>(); LoadSprites(spriteToAdd); break; } }
public async Task ChipSet_MultiSelection_DefaultChipsShouldBeInitiallySelected() { var comp = Context.RenderComponent <ChipSetDefaultChipsTest>(ComponentParameter.CreateParameter("MultiSelection", true)); // print the generated html //Console.WriteLine(comp.Markup); // select elements needed for the test var chipset = comp.FindComponent <MudChipSet>(); comp.FindAll("div.mud-chip").Count.Should().Be(7); chipset.Instance.SelectedChips.Length.Should().Be(2); comp.FindAll("p")[0].TrimmedText().Should().Be("Eggs, Salad"); // select cornflakes comp.FindAll("div.mud-chip")[3].Click(); comp.FindAll("p")[0].TrimmedText().Should().Be("Corn flakes, Eggs, Salad"); string.Join(", ", chipset.Instance.SelectedChips.Select(x => x.Text).OrderBy(x => x)).Should().Be("Corn flakes, Eggs, Salad"); // de-select eggs comp.FindAll("div.mud-chip")[1].Click(); comp.FindAll("p")[0].TrimmedText().Should().Be("Corn flakes, Salad"); string.Join(", ", chipset.Instance.SelectedChips.Select(x => x.Text).OrderBy(x => x)).Should().Be("Corn flakes, Salad"); }
/// <summary> /// Set parameters :) /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { //base.SetParameter(parameter); switch (parameter.MemberName) { case "drawdepth": SetDrawDepth((DrawDepth) Enum.Parse(typeof (DrawDepth), parameter.GetValue<string>(), true)); break; case "basename": _basename = parameter.GetValue<string>(); LoadSprites(); break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "healAmount": healAmount = parameter.GetValue<int>(); break; case "damageType": if (parameter.ParameterType == typeof (string)) { //Try to parse it. Set to Bludgeoning damagetype if parsing fails if (!Enum.TryParse(parameter.GetValue<string>(), true, out damType)) damType = DamageType.Bludgeoning; } else if (parameter.ParameterType == typeof (DamageType)) { damType = parameter.GetValue<DamageType>(); } break; case "capacity": capacity = parameter.GetValue<int>(); break; } }
public override void HandleExtendedParameters(XElement extendedParameters) { foreach (XElement itemcapability in extendedParameters.Descendants("ItemCapability")) { IEnumerable<XElement> Verbs = itemcapability.Descendants("ItemCapabilityVerb"); IEnumerable<XElement> Parameters = itemcapability.Descendants("ItemCapabilityParameter"); ItemCapability cap = null; switch (itemcapability.Attribute("name").Value) { case "MeleeWeaponCapability": cap = new MeleeWeaponCapability(); break; case "ToolCapability": cap = new ToolCapability(); break; case "GunCapability": cap = new GunCapability(); break; case "MedicalCapability": cap = new MedicalCapability(); break; case "HealthScanCapability": cap = new HealthScanCapability(); break; case "BreatherCapability": cap = new BreatherCapability(); break; } if (cap == null) return; foreach (XElement verb in Verbs) { cap.AddVerb(int.Parse(verb.Attribute("priority").Value), (ItemCapabilityVerb) Enum.Parse(typeof (ItemCapabilityVerb), verb.Attribute("name").Value)); } foreach (XElement parameter in Parameters) { string name = parameter.Attribute("name").Value; Type type = EntityTemplate.TranslateType(parameter.Attribute("type").Value); object value = Convert.ChangeType(parameter.Attribute("value").Value, type); var cparam = new ComponentParameter(name, value); cap.SetParameter(cparam); } AddCapability(cap); } }
/// <summary> /// Sets a parameter for a component type for this template /// </summary> /// <param name="componentType">The type of the component to set a parameter on</param> /// <param name="parameter">The parameter object</param> public void SetParameter(string componentType, ComponentParameter parameter) { if (_parameters.ContainsKey(componentType)) _parameters[componentType].Add(parameter); }
/// <summary> /// Parameter Setting /// Settable params: /// TweakAABB - Vector4D /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "TweakAABB": TweakAABB = parameter.GetValue<Vector4D>(); break; case "TweakAABBtop": tweakAABB.X = parameter.GetValue<float>(); break; case "TweakAABBright": tweakAABB.Y = parameter.GetValue<float>(); break; case "TweakAABBbottom": tweakAABB.Z = parameter.GetValue<float>(); break; case "TweakAABBleft": tweakAABB.W = parameter.GetValue<float>(); break; } }
/// <summary> /// Parameter Setting /// Settable params: /// TweakAABB - Vector4 /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "TweakAABB": TweakAABB = parameter.GetValue<Vector4f>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBtop": tweakAABB.X = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBright": tweakAABB.Y = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBbottom": tweakAABB.Z = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBleft": tweakAABB.W = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "DebugColor": DebugColor = ColorUtils.FromHex(parameter.GetValue<string>(), Color.Red); break; } }
public MarshalComponentParameter(ComponentFamily family, ComponentParameter parameter) { Family = family; Parameter = parameter; }
public void LoadFromXml(XElement templateElement) { Name = templateElement.Attribute("name").Value; IEnumerable<XElement> tComponents = templateElement.Element("Components").Elements(); //Parse components foreach (XElement tComponent in tComponents) { string componentname = tComponent.Attribute("name").Value; _components.Add(componentname); _parameters.Add(componentname, new List<ComponentParameter>()); IEnumerable<XElement> tComponentParameters = from tParam in tComponent.Descendants("Parameter") select tParam; //Parse component parameters foreach (XElement tComponentParameter in tComponentParameters) { if (tComponentParameter.Attribute("type").Value == "" || tComponentParameter.Attribute("name").Value == "") throw new ArgumentException("Component Parameter name or type not set."); //Get the specified type Type paramType = TranslateType(tComponentParameter.Attribute("type").Value); //Get the raw value string paramRawValue = tComponentParameter.Attribute("value").Value; //Validate string paramName = tComponentParameter.Attribute("name").Value; if (paramType == null) throw new TemplateLoadException("Invalid parameter type specified."); if (paramName == "") throw new TemplateLoadException("Invalid parameter name specified."); //Convert the raw value to the proper type object paramValue; // = Convert.ChangeType(tComponentParameter.Attribute("value").Value, paramType); if (paramType == typeof (int)) { int pval; if (!int.TryParse(paramRawValue, out pval)) throw new ArgumentException("Could not parse parameter " + paramName + " as int. Value: " + paramRawValue); paramValue = pval; } else if (paramType == typeof (float)) { float pval; if (!float.TryParse(paramRawValue, NumberStyles.Float, CultureInfo.InvariantCulture, out pval)) throw new ArgumentException("Could not parse parameter " + paramName + " as float. Value: " + paramRawValue); paramValue = pval; } else if (paramType == typeof (bool)) { bool pval; if (!bool.TryParse(paramRawValue, out pval)) throw new ArgumentException("Could not parse parameter " + paramName + " as bool. Value: " + paramRawValue); paramValue = pval; } else if (paramType == typeof (string)) { paramValue = paramRawValue; } else if (paramType == typeof (Vector2)) { var args = paramRawValue.Split(','); if (args.Length != 2) throw new ArgumentException("Could not parse parameter " + paramName + " as Vector2. Value: " + paramRawValue); paramValue = new Vector2(float.Parse(args[0]), float.Parse(args[1])); } else if (paramType == typeof(Vector3)) { var args = paramRawValue.Split(','); if (args.Length != 3) throw new ArgumentException("Could not parse parameter " + paramName + " as Vector3. Value: " + paramRawValue); paramValue = new Vector3(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2])); } else if (paramType == typeof(Vector4)) { var args = paramRawValue.Split(','); if (args.Length != 4) throw new ArgumentException("Could not parse parameter " + paramName + " as Vector4. Value: " + paramRawValue); paramValue = new Vector4(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2]), float.Parse(args[3])); } else { throw new ArgumentException("Could not parse parameter " + paramName + ". Type not recognized. Value: " + paramRawValue); } var cparam = new ComponentParameter(paramName, paramValue); _parameters[componentname].Add(cparam); } if (tComponent.Element("ExtendedParameters") != null) { _parameters[componentname].Add(new ComponentParameter("ExtendedParameters", tComponent.Element("ExtendedParameters"))); } } XElement t_placementprops = templateElement.Element("PlacementProperties"); //Load Placement properties. if (t_placementprops != null) { LoadPlacementProperties(t_placementprops); } else { PlacementMode = "AlignNone"; } XElement tDescription = templateElement.Element("Description"); if (tDescription != null) Description = tDescription.Attribute("string").Value; }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "AddEffect": AddEffect(parameter.GetValue<string>(), 10); break; default: base.SetParameter(parameter); break; } }
public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "MaxHealth": maxHealth = parameter.GetValue<int>(); currentHealth = maxHealth; break; case "CurrentHealth": currentHealth = parameter.GetValue<int>(); break; } }
/// <summary> /// This allows setting of the component's parameters once it is instantiated. /// This should basically be overridden by every inheriting component, as parameters will be different /// across the board. /// </summary> /// <param name="parameter">ComponentParameter object describing the parameter and the value</param> public virtual void SetParameter(ComponentParameter parameter) { }
/// <summary> /// Parameter Setting /// Settable params: /// TweakAABB - Vector4 /// </summary> /// <param name="parameter"></param> public override void SetParameter(ComponentParameter parameter) { base.SetParameter(parameter); switch (parameter.MemberName) { case "TweakAABB": TweakAABB = parameter.GetValue<Vector4>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBtop": tweakAABB.X = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBright": tweakAABB.Y = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBbottom": tweakAABB.Z = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "TweakAABBleft": tweakAABB.W = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize; break; case "DebugColor": var color = ColorTranslator.FromHtml(parameter.GetValue<string>()); if (!color.IsEmpty) DebugColor = color; break; } }
public override void SetParameter(ComponentParameter parameter) { switch (parameter.MemberName) { case "damageAmount": damageAmount = parameter.GetValue<int>(); break; case "damageType": if (parameter.ParameterType == typeof (string)) { //Try to parse it. Set to Bludgeoning damagetype if parsing fails if (!Enum.TryParse(parameter.GetValue<string>(), true, out damType)) damType = DamageType.Bludgeoning; } else if (parameter.ParameterType == typeof (DamageType)) { damType = parameter.GetValue<DamageType>(); } break; case "startActive": active = parameter.GetValue<bool>(); break; case "toggleable": toggleable = parameter.GetValue<bool>(); if (!toggleable) active = true; break; case "inactiveSprite": inactiveSprite = parameter.GetValue<string>(); break; case "activeSprite": activeSprite = parameter.GetValue<string>(); break; } }