protected override async Task OnInitializedAsync() { _title = ModuleState.Title; _containers = ThemeService.GetContainerControls(await ThemeService.GetThemesAsync(), PageState.Page.ThemeType); _containerType = ModuleState.ContainerType; if (!string.IsNullOrEmpty(PageState.Page.DefaultContainerType) && _containerType == PageState.Page.DefaultContainerType) { _containerType = "-"; } if (_containerType == PageState.Site.DefaultContainerType) { _containerType = "-"; } _allPages = ModuleState.AllPages.ToString(); _permissions = ModuleState.Permissions; _permissionNames = ModuleState.ModuleDefinition.PermissionNames; _pageId = ModuleState.PageId.ToString(); _settingsModuleType = Type.GetType(ModuleState.ModuleType); if (_settingsModuleType != null) { var moduleobject = Activator.CreateInstance(_settingsModuleType) as IModuleControl; _settingstitle = moduleobject.Title; if (string.IsNullOrEmpty(_settingstitle)) { _settingstitle = "Other Settings"; } DynamicComponent = builder => { builder.OpenComponent(0, _settingsModuleType); builder.AddComponentReferenceCapture(1, inst => { _settings = Convert.ChangeType(inst, _settingsModuleType); }); builder.CloseComponent(); }; } }
public override async Task SetParametersAsync(ParameterView parameters) { foreach (var p in parameters) { switch (p.Name) { case nameof(Toast): { if (Toast != null) { Toast.OnUpdate -= ToastUpdated; } Toast = (MatToast)p.Value; Toast.OnUpdate += ToastUpdated; EnsureInitialized(); Css = builder => { var transitionClass = TransitionClass; if (string.IsNullOrEmpty(transitionClass)) { return; } builder.OpenElement(1, "style"); builder.AddContent(2, transitionClass); builder.CloseElement(); }; break; } } } await base.SetParametersAsync(parameters); }
private RenderFragment GenerateIl(bool isDisabled, RenderFragment innerHtml, bool isActive = false) { RenderFragment tempDynamicResult; var classAtrr = "page-item"; if (isDisabled && !isActive) { classAtrr += " disabled"; } if (isActive) { classAtrr += " active"; } return(tempDynamicResult = builder => { builder.OpenElement(1, "il"); builder.AddAttribute(2, "class", classAtrr); builder.AddContent(3, innerHtml); builder.CloseElement(); }); }
/// <inheritdoc /> public void SetParameters(ParameterCollection parameters) { attributes = parameters.ToDictionary() as Dictionary <string, object>; // Capture the parameters we want to do special things with, plus all as a dictionary childContent = GetAndRemove <RenderFragment>(attributes, RenderTreeBuilder.ChildContent); tagName = GetAndRemove <string>(attributes, "TagName"); className = GetAndRemove <string>(attributes, "class"); Match = GetAndRemove <Match>(attributes, "Match"); //parameters.TryGetValue( RenderTreeBuilder.ChildContent, out childContent ); //parameters.TryGetValue( "TagName", out tagName ); //parameters.TryGetValue( "class", out className ); parameters.TryGetValue("href", out string href); //Match = parameters.GetValueOrDefault( nameof( Match ), Match.Prefix ); // Update computed state and render hrefAbsolute = href == null ? string.Empty : UriHelper.ToAbsoluteUri(href).AbsoluteUri; isActive = ShouldMatch(UriHelper.GetAbsoluteUri()); renderHandle.Render(Render); }
public void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment renderFragment) { // A component might be in the render queue already before getting disposed by an // earlier entry in the render queue. In that case, rendering is a no-op. if (_componentWasDisposed) { return; } // Swap the old and new tree builders (_renderTreeBuilderCurrent, _renderTreeBuilderPrevious) = (_renderTreeBuilderPrevious, _renderTreeBuilderCurrent); _renderTreeBuilderCurrent.Clear(); renderFragment(_renderTreeBuilderCurrent); var diff = RenderTreeDiffBuilder.ComputeDiff( _renderer, batchBuilder, _componentId, _renderTreeBuilderPrevious.GetFrames(), _renderTreeBuilderCurrent.GetFrames()); batchBuilder.UpdatedComponentDiffs.Append(diff); }
/// <summary> /// Shows the modal with the component type using the specified <paramref name="title"/>, /// passing the specified <paramref name="parameters"/> and setting a custom CSS style. /// </summary> /// <param name="contentComponent">Type of component to display.</param> /// <param name="title">Modal title.</param> /// <param name="parameters">Key/Value collection of parameters to pass to component being displayed.</param> /// <param name="options">Options to configure the modal.</param> public IModalReference Show(Type contentComponent, string title, ModalParameters parameters, ModalOptions options) { if (!typeof(IComponent).IsAssignableFrom(contentComponent)) { throw new ArgumentException($"{contentComponent.FullName} must be a Blazor Component"); } var modalInstanceId = Guid.NewGuid(); ModalReference modalReference = null; var modalContent = new RenderFragment(builder => { var i = 0; builder.OpenComponent(i++, contentComponent); foreach (var parameter in parameters._parameters) { builder.AddAttribute(i++, parameter.Key, parameter.Value); } builder.CloseComponent(); }); var modalInstance = new RenderFragment(builder => { builder.OpenComponent <BlazoredModalInstance>(0); builder.AddAttribute(1, "Options", options); builder.AddAttribute(2, "Title", title); builder.AddAttribute(3, "Content", modalContent); builder.AddAttribute(4, "Id", modalInstanceId); builder.AddComponentReferenceCapture(5, compRef => modalReference.ModalInstanceRef = (BlazoredModalInstance)compRef); builder.CloseComponent(); }); modalReference = new ModalReference(modalInstanceId, modalInstance, this); OnModalInstanceAdded?.Invoke(modalReference); return(modalReference); }
#pragma warning restore 0414 #pragma warning disable 1998 protected override void BuildRenderTree(Microsoft.AspNetCore.Components.RenderTree.RenderTreeBuilder builder) { base.BuildRenderTree(builder); #line 2 "x:\dir\subdir\Test\TestComponent.cshtml" RenderFragment <Test.Context> template = (context) => #line default #line hidden (builder2) => { #line 2 "x:\dir\subdir\Test\TestComponent.cshtml" __o = context.Index; #line default #line hidden #line 2 "x:\dir\subdir\Test\TestComponent.cshtml" __o = context.Item.ToLower(); #line default #line hidden } #line 2 "x:\dir\subdir\Test\TestComponent.cshtml" ; #line default #line hidden __o = new Microsoft.AspNetCore.Components.RenderFragment <Test.Context>( #line 3 "x:\dir\subdir\Test\TestComponent.cshtml" template #line default #line hidden ); builder.AddAttribute(-1, "ChildContent", (Microsoft.AspNetCore.Components.RenderFragment)((builder2) => { } )); }
public void Show(Type contentComponent, string title, ModalParameters parameters, ModalOptions options) { if (!typeof(ComponentBase).IsAssignableFrom(contentComponent)) { throw new ArgumentException("Must be a Blazor Component!"); } var content = new RenderFragment(x => { x.OpenComponent(1, contentComponent); x.CloseComponent(); }); var onShowEventArgs = new OnShowEventArgs() { Title = title, Content = content, Parameters = parameters, Options = options, }; this.modalType = contentComponent; this.OnShow?.Invoke(this, onShowEventArgs); }
private static RenderFragment WrapInLayout([DynamicallyAccessedMembers(Component)] Type layoutType, RenderFragment bodyParam) { void Render(RenderTreeBuilder builder) { builder.OpenComponent(0, layoutType); builder.AddAttribute(1, LayoutComponentBase.BodyPropertyName, bodyParam); builder.CloseComponent(); }; return(Render); }
public IRendererTreeBuilder AddContent(RenderFragment fragment) { renderTreeBuilder.AddContent(++sequence, fragment); return(this); }
/// <summary> /// Shows a warning toast /// </summary> /// <param name="message">RenderFragment to display on the toast</param> /// <param name="heading">The text to display as the toasts heading</param> public void ShowWarning(RenderFragment message, string heading = "") { ShowToast(ToastLevel.Warning, message, heading); }
/// <summary> /// Shows a information toast /// </summary> /// <param name="message">RenderFragment to display on the toast</param> /// <param name="heading">The text to display as the toasts heading</param> public void ShowInfo(RenderFragment message, string heading = "") { ShowToast(ToastLevel.Info, message, heading); }
public ISpecialColumnFragmentsCollection <TItem> AddColumnValueRenderFunction <TColumn>(Expression <Func <TItem, TColumn> > columnExpression, RenderFragment <TItem> renderFragment) { var entityType = gridConfigurationProvider.FindGridEntityConfigurationByType(typeof(TItem)); if (entityType is NullEntityType) { var entityTypeBuilder = internalModelBuilder .Entity(typeof(TItem)) .Property(columnExpression.GetPropertyAccess()) .HasBlazorComponentValue(renderFragment); return(this); } var columnName = columnExpression.GetPropertyAccess().Name; var configurationProperty = entityType.FindProperty(columnName); if (configurationProperty is Property property) { new InternalPropertyBuilder(property, internalModelBuilder) .HasBlazorComponentValue(renderFragment); } return(this); }
/// <inheritdoc /> protected override void BuildRenderTree(RenderTreeBuilder builder) { if (_refreshException != null) { Exception?oldRefreshException = _refreshException; _refreshException = null; throw oldRefreshException; } builder.OpenElement(0, "div"); if (UseGridFlexLayout) { builder.AddAttribute(1, "style", "display:flex;flex-flow: row wrap;"); } builder.OpenElement(2, "div"); builder.AddAttribute(3, "style", GetSpacerStyle(_itemsBefore)); builder.AddElementReferenceCapture(4, elementReference => _spacerBefore = elementReference); builder.CloseElement(); int lastItemIndex = Math.Min(_itemsBefore + _visibleItemCapacity, _itemCount); int renderIndex = _itemsBefore; int placeholdersBeforeCount = Math.Min(_loadedItemsStartIndex, lastItemIndex); builder.OpenRegion(5); // Render placeholders before the loaded items. for (; renderIndex < placeholdersBeforeCount; renderIndex++) { // This is a rare case where it's valid for the sequence number to be programmatically incremented. // This is only true because we know for certain that no other content will be alongside it. builder.AddContent(renderIndex, _placeholder, new PlaceholderContext(renderIndex, _itemSize)); } builder.CloseRegion(); _lastRenderedItemCount = 0; // Render the loaded items. if (_loadedItems != null && _itemTemplate != null) { IEnumerable <TItem>?itemsToShow = _loadedItems .Skip(_itemsBefore - _loadedItemsStartIndex) .Take(lastItemIndex - _loadedItemsStartIndex); builder.OpenRegion(6); foreach (TItem?item in itemsToShow) { builder.OpenElement(11, "div"); builder.SetKey(item); //builder.AddAttribute(8, "data-selection-index", _lastRenderedItemCount + _itemsBefore - _loadedItemsStartIndex + StartIndex); _itemTemplate(new IndexedItem <TItem> { Item = item, Index = renderIndex + _lastRenderedItemCount + StartIndex })(builder); _lastRenderedItemCount++; builder.CloseElement(); } renderIndex += _lastRenderedItemCount; builder.CloseRegion(); } _lastRenderedPlaceholderCount = Math.Max(0, lastItemIndex - _itemsBefore - _lastRenderedItemCount); builder.OpenRegion(12); // Render the placeholders after the loaded items. for (; renderIndex < lastItemIndex; renderIndex++) { builder.AddContent(renderIndex, _placeholder, new PlaceholderContext(renderIndex, _itemSize)); } builder.CloseRegion(); int itemsAfter = Math.Max(0, _itemCount - _visibleItemCapacity - _itemsBefore); builder.OpenElement(13, "div"); builder.AddAttribute(14, "style", GetSpacerStyle(itemsAfter)); builder.AddElementReferenceCapture(15, elementReference => _spacerAfter = elementReference); builder.CloseElement(); //builder.AddElementReferenceCapture(13, elemRef => RootElementReference = elemRef); builder.CloseElement(); }
protected override void OnInitialized() { base.OnInitialized(); // ReSharper disable once RedundantAssignment Debugger = builder => { var seq = 0; builder.OpenElement(seq++, "style"); builder.AddContent(seq++, @".redux-debugger { display: flex; flex-wrap: wrap; } .redux-debugger__historic-entry { background-color: WhiteSmoke; padding: .5em; } .redux-debugger__historic-entry:hover { background-color: Gainsboro; } .redux-debugger__historic-entry--selected, .redux-debugger__historic-entry--selected:hover { background-color: #4189C7; color: White; } .redux-debugger__historic-entry__action { font-weight: bold; } .redux-debugger__action-details { padding: .5em; }"); builder.CloseElement(); builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger"); builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger__action-history"); foreach (var entry in Store.History) { Callback callback = () => SelectEntry(entry); builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry " + (entry == _selectedEntry ? "redux-debugger__historic-entry--selected" : "")); builder.AddAttribute(seq++, "onclick", callback); builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry__action"); builder.AddContent(seq++, entry.Action?.ToString() ?? "Initial state"); builder.CloseElement(); builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry__time"); builder.AddContent(seq++, entry.Time.ToUniversalTime().ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff'Z'")); builder.CloseElement(); builder.CloseElement(); // historic-entry } builder.CloseElement(); // action-history builder.OpenElement(seq++, "div"); builder.AddAttribute(seq++, "class", "redux-debugger__action-details"); seq = RenderActionDetails(builder, seq, _selectedEntry); builder.CloseElement(); // action-details builder.CloseElement(); // redux-debugger }; }
private static RenderFragment RenderArray <T>(this IEnumerable <T> seq, RenderFragment <T> itemTemlpate) => sub => seq .Aggregate(sub, Render(itemTemlpate));
public static Func <RenderTreeBuilder, T, RenderTreeBuilder> Render <T>(this RenderFragment <T> itemTemlpate) => (b, t) => { itemTemlpate(t).Invoke(b); return(b); };
public PropertyBuilder <TProperty, TEntity> HasBlazorComponentValueRender(RenderFragment <TEntity> fragment) { Builder.HasBlazorComponentValue(fragment); return(this); }
/// <summary> /// Constructs an instance of <see cref="DynamicComponent"/>. /// </summary> public DynamicComponent() { _cachedRenderFragment = Render; }
public async Task OnRenderCompletedAsync_DoesNotThrowWhenThereAreNoPendingBatchesToAck() { // Arrange var serviceProvider = CreateServiceProvider(); var firstBatchTCS = new TaskCompletionSource <object>(); var secondBatchTCS = new TaskCompletionSource <object>(); var offlineClient = new CircuitClientProxy(new Mock <IClientProxy>(MockBehavior.Strict).Object, "offline-client"); offlineClient.SetDisconnected(); var renderer = GetRemoteRenderer(serviceProvider, offlineClient); RenderFragment initialContent = (builder) => { builder.OpenElement(0, "my element"); builder.AddContent(1, "some text"); builder.CloseElement(); }; var trigger = new Trigger(); var renderIds = new List <long>(); var onlineClient = new Mock <IClientProxy>(); onlineClient.Setup(c => c.SendCoreAsync(It.IsAny <string>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>())) .Callback((string name, object[] value, CancellationToken token) => renderIds.Add((long)value[1])) .Returns <string, object[], CancellationToken>((n, v, t) => (long)v[1] == 2 ? firstBatchTCS.Task : secondBatchTCS.Task); // This produces the initial batch (id = 2) await renderer.Dispatcher.InvokeAsync(() => renderer.RenderComponentAsync <AutoParameterTestComponent>( ParameterView.FromDictionary(new Dictionary <string, object> { [nameof(AutoParameterTestComponent.Content)] = initialContent, [nameof(AutoParameterTestComponent.Trigger)] = trigger }))); trigger.Component.Content = (builder) => { builder.OpenElement(0, "offline element"); builder.AddContent(1, "offline text"); builder.CloseElement(); }; // This produces an additional batch (id = 3) trigger.TriggerRender(); var originallyQueuedBatches = renderer._unacknowledgedRenderBatches.Count; // Act offlineClient.Transfer(onlineClient.Object, "new-connection"); var task = renderer.ProcessBufferedRenderBatches(); var exceptions = new List <Exception>(); renderer.UnhandledException += (sender, e) => { exceptions.Add(e); }; // Receive the ack for the initial batch _ = renderer.OnRenderCompletedAsync(2, null); // Receive the ack for the second batch _ = renderer.OnRenderCompletedAsync(2, null); firstBatchTCS.SetResult(null); secondBatchTCS.SetResult(null); // Repeat the ack for the third batch _ = renderer.OnRenderCompletedAsync(3, null); // Assert Assert.Empty(exceptions); }
/// <summary> /// Shows a toast using the supplied settings /// </summary> /// <param name="level">Toast level to display</param> /// <param name="message">RenderFragment to display on the toast</param> /// <param name="heading">The text to display as the toasts heading</param> public void ShowToast(ToastLevel level, RenderFragment message, string heading = "") { OnShow?.Invoke(level, message, heading); }
public TestComponent(RenderFragment renderFragment) { _renderFragment = renderFragment; }
/// <summary> /// Shows a success toast /// </summary> /// <param name="message">RenderFragment to display on the toast</param> /// <param name="heading">The text to display as the toasts heading</param> public void ShowSuccess(RenderFragment message, string heading = "") { ShowToast(ToastLevel.Success, message, heading); }
/// <summary> /// Constructs an instance of <see cref="BlazorComponent"/>. /// </summary> public BlazorComponent() { _renderFragment = BuildRenderTree; }
/// <summary> /// Shows a error toast /// </summary> /// <param name="message">RenderFragment to display on the toast</param> /// <param name="heading">The text to display as the toasts heading</param> public void ShowError(RenderFragment message, string heading = "") { ShowToast(ToastLevel.Error, message, heading); }
public async Task ShowAsync(string title, RenderFragment body) { await ShowAsync(title, body, ModalDialogSize.Default); }
internal AntTimelineItem(RenderFragment childContent, RenderFragment dot, string @class) { this.ChildContent = childContent; this.Dot = dot; this.Class = @class; }
public async Task ShowAsync(string title, RenderFragment body, ModalDialogSize size) { await OnShow?.Invoke(title, body, size); }
/// <summary> /// Constructs an instance of <see cref="ComponentBase"/>. /// </summary> public ComponentBase() { _renderFragment = BuildRenderTree; }
public static RenderFragment ToRenderFrament <T>( this IEnumerable <T> seq, RenderFragment <T> itemTemplate) => seq.ToRenderFrament(0, itemTemplate);